public void LoadPlayerCenteredScores(UM_Leaderboard leaderboard, int maxResults, UM_TimeSpan timeSpan = UM_TimeSpan.ALL_TIME, UM_CollectionType collection = UM_CollectionType.GLOBAL)
{
if (leaderboard == null)
{
return;
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
UM_Score score = GetCurrentPlayerScore(leaderboard, timeSpan, collection);
int rank = 0;
if (score != null)
{
rank = score.Rank;
}
int startIndex = Math.Max(0, rank - maxResults / 2);
GameCenterManager.LoadScore(leaderboard.IOSId, startIndex, maxResults, timeSpan.Get_GK_TimeSpan(), collection.Get_GK_CollectionType());
break;
case RuntimePlatform.Android:
GooglePlayManager.Instance.LoadPlayerCenteredScores(leaderboard.AndroidId, timeSpan.Get_GP_TimeSpan(), collection.Get_GP_CollectionType(), maxResults);
break;
}
}
public long GetCurrentPlayerScore(UM_Leaderboard leaderboard)
{
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GCLeaderboard board = GameCenterManager.GetLeaderboard(leaderboard.IOSId);
if (board != null)
{
GCScore score = board.GetCurrentPlayerScore(GCBoardTimeSpan.ALL_TIME, GCCollectionType.GLOBAL);
if (score != null)
{
return(score.GetLongScore());
}
}
break;
case RuntimePlatform.Android:
GPLeaderBoard gBoard = GooglePlayManager.instance.GetLeaderBoard(leaderboard.AndroidId);
if (gBoard != null)
{
GPScore score = gBoard.GetCurrentPlayerScore(GPBoardTimeSpan.ALL_TIME, GPCollectionType.GLOBAL);
if (score != null)
{
return(score.score);
}
}
break;
}
return(0);
}
public UM_PlayerTemplate GetPlayer(string playerId)
{
UM_PlayerTemplate player = null;
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GK_Player gk_player = GameCenterManager.GetPlayerById(playerId);
if (gk_player != null)
{
player = new UM_PlayerTemplate(gk_player, null);
}
break;
case RuntimePlatform.Android:
GooglePlayerTemplate gp_player = GooglePlayManager.Instance.GetPlayerById(playerId);
if (gp_player != null)
{
player = new UM_PlayerTemplate(null, gp_player);
}
break;
}
return(player);
}
public UM_Score(GK_Score gkScore, GPScore gpScore, GC_Score gcScore)
{
_GK_Score = gkScore;
_GP_Score = gpScore;
_GC_Score = gcScore;
if (IsValid)
{
switch (Application.platform)
{
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
GC_Player gc_player = SA_AmazonGameCircleManager.Instance.GetPlayerById(_GC_Score.PlayerId);
player = new UM_Player(null, null, gc_player);
}
else
{
GooglePlayerTemplate gp_player = GooglePlayManager.Instance.GetPlayerById(_GP_Score.PlayerId);
player = new UM_Player(null, gp_player, null);
}
break;
case RuntimePlatform.IPhonePlayer:
GK_Player gk_player = GameCenterManager.GetPlayerById(_GK_Score.PlayerId);
player = new UM_Player(gk_player, null, null);
break;
}
}
}
private void Init()
{
_IsInitedCalled = true;
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
dataEventsCount = UltimateMobileSettings.Instance.Leaderboards.Count + 1;
foreach (UM_Achievement achievment in UltimateMobileSettings.Instance.Achievements)
{
GameCenterManager.RegisterAchievement(achievment.IOSId);
}
break;
case RuntimePlatform.Android:
dataEventsCount = 2;
break;
}
GooglePlayConnection.ActionPlayerConnected += OnAndroidPlayerConnected;
GooglePlayConnection.ActionPlayerDisconnected += OnAndroidPlayerDisconnected;
GooglePlayManager.ActionAchievementsLoaded += OnGooglePlayServiceDataLoaded;
GooglePlayManager.ActionLeaderboardsLoaded += OnGooglePlayServiceDataLoaded;
GameCenterManager.OnAuthFinished += OnAuthFinished;
GameCenterManager.OnAchievementsLoaded += OnGameCenterServiceDataLoaded;
GameCenterManager.OnPlayerScoreLoaded += OnGameCenterServiceDataLoaded;
}
public void LoadLeaderboardsInfo()
{
if (_WaitingForLeaderboardsData)
{
return;
}
_WaitingForLeaderboardsData = true;
_LeaderboardsDataEventsCount = 0;
_CurrentLeaderboardsEventsCount = 0;
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
_LeaderboardsDataEventsCount = UltimateMobileSettings.Instance.Leaderboards.Count;
foreach (UM_Leaderboard leaderboard in UltimateMobileSettings.Instance.Leaderboards)
{
GameCenterManager.LoadLeaderboardInfo(leaderboard.IOSId);
}
break;
case RuntimePlatform.Android:
GooglePlayManager.Instance.LoadLeaderBoards();
break;
}
}
public int GetAchievementProgressInSteps(UM_Achievement achievement)
{
if (achievement == null)
{
Debug.LogError("Achievement is null. No progress can be retrieved.");
return(0);
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
float percentage = GameCenterManager.GetAchievementProgress(achievement.IOSId);
return(Mathf.CeilToInt(((float)achievement.Steps / 100f) * percentage));
case RuntimePlatform.Android:
GPAchievement a = GooglePlayManager.Instance.GetAchievement(achievement.AndroidId);
if (a != null)
{
if (a.Type == GPAchievementType.TYPE_INCREMENTAL)
{
return(a.CurrentSteps);
}
else
{
return((a.State == GPAchievementState.STATE_UNLOCKED) ? 1 : 0);
}
}
break;
}
return(0);
}
public void IncrementAchievementByCurrentSteps(UM_Achievement achievement, int steps)
{
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer: {
float percentage = ((float)steps / (float)achievement.Steps) * 100f;
GameCenterManager.SubmitAchievement(percentage, achievement.IOSId);
break;
}
case RuntimePlatform.Android: {
GPAchievement a = GooglePlayManager.Instance.GetAchievement(achievement.AndroidId);
if (a != null)
{
if (a.Type == GPAchievementType.TYPE_INCREMENTAL)
{
GooglePlayManager.Instance.IncrementAchievementById(a.Id, steps - a.CurrentSteps);
}
else
{
GooglePlayManager.Instance.UnlockAchievementById(a.Id);
}
}
break;
}
}
}
//--------------------------------------
// Connection
//--------------------------------------
public void Connect()
{
if (!_IsInitedCalled)
{
Init();
}
if (_ConnectionSate == UM_ConnectionState.CONNECTED || _ConnectionSate == UM_ConnectionState.CONNECTING)
{
return;
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GameCenterManager.Init();
break;
case RuntimePlatform.Android:
GooglePlayConnection.Instance.Connect();
break;
}
_ConnectionSate = UM_ConnectionState.CONNECTING;
}
void OnMouseUp()
{
this.transform.localScale -= new Vector3(0.1f, 0.1f, 0.1f);
// Load scoreboard for this stat
GameCenterManager.showLeaderBoard(leaderBoardId);
}
public void ReportScore()
{
Debug.Log("ReportScore");
hiScore++;
GameCenterManager.ReportScore(hiScore, TEST_LEADERBOARD_1, 17);
}
public void IncrementAchievement(UM_Achievement achievement, float percentages)
{
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GameCenterManager.SubmitAchievement(percentages, achievement.IOSId);
break;
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
SA_AmazonGameCircleManager.Instance.UpdateAchievementProgress(achievement.AmazonId, percentages);
}
else
{
GPAchievement a = GooglePlayManager.Instance.GetAchievement(achievement.AndroidId);
if (a != null)
{
if (a.Type == GPAchievementType.TYPE_INCREMENTAL)
{
int steps = Mathf.CeilToInt(((float)a.TotalSteps / 100f) * percentages);
GooglePlayManager.Instance.IncrementAchievementById(achievement.AndroidId, steps);
}
else
{
GooglePlayManager.Instance.UnlockAchievementById(achievement.AndroidId);
}
}
}
break;
}
}
void Awake()
{
GameCenterManager.OnAuthFinished += HandleOnAuthFinished;
//Initializing Game Center class. This action will trigger authentication flow
GameCenterManager.Init();
}
//--------------------------------------
// Connection
//--------------------------------------
public void Connect()
{
if (!_IsInitedCalled)
{
Init();
}
if (_ConnectionSate == UM_ConnectionState.CONNECTED || _ConnectionSate == UM_ConnectionState.CONNECTING)
{
return;
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GameCenterManager.Init();
break;
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
SA_AmazonGameCircleManager.Instance.Connect();
}
else
{
GooglePlayConnection.Instance.Connect();
}
break;
}
SetConnectionState(UM_ConnectionState.CONNECTING);
}
private void Init()
{
_IsInitedCalled = true;
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
dataEventsCount = UltimateMobileSettings.Instance.Leaderboards.Count + 1;
foreach (UM_Achievement achievment in UltimateMobileSettings.Instance.Achievements)
{
GameCenterManager.RegisterAchievement(achievment.IOSId);
}
break;
case RuntimePlatform.Android:
dataEventsCount = 2;
break;
}
GooglePlayConnection.instance.addEventListener(GooglePlayConnection.PLAYER_CONNECTED, OnAndroidPlayerConnected);
GooglePlayConnection.instance.addEventListener(GooglePlayConnection.PLAYER_DISCONNECTED, OnAndroidPlayerDisconnected);
GooglePlayManager.instance.addEventListener(GooglePlayManager.ACHIEVEMENTS_LOADED, OnServiceDataLoaded);
GooglePlayManager.instance.addEventListener(GooglePlayManager.LEADERBOARDS_LOADED, OnServiceDataLoaded);
GameCenterManager.OnAuthFinished += OnAuthFinished;
GameCenterManager.Dispatcher.addEventListener(GameCenterManager.GAME_CENTER_ACHIEVEMENTS_LOADED, OnServiceDataLoaded);
GameCenterManager.Dispatcher.addEventListener(GameCenterManager.GAME_CENTER_LEADERBOARD_SCORE_LOADED, OnServiceDataLoaded);
}
public int GetCurrentPlayerRank(UM_Leaderboard leaderboard)
{
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GCLeaderboard board = GameCenterManager.GetLeaderboard(leaderboard.IOSId);
if (board != null)
{
return(board.GetCurrentPlayerScore(GCBoardTimeSpan.ALL_TIME, GCCollectionType.GLOBAL).rank);
}
else
{
return(0);
}
case RuntimePlatform.Android:
GPLeaderBoard gBoard = GooglePlayManager.instance.GetLeaderBoard(leaderboard.AndroidId);
if (gBoard != null)
{
return(gBoard.GetCurrentPlayerScore(GPBoardTimeSpan.ALL_TIME, GPCollectionType.GLOBAL).rank);
}
else
{
return(0);
}
}
return(0);
}
public void LoadTopScores(UM_Leaderboard leaderboard, int maxResults, UM_TimeSpan timeSpan = UM_TimeSpan.ALL_TIME, UM_CollectionType collection = UM_CollectionType.GLOBAL)
{
if (leaderboard == null)
{
return;
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GameCenterManager.LoadScore(leaderboard.IOSId, 1, maxResults, timeSpan.Get_GK_TimeSpan(), collection.Get_GK_CollectionType());
break;
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
SA_AmazonGameCircleManager.Instance.LoadTopScores(leaderboard.AmazonId, timeSpan.Get_GC_TimeSpan());
}
else
{
GooglePlayManager.Instance.LoadTopScores(leaderboard.AndroidId, timeSpan.Get_GP_TimeSpan(), collection.Get_GP_CollectionType(), maxResults);
}
break;
}
}
//private string TEST_ACHIEVEMENT_1_ID = "com.bocean.game.casinoslots2.mega_jackpot_win";
//private string TEST_ACHIEVEMENT_2_ID = "com.bocean.game.casinoslots2.lucky_jackpot_win";
//private string TEST_ACHIEVEMENT_3_ID = "com.bocean.game.casinoslots2.jackpot_win";
//private string TEST_ACHIEVEMENT_4_ID = "com.bocean.game.casinoslots2.lucky_jewel_win";
//private string TEST_ACHIEVEMENT_5_ID = "com.bocean.game.casinoslots2.lucky_seven_win";
//private string TEST_ACHIEVEMENT_6_ID = "com.bocean.game.casinoslots2.4_of_a_kind";
//private string TEST_ACHIEVEMENT_7_ID = "com.bocean.game.casinoslots2.full_house";
//private string TEST_ACHIEVEMENT_8_ID = "com.bocean.game.casinoslots2.two_pairs";
//private string TEST_ACHIEVEMENT_9_ID = "com.bocean.game.casinoslots2.3_of_a_kind";
//private string TEST_ACHIEVEMENT_10_ID = "com.bocean.game.casinoslots2.pair_win";
void Start()
{
if (!IsInitialized)
{
//Achievement registration. If you skip this step GameCenterManager.achievements array will contain only achievements with reported progress
//GameCenterManager.RegisterAchievement (TEST_ACHIEVEMENT_1_ID);
//GameCenterManager.RegisterAchievement (TEST_ACHIEVEMENT_2_ID);
//Listen for the Game Center events
//GameCenterManager.OnAchievementsProgress += HandleOnAchievementsProgress;
//GameCenterManager.OnAchievementsReset += HandleOnAchievementsReset;
//.OnAchievementsLoaded += OnAchievementsLoaded;
GameCenterManager.OnScoreSubmitted += OnScoreSubmitted;
GameCenterManager.OnLeadrboardInfoLoaded += OnLeadrboardInfoLoaded;
GameCenterManager.OnAuthFinished += OnAuthFinished;
//Initializing Game Center class. This action will trigger authentication flow
GameCenterManager.Init();
IsInitialized = true;
}
}
// Use this for initialization
void Start()
{
Debuger.EnableLog = true;
gameHeart = new GameObject("GameHeart");
gameHeart.AddComponent <DontDestroyObj>();
//初始化数据存储系统
UserDataManager.instance.Start();
//初始化事件管理器
EventManager em = gameHeart.AddComponent <EventManager>();
//声音管理器
AudioManager am = gameHeart.AddComponent <AudioManager>();
//加载联网脚本
HttpConnection hc = gameHeart.AddComponent <HttpConnection>();
//初始化场景管理器
GameSceneManager gsm = gameHeart.AddComponent <GameSceneManager>();
ConfigManager.LoadData();
(new EventChangeScene(GameSceneManager.SceneTag.Logo)).Send();
GameCenterManager.GetInstance();
ADManager.GetInstance();
}
private void OnNearbyPlayerInfoReceived(string data)
{
string[] DataArray = data.Split(IOSNative.DATA_SPLITTER);
string playerId = DataArray[0];
GK_Player player = GameCenterManager.GetPlayerById(playerId);
bool reachable = Convert.ToBoolean(DataArray[1]);
if (reachable)
{
if (!_NearbyPlayers.ContainsKey(player.Id))
{
_NearbyPlayers.Add(player.Id, player);
}
}
else
{
if (_NearbyPlayers.ContainsKey(player.Id))
{
_NearbyPlayers.Remove(player.Id);
}
}
ActionNearbyPlayerStateUpdated(player, reachable);
}
// Use this for initialization
void Start()
{
textStyle.alignment = TextAnchor.MiddleCenter;
if (statName.Equals("tapsSec"))
{
text = ((int)(((float)PlayerPrefs.GetInt("totalTimePlayed") / PlayerPrefs.GetInt("totalTaps")) * 1000)).ToString();
score = (int)(((float)PlayerPrefs.GetInt("totalTimePlayed") / PlayerPrefs.GetInt("totalTaps")) * 1000);
}
else if (statName.Equals("reactionTimeBest"))
{
text = ((int)(PlayerPrefs.GetFloat(statName) * 1000)).ToString();
score = (int)PlayerPrefs.GetFloat(statName);
}
else
{
text = PlayerPrefs.GetInt(statName).ToString();
score = PlayerPrefs.GetInt(statName);
}
if (score < 0)
{
text = "0";
}
try{
// submit highscore
if (score != 0 && score != null)
{
GameCenterManager.reportScore(score, leaderBoardId);
}
}catch (Exception e) {
Debug.Log("Cant submit score, ERROR: " + e.Message);
}
}
//--------------------------------------
// INITIALIZE
//--------------------------------------
void Awake()
{
if (!IsInited)
{
//Achievement registration. If you will skipt this step GameCenterManager.achievements array will contain only achievements with reported progress
GameCenterManager.registerAchievement(TEST_ACHIEVEMENT_1_ID);
GameCenterManager.registerAchievement(TEST_ACHIEVEMENT_2_ID);
//Listen for the Game Center events
GameCenterManager.dispatcher.addEventListener(GameCenterManager.GAME_CENTER_ACHIEVEMENT_PROGRESS, OnAchievementProgress);
GameCenterManager.dispatcher.addEventListener(GameCenterManager.GAME_CENTER_ACHIEVEMENTS_RESET, OnAchievementsReset);
GameCenterManager.dispatcher.addEventListener(GameCenterManager.GAME_CENTER_LEADER_BOARD_SCORE_LOADED, OnLeaderBoarScoreLoaded);
//actions use example
GameCenterManager.OnPlayerScoreLoaded += OnPlayerScoreLoaded;
GameCenterManager.OnAuthFinished += OnAuthFinished;
GameCenterManager.OnAchievementsLoaded += OnAchievementsLoaded;
//Initializing Game Cneter class. This action will triger authentication flow
GameCenterManager.init();
IsInited = true;
}
}
private void OnResetAchievmentsClick(GameObject go)
{
#if UNITY_IOS
GameCenterManager.ResetAchievments();
PlayerPrefs.DeleteAll();
#endif
}
// Use this for initialization
void Start()
{
if (!GameCenterManager.IsInited)
{
GameCenterManager.init();
}
//Registering Distance in One Run Achievements
GameCenterManager.registerAchievement("distance1000"); //10 Points
GameCenterManager.registerAchievement("distance5000"); //10 Points
GameCenterManager.registerAchievement("distance7500"); //10 Points
GameCenterManager.registerAchievement("distance9001"); //10 points
GameCenterManager.registerAchievement("distance10000"); //25 Points
//Registering Total Distance Achievements
GameCenterManager.registerAchievement("totaldistance10000"); //5 Points
GameCenterManager.registerAchievement("totaldistance50000"); //10 Points
GameCenterManager.registerAchievement("totaldistance100000"); //10 Points
GameCenterManager.registerAchievement("totaldistance500000"); //15 Points
GameCenterManager.registerAchievement("totaldistance1000000"); //20 Points
//Registering Rounds Complete Achievements
GameCenterManager.registerAchievement("rounds1"); //1 Points
GameCenterManager.registerAchievement("rounds10"); //4 Points
GameCenterManager.registerAchievement("rounds25"); //10 Points
GameCenterManager.registerAchievement("rounds50"); //10 Points
GameCenterManager.registerAchievement("rounds100"); //10 Points
GameCenterManager.registerAchievement("rounds250"); //25 Points
GameCenterManager.registerAchievement("rounds500"); //25 Points
GameCenterManager.registerAchievement("rounds1000"); //100 Points
}
public void ReportScore(int score)
{
if (player_authenticated)
{
GameCenterManager.ReportScore(score, leaderBoardId);
}
}
public void LoadLeaderboardsInfo()
{
if (_WaitingForLeaderboardsData)
{
return;
}
_WaitingForLeaderboardsData = true;
_LeaderboardsDataEventsCount = 0;
_CurrentLeaderboardsEventsCount = 0;
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
_LeaderboardsDataEventsCount = UltimateMobileSettings.Instance.Leaderboards.Count;
foreach (UM_Leaderboard leaderboard in UltimateMobileSettings.Instance.Leaderboards)
{
GameCenterManager.LoadLeaderboardInfo(leaderboard.IOSId);
}
break;
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
SA_AmazonGameCircleManager.Instance.RequestLeaderboards();
}
else
{
GooglePlayManager.Instance.LoadLeaderBoards();
}
break;
}
}
public void ShowOverLayer()
{
gameState = enGameState.over;
int selmodel = PlayerPrefs.GetInt(GameConst.USERDATANAME_MODEL, 0);
int basescores = PlayerPrefs.GetInt(GameConst.USERDATANAME_MODEL_MAXSCORES + selmodel);
int thisscores = role.scores;
if (basescores < thisscores)
{
PlayerPrefs.SetInt(GameConst.USERDATANAME_MODEL_MAXSCORES + selmodel, thisscores);
GameCenterManager.GetInstance().UploadScores(GameConst.gameModels[selmodel].lbname, thisscores);
}
PlayerPrefs.SetInt(GameConst.USERDATANAME_MODEL_LASTSCORES + selmodel, thisscores);
if (reviveCount <= 0 && ADManager.GetInstance().isAdLoaded)
{
inGameUIManager.ShowReviveLayer();
}
else
{
inGameUIManager.ShowResultLayer();
}
reviveCount += 1;
}
public void LoadPlayerCenteredScores(UM_Leaderboard leaderboard, int maxResults, UM_TimeSpan timeSpan = UM_TimeSpan.ALL_TIME, UM_CollectionType collection = UM_CollectionType.GLOBAL)
{
if (leaderboard == null)
{
return;
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
UM_Score score = GetCurrentPlayerScore(leaderboard, timeSpan, collection);
int rank = 0;
if (score != null)
{
rank = score.Rank;
}
int startIndex = Math.Max(1, rank - maxResults / 2);
int endIndex = startIndex + maxResults - 1;
GameCenterManager.LoadScore(leaderboard.IOSId, startIndex, endIndex, timeSpan.Get_GK_TimeSpan(), collection.Get_GK_CollectionType());
break;
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
//Just do nothing for Amazon
}
else
{
GooglePlayManager.Instance.LoadPlayerCenteredScores(leaderboard.AndroidId, timeSpan.Get_GP_TimeSpan(), collection.Get_GP_CollectionType(), maxResults);
}
break;
}
}
public void IncrementAchievement(UM_Achievement achievement, float percentages)
{
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
GameCenterManager.SubmitAchievement(percentages, achievement.IOSId);
break;
case RuntimePlatform.Android:
GPAchievement a = GooglePlayManager.instance.GetAchievement(achievement.AndroidId);
if (a != null)
{
if (a.type == GPAchievementType.TYPE_INCREMENTAL)
{
int steps = Mathf.CeilToInt((a.totalSteps / 100f) * percentages);
GooglePlayManager.instance.IncrementAchievementById(achievement.AndroidId, steps);
}
else
{
GooglePlayManager.instance.UnlockAchievementById(achievement.AndroidId);
}
}
break;
}
}
//--------------------------------------
// Events
//--------------------------------------
private void OnServiceConnected()
{
if (_IsDataLoaded || _DataEventsCount <= 0)
{
_IsDataLoaded = true;
OnAllLoaded();
return;
}
switch (Application.platform)
{
case RuntimePlatform.IPhonePlayer:
if (UltimateMobileSettings.Instance.AutoLoadAchievementsInfo)
{
GameCenterManager.LoadAchievements();
}
if (UltimateMobileSettings.Instance.AutoLoadLeaderboardsInfo)
{
foreach (UM_Leaderboard leaderboard in UltimateMobileSettings.Instance.Leaderboards)
{
GameCenterManager.LoadLeaderboardInfo(leaderboard.IOSId);
}
}
break;
case RuntimePlatform.Android:
if (UltimateMobileSettings.Instance.PlatformEngine == UM_PlatformDependencies.Amazon)
{
Debug.Log("Start To Load Amazon Player");
SA_AmazonGameCircleManager.Instance.RetrieveLocalPlayer();
if (UltimateMobileSettings.Instance.AutoLoadAchievementsInfo)
{
SA_AmazonGameCircleManager.Instance.RequestAchievements();
}
if (UltimateMobileSettings.Instance.AutoLoadLeaderboardsInfo)
{
SA_AmazonGameCircleManager.Instance.RequestLeaderboards();
}
}
else
{
if (UltimateMobileSettings.Instance.AutoLoadAchievementsInfo)
{
GooglePlayManager.Instance.LoadAchievements();
}
if (UltimateMobileSettings.Instance.AutoLoadLeaderboardsInfo)
{
GooglePlayManager.Instance.LoadLeaderBoards();
}
}
break;
}
}
void Awake()
{
instance = this;
}
