EasyGameCenter 2.3.2

EasyGameCenter 2.3.2

×

测试已测试✗
Lang语言 SwiftSwift
许可证 MIT
发布最新发布2015年12月
SPM支持SPM✗

由 DaRkD0G 维护。

EasyGameCenter 2.3.2

  • 由
  • DaRkD0G

Easy Game Center \ EGC

Easy Game Center 帮助您管理iOS上的Game Center。报告和跟踪 高分、成就 和 多人游戏。Easy Game Center简化了Game Center的管理。

使用Easy Game Center的iOS游戏

项目功能

  • Swift和Objective-C
  • 管理 多人游戏
  • 管理 排行榜
  • 管理 成就
  • 一行代码即可管理Game Center的大部分功能
  • 成就会储存在缓存中并自动刷新
  • 当玩家连接、断开连接、多人游戏等时，调用代理函数
  • 大部分函数都有完成回调
  • 只需使用EGC.method或EasyGameCenter.method方法即可简单使用

贡献和支援

  • 任何贡献都受到欢迎！您可以通过GitHub上的pull请求和问题进行贡献。:D
  • 如果使用Easy Game Center，请发送您的应用程序链接，我将在封面页上添加
  • 支持联系 问题 或 @YannickSteph

安装

手册

将以下类 EasyGameCenter.swift 添加到您的Xcode项目中（确保在对话框中选择复制项）

将 GameKit 和 SystemConfiguration 框架添加到您的Xcode项目中。
参见

文档

初始化和示例

您可以添加协议 EGCDelegate 以访问代理函数

  • 连接 EGCAuthentified EGCInCache
  • 多人游戏 EGCMatchStarted EGCMatchRecept EGCMatchEnded EGCMatchCancel

EGCDelegate 是可选的，非强制性

class MainViewController: UIViewController, EGCDelegate {
    /**
        This method is called after the view controller has loaded
    */
    override func viewDidLoad() {
        super.viewDidLoad()

        // Init EGC and set delegate UIViewController
        EGC.sharedInstance(self)

        // Will not show automatic Game Center login page
        // EGC.showLoginPage = false

        // If you want see message debug
        // EGC.debugMode = true
    }
    /**
        Notifies the view controller that its view was added to a view hierarchy.
    */
    override func viewDidAppear(animated: Bool) {
        super.viewDidAppear(animated)

        // Set new view controller delegate, that's when you change UIViewController
        // If you have several UIViewController just add this in your UIViewControllers for set new Delegate
        EGC.delegate = self
    }

    /// ############################################################ ///
    ///        Mark: - Delegate function of EasyGameCenter           ///
    /// ############################################################ ///
    /**
        Listener Player is authentified 
        Optional function
    */
    func EGCAuthentified(authentified:Bool) {
        print("Player Authentified = \(authentified)")
    }
    /**
        Listener when Achievements is in cache
        Optional function
    */
    func EGCInCache() {
        // Call when GkAchievement & GKAchievementDescription in cache
    }

    /// ############################################################ ///
    ///  Mark: - Delegate function of EasyGameCenter for MultiPlaye  ///
    /// ############################################################ ///
    /**
        Listener When Match Started
        Optional function
    */
    func EGCMatchStarted() {
        print("MatchStarted")
    }
    /**
        Listener When Match Recept Data
        When player send data to all player
        Optional function
    */
    func EGCMatchRecept(match: GKMatch, didReceiveData data: NSData, fromPlayer playerID: String) {
        // See Packet Example in project
        let strucData =  Packet.unarchive(data)
        print("Recept From player = \(playerID)")
        print("Recept Packet.name = \(strucData.name)")
        print("Recept Packet.index = \(strucData.index)")
    }
    /**
        Listener When Match End
        Optional function
    */
    func EGCMatchEnded() {
        print("MatchEnded")
    }
    /**
        Listener When Match Cancel
        Optional function
    */
    func EGCMatchCancel() {
        print("Match cancel")
    }

显示方法

显示成就

  • 显示拥有成就完成的游戏中心成就
  • 选项：无完成
    EGC.showGameCenterAchievements()
  • 选项：有完成
    EGC.showGameCenterAchievements { 
        (isShow) -> Void in
        if isShow {
                print("Game Center Achievements is shown")
        }
    }

显示排行榜

  • 显示拥有成就完成的游戏中心排行榜
  • 选项：无完成
    EGC.showGameCenterLeaderboard(leaderboardIdentifier: "IdentifierLeaderboard")
  • 选项：有完成
    EGC.showGameCenterLeaderboard(leaderboardIdentifier: "IdentifierLeaderboard") { 
        (isShow) -> Void in
        if isShow {
            print("Game Center Leaderboards is shown")
        }
    }

显示挑战

