         }
 
     }
-    /*oneLeaderBoard.loadScoresWithCompletionHandler { (scores, error) ->
-    Void in
-    if error != nil {
-    println("Error: \(error!.localizedDescription)")
-    completion!(result: false)
-    } else if (scores != nil) {
-    print(oneLeaderBoard.identifier)
-    print(oneLeaderBoard.localPlayerScore)
-    self.scoresleaderBoard[oneLeaderBoard.identifier] = oneLeaderBoard.localPlayerScore
-    if completion != nil { completion!(result: true) }
-    }
-    }*/
-    /**
-    Load GKScore of leaderboards in cache
-    
-    :param: completion if load in cache is OK
+    /**
+        get GKScoreOfLeaderboard
+    
+    :param: completion GKScore or nil
     */
     private func  getGKScoreOfLeaderboard(#leaderboardIdentifier:String, completion: ((result:GKScore?) -> Void)) {
 

        }
    }
    /**
    Show banner game center
    
    :param: title       title
    :param: description description
    :param: completion  if show message is showing
    */
    class func showBannerWithTitle(#title:String, description:String,completion: ((isShow:Bool) -> Void)?) {
        GKNotificationBanner.showBannerWithTitle(title, message: description, completionHandler: { () -> Void in
            if completion != nil { completion!(isShow:true) }
        })
    }
    /**
    Remove One Achievements
    
    :param: Achievement Identifier String
    */
    class func resetOneAchievement(#achievementIdentifier :String) {
        
        if let achievement = EasyGameCenter.achievementForIndetifier(identifierAchievement: achievementIdentifier) {
            GKAchievement.resetAchievementsWithCompletionHandler({ (var error:NSError!) ->
                Void in
                
                if error != nil {
                    println("Couldn't Reset achievement (\(achievementIdentifier))")
                    
                } else {
                    
                    achievement.percentComplete = 0
                    achievement.showsCompletionBanner = false
                    println("Reset achievement (\(achievementIdentifier))")
                }
                
            })
        }
    }
    
    /**
    Remove All Achievements
    */
    class func resetAllAchievements() {
        let gameCenter = EasyGameCenter.Static.instance!
        
        for lookupAchievement in gameCenter.achievementsCache {
            
            var achievementID = lookupAchievement.0
            EasyGameCenter.resetOneAchievement(achievementIdentifier: achievementID)
            
        }
    }
    /**
    Get SKScore
    
    :param: Leaderboard Identifier
    
    :returns: return GKScore

    class func getScoreLeaderboard(#leaderboardIdentifier:String) -> GKScore? {
        
        if EasyGameCenter.getStateGameCenter() == .PlayerIdentified  {
            let gameCenter = EasyGameCenter.sharedInstance
            if let scoreLeaderboard = gameCenter.scoresleaderBoard[leaderboardIdentifier] as GKScore? {
                return scoreLeaderboard
            }
        }
        return nil
    }  */
    /**
    CheckUp Connection the new
    
    :returns: Bool Connection Validation
    */
    class func isConnectedToNetwork() -> Bool {
        

                /* try to report the progress to the Game Center */
                GKAchievement.reportAchievements([achievement], withCompletionHandler:  {(var error:NSError!) -> Void in
                    
                    var validation = false
                    
                    if error != nil {
                        println("Couldn't save achievement (\(achievementIdentifier)) progress to \(progress) %")
                        
                    } else {
                        validation = true
                       
                    }
                    
                    if completionIsSend != nil { completionIsSend!(isSendOrNor: validation) }
                })
            }
        }
    }
 
    /**
        If player is Identified to Game Center
    
        :returns: Bool True is identified
    */
    class func isPlayerIdentifiedToGameCenter() -> Bool {
        
        return GKLocalPlayer.localPlayer().authenticated
    }
    /**
        If achievement is Completed
    
        :param: Achievement Identifier
        :return: (Bool) if finished
    */
    class func ifAchievementCompleted(#achievementIdentifier: String) -> Bool{
        
