void submitScoreHandleTouchUpInside(object sender, EventArgs e)
{
if (!GKLocalPlayer.LocalPlayer.Authenticated)
{
new UIAlertView("Error", "Need sign in Game Center to submit the score", null, "OK", null).Show();
GKLocalPlayer.LocalPlayer.Authenticate(authenticatedHandler);
return;
}
GKScore submitScore = new GKScore("leaderboard");
submitScore.Init();
try{
submitScore.Value = Convert.ToInt64(this.scoreTextField.Text);
}
catch {
new UIAlertView("Error", "Score should be a number", null, "OK", null).Show();
return;
}
submitScore.ShouldSetDefaultLeaderboard = true;
submitScore.Context = 100;
player.submitScore(submitScore);
}
// Attempt to resubmit the scoress
public void resubmitSotredScores()
{
if (GKLocalPlayer.LocalPlayer.Authenticated && storedScores.Count != 0)
{
int index = (int)storedScores.Count - 1;
while (index >= 0)
{
GKScore score = new GKScore(storedScores.ValueAt((uint)index));
score.ShouldSetDefaultLeaderboard = true;
if (score == null)
{
return;
}
score.ReportScore(new GKNotificationHandler((error) =>
{
if (error == null)
{
new UIAlertView("Score Submitted", "Score submitted successfully ", null, "OK", null).Show();
}
else
{
this.storeScore(score);
new UIAlertView("Score Stored", "Score Stored ", null, "OK", null).Show();
}
}));
storedScores.RemoveObject(index);
index--;
}
}
}
async void ChallengeFriends()
{
if (!GKLocalPlayer.LocalPlayer.Authenticated)
{
new UIAlertView("Player not logged in", "Must be logged into Game Center to challenge friends",
null, "Okay", null).Show();
return;
}
if (GKLocalPlayer.LocalPlayer.Friends == null)
{
await GKLocalPlayer.LocalPlayer.LoadFriendsAsync();
}
GKScore score = new GKScore()
{
LeaderboardIdentifier = MainGame.Prefix + "15secondseasymode",
Context = (ulong)GameTypePlayed.Easy15,
Value = 10
};
UIViewController challengeController = score.ChallengeComposeController(
GKLocalPlayer.LocalPlayer.Friends, "Beat it!",
delegate(UIViewController composeController, bool didIssueChallenge, string[] sentPlayerIDs) {
AppDelegate.Shared.ViewController.DismissViewController(true, null);
}
);
AppDelegate.Shared.ViewController.PresentViewController(challengeController, true, null);
}
/// <summary>
/// Adds the new score.
/// </summary>
/// <param name="score">The score.</param>
public Task <bool> AddNewScore(string leaderboardCode, long score)
{
var tcs = new TaskCompletionSource <bool>();
var submitScore = new GKScore(leaderboardCode);
submitScore.Value = score;
submitScore.Context = 100;
submitScore.ReportScore((error) =>
{
var result = true;
if (error != null)
{
result = false;
#if DEBUG
new UIAlertView("Score submittion failed", "Submittion failed because: " + error, null, "OK", null).Show();
#endif
}
tcs.TrySetResult(result);
});
return(tcs.Task);
}
void DisplayScore(GKScore score, int rank, GKPlayer player)
{
CGPoint[] podiumPositions = new CGPoint[] {
new CGPoint(0, 100),
new CGPoint(-84, 75),
new CGPoint(84, 50)
};
CGPoint currentPoint = podiumPositions [rank];
SKLabelNode scoreLabel = new SKLabelNode("GillSans-Bold")
{
Text = score.FormattedValue,
FontSize = 14,
Position = new CGPoint(FrameMidX + currentPoint.X, FrameMidY + currentPoint.Y - 32)
};
player.LoadPhoto(GKPhotoSize.Small, delegate(UIImage photo, NSError error) {
if (photo == null)
{
photo = UIImage.FromFile("Images/DefaultPlayerPhoto.png");
}
var image = SKSpriteNode.FromTexture(SKTexture.FromImage(photo), new CGSize(32, 32));
image.Position = new CGPoint(FrameMidX + currentPoint.X, FrameMidY + currentPoint.Y + 16);
AddChild(image);
});
AddChild(scoreLabel);
}
public void Ctor_String()
{
// Apple deprecated `initWithCategory:` for `initWithLeaderboardIdentifier:` which *seems* to do the
// same thing, only with new names - but we need to be sure since 7.0 will map the .ctor(string) API
// to the new selector
using (var s = new GKScore("category-or-identifier")) {
#if !__TVOS__
Assert.That(s.Category, Is.EqualTo("category-or-identifier"), "Category");
#endif
Assert.That(s.Context, Is.EqualTo(0), "Context");
Assert.NotNull(s.Date, "Date");
Assert.Null(s.FormattedValue, "FormattedValue");
// this is a new API in iOS8 (it was private before that) and returned an empty instance like:
// "<<GKPlayer: 0x81254e60>(playerID:(null) alias:(null) name:(null) status:(null))>"
if (TestRuntime.CheckSystemAndSDKVersion(8, 0))
{
Assert.Null(s.Player, "Player");
}
if (TestRuntime.CheckSystemAndSDKVersion(7, 0))
{
Assert.That(s.LeaderboardIdentifier, Is.EqualTo("category-or-identifier"), "LeaderboardIdentifier");
}
Assert.That(s.RetainCount, Is.EqualTo((nint)1), "RetainCount");
}
}
// Attempt to resubmit the scoress
public void resubmitSotredScores()
{
if (GKLocalPlayer.LocalPlayer.Authenticated && storedScores.Count != 0)
{
int index =(int) storedScores.Count - 1;
while (index >=0)
{
GKScore score = new GKScore (storedScores.ValueAt ((uint)index));
score.ShouldSetDefaultLeaderboard = true;
if (score == null)
return;
score.ReportScore (new GKNotificationHandler( (error) =>
{
if(error == null)
{
new UIAlertView ("Score Submitted", "Score submitted successfully ", null, "OK", null).Show();
}
else
{
this.storeScore(score);
new UIAlertView ("Score Stored", "Score Stored ", null, "OK", null).Show();
}
}));
storedScores.RemoveObject(index);
index --;
}
}
}
void submitScoreHandleTouchUpInside (object sender, EventArgs e)
{
GKScore submitScore = new GKScore ("leaderboard");
submitScore.Init ();
submitScore.Value = Convert.ToInt64(this.scoreTextField.Text);
submitScore.ShouldSetDefaultLeaderboard = true;
submitScore.Context = 100;
player.submitScore (submitScore);
}
/// <summary>
/// Reports a high score to Game Center.
/// The returned GKScore can be used for more advanced functionalities such as sending challenges.
/// Raises ScoreReported and ScoreReportFailed events on completion.
/// </summary>
/// <returns>The score.</returns>
/// <param name="leaderboardID">Leaderboard I.</param>
/// <param name="score">Score.</param>
public static GKScore ReportScore(string leaderboardID, long score)
{
var scoreReporter = new GKScore(leaderboardID);
scoreReporter.value = score;
// scoreReporter.context = 0;
scoreReporter.ReportScore(_ScoreReported);
return(scoreReporter);
}
public void SendScore(string id, int score)
{
if (_enabled)
{
GKScore gkScore = new GKScore(id, GKLocalPlayer.LocalPlayer);
gkScore.Value = score;
GKScore.ReportScores(new GKScore[1] {
gkScore
}, (error) => {});
}
}
public async Task<bool> ReportScore (long score, string category)
{
var scoreReporter = new GKScore (category) {
Value = score
};
try {
await scoreReporter.ReportScoreAsync ();
return true;
} catch {
return false;
}
}
public void reportScore (long score, string category, MTGKTapperViewController controller)
{
GKScore scoreReporter = new GKScore (category);
scoreReporter.Value = score;
scoreReporter.ReportScore (new Action<NSError> ((error) => {
if (error == null) {
new UIAlertView ("Score reported", "Score Reported successfully", null, "OK", null).Show ();
} else {
new UIAlertView ("Score Reported Failed", "Score Reported Failed", null, "OK", null).Show ();
}
NSThread.SleepFor (1);
controller.updateHighScore ();
}));
}
public void ReportScore (long score, string category, MTGKTapperViewController controller)
{
var scoreReporter = new GKScore (category) {
Value = score
};
scoreReporter.ReportScore (error => {
if (error == null)
ShowAlert("Score reported", "Score Reported successfully");
else
ShowAlert("Score Reported Failed", "Score Reported Failed");
NSThread.SleepFor (1);
controller.UpdateHighScore ();
});
}
public void UpdateScore(string aCategory, long aScore)
{
if (IsSignedInToLive)
{
GKScore score = new GKScore(aCategory);
score.Value = aScore;
score.ReportScore(delegate(NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
}
}
void RetrieveTopTenScores()
{
GKLeaderboard leaderboardRequest = new GKLeaderboard();
if (leaderboardRequest != null)
{
// configure request
leaderboardRequest.playerScope = GKLeaderboardPlayerScope.Global;
leaderboardRequest.timeScope = GKLeaderboardTimeScope.AllTime;
leaderboardRequest.category = leaderboardID;
Log("Getting leaderboard identifier: " + leaderboardRequest.identifier);
Log("Getting leaderboard category: " + leaderboardRequest.category);
Log("Getting leaderboard group identifier: " + leaderboardRequest.groupIdentifier);
leaderboardRequest.range = new NSRange(1, 10);
// load scores; it calls delegate back when done
leaderboardRequest.LoadScores(delegate(object[] scores, NSError error) {
if (error != null)
{
Log("Error retrieving scores: " + error.LocalizedDescription());
}
else if (scores != null)
{
// got the scores, but the low-level GKScore only has player ID.
// if you want player display name, you need to combine it with
// the high-level API to load the players
string[] playerIDs = scores.Cast <GKScore>().Select(x => x.playerID).ToArray();
Player.LoadPlayersByIDs(playerIDs, delegate(Player[] players) {
// print localized title of leaderboard
Log("Top 10 for " + leaderboardRequest.title);
for (int i = 0; i < scores.Length; i++)
{
GKScore score = scores[i] as GKScore;
result += score.formattedValue + System.Environment.NewLine;
Player player = players[i];
Log(score.rank + ". " + score.formattedValue + ", " + score.date + ", " + player.displayName);
}
});
}
});
}
}
public void reportScore(long score, string category, MTGKTapperViewController controller)
{
GKScore scoreReporter = new GKScore(category);
scoreReporter.Value = score;
scoreReporter.ReportScore(new Action <NSError> ((error) => {
if (error == null)
{
new UIAlertView("Score reported", "Score Reported successfully", null, "OK", null).Show();
}
else
{
new UIAlertView("Score Reported Failed", "Score Reported Failed", null, "OK", null).Show();
}
NSThread.SleepFor(1);
controller.updateHighScore();
}));
}
public void UpdateScore(string aCategory, long aScore)
{
if (IsSignedInToLive)
{
UIApplication.SharedApplication.InvokeOnMainThread(delegate
{
GKScore score = new GKScore(aCategory);
score.Value = aScore;
GKScore.ReportScores(new [] { score }, delegate(NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
});
}
}
async Task UpdateCurrentTapsLeaderboardAndTapAchievements()
{
GKLeaderboard averageTapLeaderboard = new GKLeaderboard(new [] { GKLocalPlayer.LocalPlayer.PlayerID })
{
Identifier = AverageTapTimeId
};
var scores = await averageTapLeaderboard.LoadScoresAsync();
GKScore currentScore;
GKScore newScore = new GKScore(AverageTapTimeId);
if (scores != null && scores.Length > 1)
{
currentScore = scores [0];
int oldTaps = (int)currentScore.Context;
int oldTime = (int)currentScore.Value * oldTaps;
int newTime = oldTime + GameInfo.GameTimeInSeconds * 100;
int newTaps = oldTaps + GameInfo.CurrentTaps;
newScore.Value = newTime / newTaps;
newScore.Context = (ulong)newTaps;
}
else
{
newScore.Value = GameInfo.GameTimeInSeconds / Math.Max(GameInfo.CurrentTaps, 1) * 100;
newScore.Context = (ulong)GameInfo.CurrentTaps;
}
GKAchievement playAHundred = new GKAchievement(Tap100Id, GKLocalPlayer.LocalPlayer.PlayerID)
{
PercentComplete = (float)newScore.Context / 100f * 100f
};
GKAchievement playAThousand = new GKAchievement(Tap1000Id, GKLocalPlayer.LocalPlayer.PlayerID)
{
PercentComplete = (float)newScore.Context / 1000f * 100f
};
await GKAchievement.ReportAchievementsAsync(new [] { playAHundred, playAThousand });
await GKScore.ReportScoresAsync(new [] { newScore });
}
public void ReportScore(long score, string category, MTGKTapperViewController controller)
{
var scoreReporter = new GKScore(category)
{
Value = score
};
scoreReporter.ReportScore(error => {
if (error == null)
{
ShowAlert("Score reported", "Score Reported successfully");
}
else
{
ShowAlert("Score Reported Failed", "Score Reported Failed");
}
NSThread.SleepFor(1);
controller.UpdateHighScore();
});
}
// Attemp to submit a score. On an error store it for a later time
public void submitScore(GKScore score)
{
if (GKLocalPlayer.LocalPlayer.Authenticated)
{
if (score == null)
{
return;
}
score.ReportScore(new Action <NSError> ((error) => {
if (error == null)
{
this.resubmitSotredScores();
new UIAlertView("Score Submitted", "Score submitted successfully ", null, "OK", null).Show();
}
else
{
this.storeScore(score);
new UIAlertView("Score Stored", "Score Stored ", null, "OK", null).Show();
}
}));
}
}
public void UpdateScore(string aCategory, long aScore)
{
if (IsSignedInToLive)
{
UIApplication.SharedApplication.InvokeOnMainThread(delegate
{
GKScore score = new GKScore(aCategory);
score.Value = aScore;
if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
{
#pragma warning disable 618
// Report score for iOS 5 and older
score.ReportScore(delegate(NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
#pragma warning restore 618
}
else
{
// Report score for iOS 6+
GKScore.ReportScores(new GKScore[] { score }, delegate(NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
}
});
}
}
/// <summary>
/// Adds a new leaderboard score.
/// </summary>
/// <param name="leaderboardCode">The leaderboard code.</param>
/// <param name="score">The score.</param>
/// <returns>
/// <c>true</c> if the score has been added; otherwise, <c>false</c>.
/// </returns>
public Task <bool> AddNewScore(string leaderboardCode, long score)
{
var tcs = new TaskCompletionSource <bool>();
UIKit.UIApplication.SharedApplication.InvokeOnMainThread(async() =>
{
var submitScore = new GKScore(leaderboardCode);
submitScore.Value = score;
bool result = true;
try
{
await GKScore.ReportScoresAsync(new GKScore[] { submitScore });
}
catch
{
result = false;
}
tcs.TrySetResult(result);
});
return(tcs.Task);
}
// Attemp to submit a score. On an error store it for a later time
public void submitScore(GKScore score)
{
if (GKLocalPlayer.LocalPlayer.Authenticated)
{
if (score == null)
{
return;
}
score.ReportScore(new GKNotificationHandler((error) =>
{
//if(error == null|| (error.Code ==null && error.Domain == null))
if (error == null)
{
this.resubmitSotredScores();
new UIAlertView("Score Submitted", "Score submitted successfully ", null, "OK", null).Show();
}
else
{
this.storeScore(score);
new UIAlertView("Score Stored", "Score Stored ", null, "OK", null).Show();
}
}));
}
}
public void UpdateScore( string aCategory, long aScore )
{
if (IsSignedInToLive)
{
UIApplication.SharedApplication.InvokeOnMainThread(delegate
{
GKScore score = new GKScore(aCategory);
score.Value = aScore;
GKScore.ReportScores(new [] { score }, delegate(NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
});
}
}
public void RetrieveTopTenScores()
{
#if UNITY_IOS && !UNITY_EDITOR
GKLeaderboard leaderboardRequest = new GKLeaderboard();
if (leaderboardRequest != null)
{
// configure request
leaderboardRequest.playerScope = GKLeaderboardPlayerScope.Global;
leaderboardRequest.timeScope = GKLeaderboardTimeScope.AllTime;
leaderboardRequest.category = leaderboardID;
leaderboardRequest.range = new NSRange(1, 1);
// load scores; it calls delegate back when done
leaderboardRequest.LoadScores(delegate(object[] scores, NSError error) {
if (error != null)
{
//Log("Error retrieving scores: " + error.LocalizedDescription());
}
else if (scores != null)
{
// got the scores, but the low-level GKScore only has player ID.
// if you want player display name, you need to combine it with
// the high-level API to load the players
string[] playerIDs = scores.Cast <GKScore>().Select(x => x.playerID).ToArray();
Player.LoadPlayersByIDs(playerIDs, delegate(Player[] players) {
// print localized title of leaderboard
//Log("Top 100 for " + leaderboardRequest.title);
//current user
GKScore score = leaderboardRequest.localPlayerScore;
int rank = score.rank;
Player player = players[0];
//GameObject.Find ("TESTE").transform.GetChild(0).GetComponent<Text>().text="rank "+rank+" Score "+score+" Name "+player.displayName;
//All scores
/*for (int i=0; i<scores.Length; i++) {
* GKScore score = scores[i] as GKScore;
* Player player = players[i];
* //plname = players[i];
* testescore+=score.rank + ". " + score.formattedValue +", "+player.displayName;
* //testescore+=score.rank + ". " + score.formattedValue;
* //GameObject.Find ("TESTE").transform.GetChild(0).GetComponent<Text>().text="ShowScore "+testescore;
* Debug.Log(score.rank + ". " + score.formattedValue + ", " + score.date + ", " + player.displayName);
* }*/
});
}
});
}
#endif
#if UNITY_ANDROID && !UNITY_EDITOR
/*ILeaderboard lb = Social.CreateLeaderboard();
* lb.id = leaderboardID;
* lb.LoadScores(ok =>
* {
* if (ok) {
* androidstatus="OK retrieving leaderboard";
* LoadUsersAndDisplay(lb);
* }
* else {
* androidstatus="Error retrieving leaderboard";
* }
* });*/
#endif
}
public void UpdateScore( string aCategory, long aScore )
{
if (IsSignedInToLive)
{
GKScore score = new GKScore(aCategory);
score.Value = aScore;
score.ReportScore(delegate (NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
}
}
/// <summary>
/// Reports a high score to Game Center.
/// The returned GKScore can be used for more advanced functionalities such as sending challenges.
/// Raises ScoreReported and ScoreReportFailed events on completion.
/// </summary>
/// <returns>The score.</returns>
/// <param name="leaderboardID">Leaderboard I.</param>
/// <param name="score">Score.</param>
public static GKScore ReportScore(string leaderboardID, long score)
{
var scoreReporter = new GKScore(leaderboardID);
scoreReporter.value = score;
// scoreReporter.context = 0;
scoreReporter.ReportScore(_ScoreReported);
return scoreReporter;
}
// Attemp to submit a score. On an error store it for a later time
public void submitScore(GKScore score)
{
if (GKLocalPlayer.LocalPlayer.Authenticated)
{
if (score == null)
return;
score.ReportScore (new GKNotificationHandler( (error) =>
{
//if(error == null|| (error.Code ==null && error.Domain == null))
if(error == null)
{
this.resubmitSotredScores();
new UIAlertView ("Score Submitted", "Score submitted successfully ", null, "OK", null).Show();
}
else
{
this.storeScore(score);
new UIAlertView ("Score Stored", "Score Stored ", null, "OK", null).Show();
}
}));
}
}
/* ************************************************************************
*
* Scores
*
* *************************************************************************
*/
// Store score for submission at a later time
public void storeScore(GKScore score)
{
storedScores.Add(score);
this.writeStoredScore();
}
async Task ReportScore()
{
string leaderboardIdentifier = null;
string gameTypeString = null;
GameTypePlayed gameType = GameTypePlayed.Invalid;
if (GameInfo.GameTime == GameTime.Fifteen)
{
if (GameInfo.GameMode == GameMode.Easy)
{
gameTypeString = "15secondseasymode";
gameType = GameTypePlayed.Easy15;
}
else if (GameInfo.GameMode == GameMode.Hard)
{
gameTypeString = "15secondshardmode";
gameType = GameTypePlayed.Hard15;
}
}
else if (GameInfo.GameTime == GameTime.Thirty)
{
if (GameInfo.GameMode == GameMode.Easy)
{
gameTypeString = "30secondseasymode";
gameType = GameTypePlayed.Easy30;
}
else if (GameInfo.GameMode == GameMode.Hard)
{
gameTypeString = "30secondshardmode";
gameType = GameTypePlayed.Hard30;
}
}
else if (GameInfo.GameTime == GameTime.FourtyFive)
{
if (GameInfo.GameMode == GameMode.Easy)
{
gameTypeString = "45secondseasymode";
gameType = GameTypePlayed.Easy45;
}
else if (GameInfo.GameMode == GameMode.Hard)
{
gameTypeString = "45secondshardmode";
gameType = GameTypePlayed.Hard45;
}
}
if (gameTypeString != null)
{
leaderboardIdentifier = Prefix + gameTypeString;
}
if (leaderboardIdentifier != null)
{
GKScore score = new GKScore(leaderboardIdentifier)
{
Value = GameInfo.CurrentTaps,
Context = 0
};
var challenges = GameInfo.Challenge == null ? null : new [] { GameInfo.Challenge };
await GKScore.ReportScoresAsync(new [] { score }, challenges);
}
if (GKLocalPlayer.LocalPlayer.Authenticated)
{
if (GameInfo.GameMode == GameMode.Hard)
{
var playhard = new GKAchievement(PlayHardId, GKLocalPlayer.LocalPlayer.PlayerID)
{
PercentComplete = 100
};
await GKAchievement.ReportAchievementsAsync(new [] { playhard });
}
int playedGameTypesBitField;
using (NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults) {
playedGameTypesBitField = defaults.IntForKey("playedGameTypes") | (int)gameType;
defaults.SetInt(playedGameTypesBitField, "playedGameTypes");
defaults.Synchronize();
}
int numTypesPlayed = 0;
for (int i = 0; i < 6; i++)
{
if ((playedGameTypesBitField & 0x01) != 0)
{
numTypesPlayed++;
}
playedGameTypesBitField >>= 1;
}
GKAchievement playAllModesAchievement = new GKAchievement(PlayAllId)
{
PercentComplete = numTypesPlayed / 6.0 * 100.0
};
await GKAchievement.ReportAchievementsAsync(new [] { playAllModesAchievement });
await UpdateCurrentTapsLeaderboardAndTapAchievements();
}
}
public void UpdateScore(string aCategory, long aScore)
{
if (IsSignedInToLive)
{
UIApplication.SharedApplication.InvokeOnMainThread(delegate
{
GKScore score = new GKScore(aCategory);
score.Value = aScore;
if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
{
#pragma warning disable 618
// Report score for iOS 5 and older
score.ReportScore(delegate (NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
#pragma warning restore 618
}
else
{
// Report score for iOS 6+
GKScore.ReportScores(new GKScore[] { score }, delegate (NSError error)
{
if (error != null)
{
// Oh oh something went wrong.
}
});
}
});
}
}
void submitScoreHandleTouchUpInside (object sender, EventArgs e)
{
if (!GKLocalPlayer.LocalPlayer.Authenticated) {
new UIAlertView ("Error", "Need sign in Game Center to submit the score", null, "OK", null).Show();
GKLocalPlayer.LocalPlayer.Authenticate (authenticatedHandler);
return;
}
GKScore submitScore = new GKScore ("leaderboard");
submitScore.Init ();
try{
submitScore.Value = Convert.ToInt64(this.scoreTextField.Text);
}
catch{
new UIAlertView ("Error", "Score should be a number", null, "OK", null).Show();
return;
}
submitScore.ShouldSetDefaultLeaderboard = true;
submitScore.Context = 100;
player.submitScore (submitScore);
}
public override void AddScore(GameMode mode, GameDifficulty difficulty, int score)
{
if (mode != GameMode.VERSUS)
{
string leaderboardId = GetLeaderboardId(mode, difficulty);
Logger.I("Game Center - Adding score to " + leaderboardId + "...");
GKScore gkScore = new GKScore(leaderboardId);
gkScore.Value = score;
gkScore.ReportScore((error) => {
if (error != null)
{
Logger.E("Game Center - Score not submited! " + error);
}
});
}
}
void DisplayScore (GKScore score, int rank, GKPlayer player)
{
PointF[] podiumPositions = new PointF[] {
new PointF (0, 100),
new PointF (-84, 75),
new PointF (84, 50)
};
PointF currentPoint = podiumPositions [rank];
SKLabelNode scoreLabel = new SKLabelNode ("GillSans-Bold") {
Text = score.FormattedValue,
FontSize = 14,
Position = new PointF (FrameMidX + currentPoint.X, FrameMidY + currentPoint.Y - 32)
};
player.LoadPhoto (GKPhotoSize.Small, delegate (UIImage photo, NSError error) {
if (photo == null)
photo = UIImage.FromFile ("Images/DefaultPlayerPhoto.png");
var image = SKSpriteNode.FromTexture (SKTexture.FromImage (photo), new SizeF (32, 32));
image.Position = new PointF (FrameMidX + currentPoint.X, FrameMidY + currentPoint.Y + 16);
AddChild (image);
});
AddChild (scoreLabel);
}
async Task UpdateCurrentTapsLeaderboardAndTapAchievements ()
{
GKLeaderboard averageTapLeaderboard = new GKLeaderboard (new [] { GKLocalPlayer.LocalPlayer.PlayerID }) {
Identifier = AverageTapTimeId
};
var scores = await averageTapLeaderboard.LoadScoresAsync ();
GKScore currentScore;
GKScore newScore = new GKScore (AverageTapTimeId);
if (scores != null && scores.Length > 1) {
currentScore = scores [0];
int oldTaps = (int)currentScore.Context;
int oldTime = (int)currentScore.Value * oldTaps;
int newTime = oldTime + GameInfo.GameTimeInSeconds * 100;
int newTaps = oldTaps + GameInfo.CurrentTaps;
newScore.Value = newTime / newTaps;
newScore.Context = (ulong)newTaps;
} else {
newScore.Value = GameInfo.GameTimeInSeconds / Math.Max (GameInfo.CurrentTaps, 1) * 100;
newScore.Context = (ulong)GameInfo.CurrentTaps;
}
GKAchievement playAHundred = new GKAchievement (Tap100Id, GKLocalPlayer.LocalPlayer.PlayerID) {
PercentComplete = (float) newScore.Context / 100f * 100f
};
GKAchievement playAThousand = new GKAchievement (Tap1000Id, GKLocalPlayer.LocalPlayer.PlayerID) {
PercentComplete = (float) newScore.Context / 1000f * 100f
};
await GKAchievement.ReportAchievementsAsync (new [] { playAHundred, playAThousand });
await GKScore.ReportScoresAsync (new [] { newScore });
}
async void ChallengeFriends ()
{
if (!GKLocalPlayer.LocalPlayer.Authenticated) {
new UIAlertView ("Player not logged in", "Must be logged into Game Center to challenge friends",
null, "Okay", null).Show ();
return;
}
if (GKLocalPlayer.LocalPlayer.Friends == null)
await GKLocalPlayer.LocalPlayer.LoadFriendsAsync ();
GKScore score = new GKScore () {
LeaderboardIdentifier = MainGame.Prefix + "15secondseasymode",
Context = (ulong)GameTypePlayed.Easy15,
Value = 10
};
UIViewController challengeController = score.ChallengeComposeController (
GKLocalPlayer.LocalPlayer.Friends, "Beat it!",
delegate (UIViewController composeController, bool didIssueChallenge, string[] sentPlayerIDs) {
AppDelegate.Shared.ViewController.DismissViewController (true, null);
}
);
AppDelegate.Shared.ViewController.PresentViewController (challengeController, true, null);
}
// Attemp to submit a score. On an error store it for a later time
public void submitScore (GKScore score)
{
if (GKLocalPlayer.LocalPlayer.Authenticated) {
if (score == null)
return;
score.ReportScore (new Action<NSError> ((error) => {
if (error == null) {
this.resubmitSotredScores ();
new UIAlertView ("Score Submitted", "Score submitted successfully ", null, "OK", null).Show ();
} else {
this.storeScore (score);
new UIAlertView ("Score Stored", "Score Stored ", null, "OK", null).Show ();
}
}));
}
}
/* ************************************************************************
*
* Scores
*
* *************************************************************************
*/
// Store score for submission at a later time
public void storeScore (GKScore score)
{
storedScores.Add (score);
this.writeStoredScore ();
}
async Task ReportScore ()
{
string leaderboardIdentifier = null;
string gameTypeString = null;
GameTypePlayed gameType = GameTypePlayed.Invalid;
if (GameInfo.GameTime == GameTime.Fifteen) {
if (GameInfo.GameMode == GameMode.Easy) {
gameTypeString = "15secondseasymode";
gameType = GameTypePlayed.Easy15;
} else if (GameInfo.GameMode == GameMode.Hard) {
gameTypeString = "15secondshardmode";
gameType = GameTypePlayed.Hard15;
}
} else if (GameInfo.GameTime == GameTime.Thirty) {
if (GameInfo.GameMode == GameMode.Easy) {
gameTypeString = "30secondseasymode";
gameType = GameTypePlayed.Easy30;
} else if (GameInfo.GameMode == GameMode.Hard) {
gameTypeString = "30secondshardmode";
gameType = GameTypePlayed.Hard30;
}
} else if (GameInfo.GameTime == GameTime.FourtyFive) {
if (GameInfo.GameMode == GameMode.Easy) {
gameTypeString = "45secondseasymode";
gameType = GameTypePlayed.Easy45;
} else if (GameInfo.GameMode == GameMode.Hard) {
gameTypeString = "45secondshardmode";
gameType = GameTypePlayed.Hard45;
}
}
if (gameTypeString != null)
leaderboardIdentifier = Prefix + gameTypeString;
if (leaderboardIdentifier != null) {
GKScore score = new GKScore (leaderboardIdentifier) {
Value = GameInfo.CurrentTaps,
Context = 0
};
var challenges = GameInfo.Challenge == null ? null : new [] { GameInfo.Challenge };
await GKScore.ReportScoresAsync (new [] { score }, challenges);
}
if (GKLocalPlayer.LocalPlayer.Authenticated) {
if (GameInfo.GameMode == GameMode.Hard) {
var playhard = new GKAchievement (PlayHardId, GKLocalPlayer.LocalPlayer.PlayerID) {
PercentComplete = 100
};
await GKAchievement.ReportAchievementsAsync (new [] { playhard });
}
int playedGameTypesBitField;
using (NSUserDefaults defaults = NSUserDefaults.StandardUserDefaults) {
playedGameTypesBitField = (int)defaults.IntForKey ("playedGameTypes") | (int) gameType;
defaults.SetInt (playedGameTypesBitField, "playedGameTypes");
defaults.Synchronize ();
}
int numTypesPlayed = 0;
for (int i = 0; i < 6; i++) {
if ((playedGameTypesBitField & 0x01) != 0)
numTypesPlayed++;
playedGameTypesBitField >>= 1;
}
GKAchievement playAllModesAchievement = new GKAchievement (PlayAllId) {
PercentComplete = numTypesPlayed / 6.0 * 100.0
};
await GKAchievement.ReportAchievementsAsync (new [] { playAllModesAchievement });
await UpdateCurrentTapsLeaderboardAndTapAchievements ();
}
}
public async void checkHighest(int sc, string level)
{
string catString = "com.commtech.inapppurchTest.StageScores"; //com.commtech.inapppurchTest.
GKLocalPlayer xx = GKLocalPlayer.LocalPlayer;
GKLeaderboard Leaderboard = new GKLeaderboard(new [] { xx.PlayerID })
{
Identifier = catString
};
var ss = Leaderboard.LocalPlayerScore;
//var scores = await Leaderboard.LoadScoresAsync ();
var oldScore = 0; //ss.Value;
//var oldScore = current.Value;
// if (ss.Value != null) {
//
// oldScore = (int)ss.Value;
// }
// var Category = Convert.ToInt64( level.Substring (1, 1));
//
// Console.WriteLine ("XXXXXXXXXXXXXXXXXXMXMXMXMXMMXMXMXXXXXXMXMXMXXXXXXXX");
//
// if (oldScore == null) {
var newScore = new GKScore(catString)
{
Value = sc
};
newScore.ReportScore(new Action <NSError> ((error) => {
if (error == null)
{
Console.WriteLine("YYYYYYYYYYYYYYYYYYYYYYYYYYBBBYYYBYBYBYBYYyy");
//new UIAlertView ("Score reported", "Score Reported successfully", null, "OK", null).Show ();
}
else
{
Console.WriteLine("XXXXXXXXXXXXXXXXXXMXMXMXMXMMXMXMXXXXXXMXMXMXXXXXXXX");
//new UIAlertView ("Score Reported Failed", "Score Reported Failed", null, "OK", null).Show ();
}
NSThread.SleepFor(1);
//controller.updateHighScore ();
}));
//
// Console.WriteLine ("score::" + newScore.Value);
// await GKScore.ReportScoresAsync(new [] { newScore });
////
// }
// else if (sc > oldScore) {
// // gcm.reportScore (sc, car);
// var newScore = new GKScore (catString) {
// Value = sc
//
// };
//
// //await GKScore.ReportScoresAsync(new [] { newScore });
//
// }
//GameCenterManager1 gcm = new GameCenterManager1 ();
}