  • 显示拥有成就完成的游戏中心挑战
  • 选项：无完成
    EGC.showGameCenterChallenges()
  • 选项：有完成
    EGC.showGameCenterChallenges {
        (isShow) -> Void in
        if isShow {
            print("Game Center Challenges Is shown")
        }
    }

显示 Game Center 认证页面

  • 显示拥有成就完成的 Game Center 认证页面
  • 选项：无完成
    EGC.showGameCenterAuthentication()
  • 选项：有完成
    EGC.showGameCenterAuthentication { 
        (result) -> Void in
        if result {
            print("Game Center Authentication is open")
        }
    }

显示自定义横幅

  • 显示拥有成就完成的自定义横幅 Game Center
  • 选项：无完成
    EGC.showCustomBanner(title: "Title", description: "My Description...")
  • 选项：有完成
    EGC.showCustomBanner(title: "Title", description: "My Description...") { 
        print("Custom Banner is finish to Show")
    }

成就方法

进度成就

  • 向成就添加进度并显示横幅
  • 选项：报告成就
    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier")
  • 选项：不显示横幅
    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier", showBannnerIfCompleted: false)
  • 选项：添加到现有成就（与旧成就累加）
    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier", addToExisting: true)
  • 选项：不显示横幅并添加到现有成就（与旧成就累加）
    EGC.reportAchievement(progress: 42.00, achievementIdentifier: "Identifier", showBannnerIfCompleted: false ,addToExisting: true)

如果成就完成

  • 完成的成就
    if EGC.isAchievementCompleted(achievementIdentifier: "Identifier") {
        print("\n[Easy Game Center]Yes\n")
    } else {
        print("\n[Easy Game Center] No\n")
    }

获取所有未显示横幅的已完成成就

  • 获取所有已完成成就和未显示横幅，带有完成选项
    if let achievements : [GKAchievement] = EGC.getAchievementCompleteAndBannerNotShowing() {
        for oneAchievement in achievements  {
            print("\n[Easy Game Center] Achievement where banner not show \(oneAchievement.identifier)\n")
        }
    } else {
        print("\n[Easy Game Center] No Achievements with banner not showing\n")
    }

显示所有未显示横幅的已完成成就

  • 显示所有已完成成就和未显示横幅，带有完成选项
  • 选项：无完成
    EGC.showAllBannerAchievementCompleteForBannerNotShowing()
  • 选项：有完成
    EGC.showAllBannerAchievementCompleteForBannerNotShowing { 
        (achievementShow) -> Void in
        if let achievementIsOK = achievementShow {
            print("\n[Easy Game Center] Achievement show is \(achievementIsOK.identifier)\n")
        } else {
            print("\n[Easy Game Center] No Achievements with banner not showing\n")
        }
    }

获取所有 GKAchievementDescription 成就

  • 获取所有成就描述（GKAchievementDescription），带有完成选项
    EGC.getGKAllAchievementDescription {
        (arrayGKAD) -> Void in
        if let arrayAchievementDescription = arrayGKAD {
            for achievement in arrayAchievementDescription  {
                print("\n[Easy Game Center] ID : \(achievement.identifier)\n")
                print("\n[Easy Game Center] Title : \(achievement.title)\n")
                print("\n[Easy Game Center] Achieved Description : \(achievement.achievedDescription)\n")
                print("\n[Easy Game Center] Unachieved Description : \(achievement.unachievedDescription)\n")
            }
        }
    }

获取成就 GKAchievement

  • 获取单个成就（GKAchievement）
    if let achievement = EGC.getAchievementForIndentifier(identifierAchievement: "AchievementIdentifier") {
        print("\n[Easy Game Center] ID : \(achievement.identifier)\n")
    }

获取成就 GKAchievement GKAchievementDescription（元组）

  • 为标识符成就获取（GKAchievement, GKAchievementDescription）元组
    EGC.getTupleGKAchievementAndDescription(achievementIdentifier: "AchievementIdentifier") {            
        (tupleGKAchievementAndDescription) -> Void in
        if let tupleInfoAchievement = tupleGKAchievementAndDescription {
            // Extract tuple
            let gkAchievementDescription = tupleInfoAchievement.gkAchievementDescription
            let gkAchievement = tupleInfoAchievement.gkAchievement
            // The title of the achievement.
            print("\n[Easy Game Center] Title : \(gkAchievementDescription.title)\n")
            // The description for an unachieved achievement.
            print("\n[Easy Game Center] Achieved Description : \(gkAchievementDescription.achievedDescription)\n")
        }
    }

成就进度

  • 获取成就的进度
    let progressAchievement = EGC.getProgressForAchievement(achievementIdentifier: "AchievementIdentifier")

重置所有成就

  • 重置所有成就
  • 选项：无完成
    EGC.resetAllAchievements()
    EGC.resetAllAchievements { 
        (achievementReset) -> Void in
        print("\n[Easy Game Center] ID : \(achievementReset.identifier)\n")
    }

排行榜方法

报告

