public static void Report(Leaderboard leaderboard, long score)
{
if (!instanceExists)
{
return;
}
int leaderboardIndex = (int)leaderboard;
if (leaderboardIndex >= instance.leaderboardInfos.Length)
{
Debug.LogFormat("LeaderboardManager:Report - leaderboard index ({0}) out of bound.", leaderboardIndex);
return;
}
if (instance.debugMode)
{
Debug.LogFormat("LeaderboardManager:Report({0},{1})", leaderboard, score);
}
#if UNITY_IOS || UNITY_TVOS
GameCenterBinding.reportScore(score, instance.leaderboardInfos[leaderboardIndex].leaderboardId);
#elif UNITY_ANDROID && !CHS
if (PlayGameCenterManager.isAuthenticated)
{
PlayGameServices.submitScore(instance.leaderboardInfos[leaderboardIndex].leaderboardId, score);
}
else
{
SetCachedHighScore(leaderboard, score);
}
#endif
}
public void SetHighScore(int highScore)
{
if (_hasLeaderboardData)
{
Debug.Log("SUBMITTING HIGH SCORE TO LEADERBOARD:" + _leaderboards[0].leaderboardId.ToString());
GameCenterBinding.reportScore(highScore, _leaderboards[0].leaderboardId);
}
}
public static void SetScore(long score, ulong context, string leaderboardId)
{
AuthenticateUser();
#if UNITY_IPHONE
GameCenterBinding.reportScore(score, context, leaderboardId);
#endif
}
public void SubmitScore(int score, string leaderboardID)
{
#if UNITY_IPHONE && API_SCORE_GAMECENTER
if (!Enabled)
{
return;
}
if (leaderboardID != null)
{
GameCenterBinding.reportScore(score, leaderboardID);
}
#endif
}
void onEnemyStatsChange(EnemyStats stats, EnemyBase._EnemyState state)
{
if (state == EnemyBase._EnemyState.Dead)
{
GameState = _GameState.Results;
onUIUpdate(DBAccess.instance.userPrefs.userGun, GameState, null, stats);
DBAccess.instance.userPrefs.wins++;
if (GameCenterBinding.isPlayerAuthenticated())
{
GameCenterBinding.reportScore((long)DBAccess.instance.userPrefs.wins, "Leaderboard_Win");
}
}
}
void leaderboardsGUI()
{
if (GUILayout.Button("Load Leaderboard Data"))
{
GameCenterBinding.loadLeaderboardTitles();
}
if (GUILayout.Button("Show Leaderboards"))
{
GameCenterBinding.showLeaderboardWithTimeScope(GameCenterLeaderboardTimeScope.AllTime);
}
if (!_hasLeaderboardData)
{
GUILayout.Label("Load leaderboard data to see more options");
return;
}
if (GUILayout.Button("Post Score"))
{
Debug.Log("about to report a random score for leaderboard: " + _leaderboards[0].leaderboardId);
GameCenterBinding.reportScore(Random.Range(1, 99999), _leaderboards[0].leaderboardId);
}
if (GUILayout.Button("Issue Score Challenge"))
{
var playerIds = new string[] { "player1", "player2" };
var score = Random.Range(1, 9999);
GameCenterBinding.issueScoreChallenge(score, 0, _leaderboards[0].leaderboardId, playerIds, "Beat this score!");
}
if (GUILayout.Button("Get Raw Score Data"))
{
GameCenterBinding.retrieveScores(false, GameCenterLeaderboardTimeScope.AllTime, 1, 25, _leaderboards[0].leaderboardId);
}
if (GUILayout.Button("Get Scores for Me"))
{
GameCenterBinding.retrieveScoresForPlayerId(GameCenterBinding.playerIdentifier(), _leaderboards[0].leaderboardId);
}
}
void submitScore(int playerScore)
{
#if GOT_PRIME31_GAMECENTER
AchivementEx[] achievementResults = AchivementEx.getAchivements(achivements, playerScore, Constants.getCourseIndex());
if (achievementResults != null)
{
for (int i = 0; i < achievementResults.Length; i++)
{
GameCenterBinding.reportAchievement(achievementResults[i].achivementID, 100f);
}
}
#endif
#if GOT_PRIME31_GAMECENTER
GameCenterBinding.reportScore(playerScore,
leaderBoardIDs[Constants.getCourseIndex()]);
#endif
}
IEnumerator deathRoutine()
{
yield return(new WaitForSeconds(cameraAnimNode.animation["CameraDeath"].length));
cameraFades[0].enabled = true;
cameraFades[0].SetScreenOverlayColor(Color.clear);
cameraFades[0].StartFade(new Color(0.725f, 0f, 0f, 1f), 2f);
yield return(new WaitForSeconds(2f));
cameraFades[0].enabled = false;
DBAccess.instance.userPrefs.losses++;
if (GameCenterBinding.isPlayerAuthenticated())
{
GameCenterBinding.reportScore((long)DBAccess.instance.userPrefs.losses, "Leaderboard_Loss");
}
}
public void ReportScore(int score, int modeId, int leaderboard)
{
#if UNITY_IOS && GAMECENTER
if (isModeBasedGame)
{
GameCenterBinding.reportScore(score, modes[modeId].leaderboards[leaderboard].keyGameCenteriOS);
}
else
{
GameCenterBinding.reportScore(score, leaderboards[leaderboard].keyGameCenteriOS);
}
#endif
#if UNITY_ANDROID && GPGSERVIES
if (isModeBasedGame)
{
PlayGameServices.submitScore(modes[modeId].leaderboards[leaderboard].keyGoogleGameServices, score);
}
else
{
PlayGameServices.submitScore(leaderboards[leaderboard].keyGoogleGameServices, score);
}
#endif
}
void OnGUI()
{
float yPos = 5.0f;
float xPos = 5.0f;
float width = (Screen.width >= 960 || Screen.height >= 960) ? 320 : 160;
float height = (Screen.width >= 960 || Screen.height >= 960) ? 80 : 40;
float heightPlus = height + 5.0f;
if (GUI.Button(new Rect(xPos, yPos, width, height), "Authenticate"))
{
GameCenterBinding.authenticateLocalPlayer();
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Load Achievement Metadata"))
{
GameCenterBinding.retrieveAchievementMetadata();
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Get Raw Achievements"))
{
GameCenterBinding.getAchievements();
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Post Achievement"))
{
if (achievementMetadata != null && achievementMetadata.Count > 0)
{
int percentComplete = (int)Random.Range(2, 60);
Debug.Log("sending percentComplete: " + percentComplete);
GameCenterBinding.reportAchievement(achievementMetadata[0].identifier, percentComplete);
}
else
{
Debug.Log("you must load achievement metadata before you can post an achievement");
}
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Issue Achievement Challenge"))
{
if (achievementMetadata != null && achievementMetadata.Count > 0)
{
var playerIds = new string[] { "player1", "player2" };
GameCenterBinding.issueAchievementChallenge(achievementMetadata[0].identifier, playerIds, "I challenge you");
}
else
{
Debug.Log("you must load achievement metadata before you can issue an achievement challenge");
}
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Show Achievements"))
{
GameCenterBinding.showAchievements();
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Reset Achievements"))
{
GameCenterBinding.resetAchievements();
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Multiplayer Scene"))
{
Application.LoadLevel("GameCenterMultiplayerTestScene");
}
// Second Column
xPos = Screen.width - width - 5.0f;
yPos = 5.0f;
if (GUI.Button(new Rect(xPos, yPos, width, height), "Get Player Alias"))
{
string alias = GameCenterBinding.playerAlias();
Debug.Log("Player alias: " + alias);
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Load Leaderboard Data"))
{
GameCenterBinding.loadLeaderboardTitles();
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Post Score"))
{
// We must have a leaderboard to post the score to
if (leaderboards != null && leaderboards.Count > 0)
{
Debug.Log("about to report a random score for leaderboard: " + leaderboards[0].leaderboardId);
GameCenterBinding.reportScore(Random.Range(1, 99999), leaderboards[0].leaderboardId);
}
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Issue Score Challenge"))
{
// We must have a leaderboard to post the score to
if (leaderboards != null && leaderboards.Count > 0)
{
var playerIds = new string[] { "player1", "player2" };
var score = Random.Range(1, 9999);
GameCenterBinding.issueScoreChallenge(score, 0, leaderboards[0].leaderboardId, playerIds, "Beat this score!");
}
else
{
Debug.Log("you must load your leaderboards before you can issue a score challenge");
}
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Show Leaderboards"))
{
GameCenterBinding.showLeaderboardWithTimeScope(GameCenterLeaderboardTimeScope.AllTime);
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Get Raw Score Data"))
{
// We must have a leaderboard to retrieve scores from
if (leaderboards != null && leaderboards.Count > 0)
{
GameCenterBinding.retrieveScores(false, GameCenterLeaderboardTimeScope.AllTime, 1, 25, leaderboards[0].leaderboardId);
}
else
{
Debug.Log("Load leaderboard data before attempting to retrieve scores");
}
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Get Scores for Me"))
{
// We must have a leaderboard to retrieve scores from
if (leaderboards != null && leaderboards.Count > 0)
{
GameCenterBinding.retrieveScoresForPlayerId(GameCenterBinding.playerIdentifier(), leaderboards[0].leaderboardId);
}
else
{
Debug.Log("Load leaderboard data before attempting to retrieve scores");
}
}
if (GUI.Button(new Rect(xPos, yPos += heightPlus, width, height), "Retrieve Friends"))
{
GameCenterBinding.retrieveFriends(true);
}
}
//=============================================================================
public void ReportScore(System.Int64 Score)
{
// Report score to GC/GP first
#if UNITY_IPHONE
if ((IsLoggedIn() == true) && (m_ManagerState == eManagerState.Idle))
{
GameCenterBinding.reportScore(Score, ScoreboardID);
m_ManagerState = eManagerState.ReportScore;
}
else
{
if (ReportScoreFailEvent != null)
{
ReportScoreFailEvent("Error - not logged in or manager busy");
}
}
#endif
#if UNITY_ANDROID
if ((IsLoggedIn() == true) && (m_ManagerState == eManagerState.Idle))
{
PlayGameServices.submitScore(ScoreboardIDAndroid, Score);
m_ManagerState = eManagerState.ReportScore;
}
else
{
if (ReportScoreFailEvent != null)
{
ReportScoreFailEvent("Error - not logged in or manager busy");
}
}
#endif
// Now report score to playtomic system along with any custom parameters
if (IsPlayerRegistered() == false)
{
return;
}
#if UNITY_EDITOR
string sourceType = "Editor";
#elif UNITY_IPHONE
string sourceType = "iOS";
#elif UNITY_ANDROID
string sourceType = "iOS"; //"Android";
#else
string sourceType = "Unknown";
#endif
string CurCountry = PreHelpers.GetCountryCode();
PlayerScore NewScore = new PlayerScore
{
playername = GetPlayerName(),
playerid = GetPlayerID(),
points = Score,
table = ScoreboardID,
allowduplicates = false,
source = sourceType,
fields = new PDictionary
{
{ "country", CurCountry }
}
};
Playtomic.Leaderboards.Save(NewScore, ScoreSubmitComplete);
}
//public void ReportScore(System.Int64 score, System.UInt64 context, string leaderboardId ){
public void ReportScore(System.Int64 score, System.UInt64 context, string leaderboardId)
{
GameCenterBinding.reportScore(score, context, leaderboardId);
}
public void ReportScore(long score, string ID)
{
GameCenterBinding.reportScore(score, ID);
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 500))
{
if (hit.collider.tag == "_play")
{
if (S_Engine > 0 || G_Engine > 0)
{
_MainMenu.isM_Close = true;
Instantiate(EngineChoose);
}
else
{
_MainMenu.isM_Close = true;
E_Index = 0;
StartCoroutine(waitlevels(1.2f));
}
}
if (hit.collider.tag == "_options")
{
_MainMenu.isM_Close = true;
StartCoroutine(WaitForOptions(1.2f));
}
if (hit.collider.tag == "_store")
{
_MainMenu.isM_Close = true;
StartCoroutine(waitStore(1.2f));
}
if (hit.collider.tag == "gamecenter")
{
if (leaderboards != null && leaderboards.Count > 0)
{
GameCenterBinding.reportScore(PlayerPrefs.GetInt("HighScore"), leaderboards[0].leaderboardId);
}
GameCenterBinding.showLeaderboardWithTimeScope(GameCenterLeaderboardTimeScope.AllTime);
}
if (hit.collider.tag == "_eng_1") // ghost engine
{
isEngEnabled = false;
_MainMenu.isEngSelected = true;
E_Index = 2;
isG_Engine = true;
StartCoroutine(waitlevels(1.2f));
}
if (hit.collider.tag == "_eng_2") // super engine
{
isS_Engine = true;
isEngEnabled = false;
E_Index = 1;
_MainMenu.isEngSelected = true;
StartCoroutine(waitlevels(1.2f));
}
}
}
}