  • 报告排行榜分数
    EGC.reportScoreLeaderboard(leaderboardIdentifier: "LeaderboardIdentifier", score: 100)

获取 GKLeaderboard

  • 获取带有完成选项的 GKLeaderboard
    EGC.getGKLeaderboard { 
        (resultArrayGKLeaderboard) -> Void in
        if let resultArrayGKLeaderboardIsOK = resultArrayGKLeaderboard {
            for oneGKLeaderboard in resultArrayGKLeaderboardIsOK  {
                print("\n[Easy Game Center] ID : \(oneGKLeaderboard.identifier)\n")
                print("\n[Easy Game Center] Title :\(oneGKLeaderboard.title)\n")
                print("\n[Easy Game Center] Loading ? : \(oneGKLeaderboard.loading)\n")
            }
        }
    }

获取GKScore

  • 获取完成后的GKScore排行榜
    EGC.getGKScoreLeaderboard(leaderboardIdentifier: "LeaderboardIdentifier") {
        (resultGKScore) -> Void in
        if let resultGKScoreIsOK = resultGKScore as GKScore? {
            print("\n[Easy Game Center] Leaderboard Identifier : \(resultGKScoreIsOK.leaderboardIdentifier)\n")
            print("\n[Easy Game Center] Date : \(resultGKScoreIsOK.date)\n")
            print("\n[Easy Game Center] Rank :\(resultGKScoreIsOK.rank)\n")
            print("\n[Easy Game Center] Hight Score : \(resultGKScoreIsOK.value)\n")
        }
    }

获取高分（元组）

  • 获取完成后的高分排行榜，(名，分数，排名)元组
    EGC.getHighScore(leaderboardIdentifier: "LeaderboardIdentifier") {
        (tupleHighScore) -> Void in
        //(playerName:String, score:Int,rank:Int)?
        if let tupleIsOk = tupleHighScore {
            print("\n[Easy Game Center] Player name : \(tupleIsOk.playerName)\n")
            print("\n[Easy Game Center] Score : \(tupleIsOk.score)\n")
            print("\n[Easy Game Center] Rank :\(tupleIsOk.rank)\n")
        }
    }

多人玩家

多人玩家方法

按玩家数量查找玩家

  • 按最小和最大玩家数量查找玩家
    EGC.findMatchWithMinPlayers(2, maxPlayers: 4)

发送数据到所有玩家

  • 发送数据到所有玩家（NSData）
    // Example Struc
    var myStruct = Packet(name: "My Data to Send !", index: 1234567890, numberOfPackets: 1)

    //Send Data
    EGC.sendDataToAllPlayers(myStruct.archive(), modeSend: .Reliable): 4)

获取比赛中的玩家

  • 获取比赛中的玩家，返回集合
    if let players = EGC.getPlayerInMatch() {
        for player in players{
            print(player.alias)
        }
    }

获取比赛

  • 获取当前比赛
    if let match = EGC.getMatch() {
        print(match)
    }

断开比赛/停止

  • 断开比赛或停止发送数据到比赛中的所有玩家
    EGC.disconnectMatch()

其他游戏中心方法

玩家已识别至游戏中心

  • 玩家是否已识别至gameCenter
    if EGC.isPlayerIdentified { /* Player identified */ }

获取本地玩家

  • 获取本地玩家（GKLocalPlayer）
    let localPlayer = EGC.getLocalPlayer()

获取本地玩家信息

    EGC.getlocalPlayerInformation {
        (playerInformationTuple) -> () in
        //playerInformationTuple:(playerID:String,alias:String,profilPhoto:UIImage?)

        if let typleInformationPlayer = playerInformationTuple {

            self.PlayerID.text = "Player ID : \(typleInformationPlayer.playerID)"
            self.Name.text = "Name : \(typleInformationPlayer.alias)"
            self.PlayerAuthentified.text = "Player Authentified : True"

            if let haveProfilPhoto = typleInformationPlayer.profilPhoto {
                self.PlayerProfil.image = haveProfilPhoto
            }

        }
    }

网络

  • 是否已连接到网络
    if EGC.isConnectedToNetwork { /* You have network */ }

隐藏自动登录游戏中心

  • 隐藏自动登录游戏中心页面，如果玩家未登录
    EGC.showLoginPage = false

调试模式

  • 如果您不想看到Easy Game Center的消息
    // If you doesn't want see message Easy Game Center, delete this ligne
    // EGC.debugMode = true

支持旧版本

支持iOS 7+和iOS 8+

@RedWolfStudioFR

@YannickSteph

Yannick Stephan努力确保与Easy Game Center具有尽可能高的功能兼容性。

许可证

MIT许可证（MIT）

版权所有 © 2015 Red Wolf Studio, Yannick Stephan

Red Wolf Studio

Yannick Stephan