private IEnumerator WaitForRequest(int boardid)
{
string URL = "https://apps.mw-systems.com/api/v1/leaderboards/getallscores";
WWWForm form = new WWWForm();
form.AddField("api_key", API_KEY);
form.AddField("board_id", boardid);
UnityWebRequest www = UnityWebRequest.Post(URL, form);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
StartCoroutine(Queue());
}
else
{
string result = www.downloadHandler.text;
RequestStatus requestResult = JsonUtility.FromJson <RequestStatus>(result);
if (requestResult.status.code != 0)
{
//Debug.LogWarning(requestResult.status.msg);
OnFinishedDelegate?.Invoke(null);
}
else
{
LeaderboardResult res = JsonUtility.FromJson <LeaderboardResult>(result);
OnFinishedDelegate?.Invoke(res.entries);
}
}
}
private void ProcessLeaderboard(LeaderboardResult result)
{
var output = string.Empty;
if (result != null)
{
// Show information about the leaderboard
output = output.WriteMessageLine("Leaderboard: " + result.DisplayName);
// Show the columns in the leaderbard
output = output.WriteMessageLine("Column count:" + result.Columns.Count.ToString());
foreach (var column in result.Columns)
{
// Display the LeaderboardColumn property bag
output = output.WriteMessageLine(column.DisplayName);
output = output.WriteMessageLine(column.StatisticName);
output = output.WriteMessageLine(column.StatisticType.ToString());
}
// Show the user's row in the leaderboard
output = output.WriteMessageLine("Row count:" + result.TotalRowCount.ToString());
foreach (var row in result.Rows)
{
// Display the LeaderboardRow property bag
output = output.WriteMessageLine(row.XboxUserId);
output = output.WriteMessageLine(row.Gamertag);
output = output.WriteMessageLine(row.Percentile.ToString());
output = output.WriteMessageLine(row.Rank.ToString());
}
WriteOutputMessage(outputMessage, output);
}
}
public static List <LeaderboardResult> ConvertStringToResult(string wwwResult)
{
List <LeaderboardResult> result = new List <LeaderboardResult>();
string[] lines = wwwResult.Split('\n');
foreach (string line in lines)
{
if (string.IsNullOrEmpty(line))
{
continue;
}
string[] lineParts = line.Split('|');
LeaderboardResult convertedLine = new LeaderboardResult
{
place = int.Parse(lineParts[5]) + 1,
name = lineParts[0],
score = int.Parse(lineParts[1])
};
result.Add(convertedLine);
}
return(result);
}
public static List <LeaderboardResult> GetLeaderboard(Server.TokenAndId tai, bool backgammon, bool narde, int size)
{
string backgammonString = backgammon ? "1" : "0";
string nardeString = narde ? "1" : "0";
string str = "leaderboard " + "id=" + tai.id + ";token=" + tai.token + ";size=" + size + ";" + "backgammon=" + backgammonString + ";narde=" + nardeString;
Response response = DBSocketRequest.Send(str);
if (response is ErrorResponse)
{
Exception exception = ((ErrorResponse)response).ThrowException();
throw exception;
}
else
{
double[][] result = JsonConvert.DeserializeObject <double[][]>(response.ToString());
List <LeaderboardResult> res = new List <LeaderboardResult>();
for (int i = 0; i < result.Length; i++)
{
int id = (int)(result[i][0]);
int games = (int)(result[i][1]);
double roi = (int)(result[i][2]);
double rating = (int)(result[i][3]);
LeaderboardResult lr = new LeaderboardResult();
lr.id = id;
lr.games = games;
lr.roi = roi;
lr.rating = rating;
res.Add(lr);
}
return(res);
}
}
private void UpdateData(LeaderboardResult data)
{
if (Stat != null &&
(data.NextQuery == null ||
(data.NextQuery != null && data.NextQuery.StatName == Stat.Name)))
{
this.leaderboardData = data;
if (this.totalPages == 0)
{
this.totalPages = (this.leaderboardData.TotalRowCount - 1) / this.entryCount + 1;
}
this.pageText.text = string.Format("Page: {0} / {1}", this.currentPage + 1, this.totalPages);
while (this.contentPanel.childCount > 0)
{
var entry = this.contentPanel.GetChild(0).gameObject;
this.entryObjectPool.ReturnObject(entry);
}
foreach (LeaderboardRow row in this.leaderboardData.Rows)
{
GameObject entryObject = this.entryObjectPool.GetObject();
LeaderboardEntry entry = entryObject.GetComponent <LeaderboardEntry>();
entry.Data = row;
entryObject.transform.SetParent(this.contentPanel);
}
this.UpdateButtons();
}
}
public async Task GetLeaderboard()
{
LeaderboardQuery query = new LeaderboardQuery
{
StatName = "Jumps",
MaxItems = 100,
};
LeaderboardResult result = await this.leaderboardService.GetLeaderboardAsync(this.user, query);
MockXboxLiveData.MockRequestData mockRequestData = MockXboxLiveData.MockResponses["defaultLeaderboardData"];
JObject responseJson = JObject.Parse(mockRequestData.Response.ResponseBodyString);
Assert.AreEqual("GET", mockRequestData.Request.Method);
Assert.AreEqual("https://leaderboards.xboxlive.com/scids/00000000-0000-0000-0000-0000694f5acb/leaderboards/stat(Jumps)?maxItems=100", mockRequestData.Request.Url);
Assert.IsTrue(result.HasNext);
VerifyLeaderboardResult(result, responseJson);
// Testing continuation token with GetNext.
LeaderboardQuery nextQuery = new LeaderboardQuery(query, "6");
LeaderboardResult nextResult = await this.leaderboardService.GetLeaderboardAsync(this.user, nextQuery);
MockXboxLiveData.MockRequestData mockRequestDataWithContinuationToken = MockXboxLiveData.MockResponses["defaultLeaderboardDataWithContinuationToken"];
JObject responseJsonWithContinuationToken = JObject.Parse(mockRequestDataWithContinuationToken.Response.ResponseBodyString);
Assert.AreEqual("GET", mockRequestDataWithContinuationToken.Request.Method);
Assert.AreEqual("https://leaderboards.xboxlive.com/scids/00000000-0000-0000-0000-0000694f5acb/leaderboards/stat(Jumps)?maxItems=100&continuationToken=6", mockRequestDataWithContinuationToken.Request.Url);
Assert.IsFalse(nextResult.HasNext);
VerifyLeaderboardResult(nextResult, responseJsonWithContinuationToken);
}
public void GetLeaderboard(XboxLiveUser user, string statName, LeaderboardQuery query)
{
if (!LocalUsers.Contains(user))
{
throw new ArgumentException("Local User needs to be added.");
}
if (!mStats.ContainsKey(statName))
{
mStats[statName] = new StatisticValue()
{
Name = statName,
AsInteger = 300,
AsNumber = 300,
DataType = StatisticDataType.Number
};
}
StatisticValue stat = mStats[statName];
List <LeaderboardRow> rows = new List <LeaderboardRow>();
uint maxScore = query.MaxItems * 100;
uint rankOffset = query.SkipResultToRank == 0 ? 1 : query.SkipResultToRank;
bool userDisplayed = false;
for (uint i = 0; i < query.MaxItems; i++)
{
uint score = maxScore - i * 100;
LeaderboardRow row;
if (!userDisplayed && stat.DataType == StatisticDataType.Number && (stat.AsNumber >= score || stat.AsInteger >= score))
{
userDisplayed = true;
row = new LeaderboardRow(new List <string> {
stat.AsNumber.ToString()
}, i + rankOffset, 0.8, user.XboxUserId, user.Gamertag);
}
else
{
row = new LeaderboardRow(new List <string> {
score.ToString()
}, i + rankOffset, 0.8, string.Format("{0}{0}{0}{0}{0}{0}{0}{0}", i), string.Format("Gamertag {0}", i));
}
rows.Add(row);
}
List <LeaderboardColumn> cols = new List <LeaderboardColumn>();
cols.Add(new LeaderboardColumn(stat.DataType == StatisticDataType.String ? LeaderboardStatType.String : LeaderboardStatType.Integer, ""));
LeaderboardResult result = new LeaderboardResult(rows, cols, query.MaxItems);
LeaderboardResultEventArgs args = new LeaderboardResultEventArgs(result);
mStatEventList.Add(new StatisticEvent(StatisticEventType.GetLeaderboardComplete, user, args));
}
private string GetColumnsString(LeaderboardResult result)
{
string output = "";
foreach (LeaderboardColumn column in result.Columns)
{
output += (column.DisplayName + ", ");
}
return(output);
}
private void LogLeaderboardResult(LeaderboardResult result)
{
LogLine("Columns: " + GetColumnsString(result));
foreach (LeaderboardRow row in result.Rows)
{
LogLine(String.Format("Gamertag: {0}, Rank: {1}, Percentile: {2}, Values: {3}",
row.Gamertag, row.Rank, row.Percentile, GetRowValuesString(row)));
}
LogLine("");
}
async void DoWork()
{
while (true)
{
if (this.User.IsSignedIn)
{
// Perform the long running do work task on a background thread.
var statsDoWorkTask = Task.Run(() => { return(this.StatsManager.DoWork()); });
List <StatEvent> statsEvents = await statsDoWorkTask;
foreach (StatEvent ev in statsEvents)
{
if (ev.EventType == StatEventType.GetLeaderboardComplete)
{
LeaderboardResult result = ((LeaderboardResultEventArgs)ev.EventArgs).Result;
this.LeaderboardResult = result;
NextLbBtn.IsEnabled = result.HasNext;
}
}
var statNames = this.StatsManager.GetStatNames(this.User);
if (statNames.Count > 0)
{
foreach (var stat in statNames)
{
if (string.Equals(stat, "headshots"))
{
this.headshots = this.StatsManager.GetStat(this.User, "headshots").AsInteger();
}
else if (string.Equals(stat, "jumps"))
{
this.jumps = this.StatsManager.GetStat(this.User, "jumps").AsInteger();
}
}
this.StatsData.Text = string.Join(Environment.NewLine, statNames.Select(n => this.StatsManager.GetStat(this.User, n)).Select(s => $"{s.Name} ({s.Type}) = {s.Value}"));
}
var socialDoWorkTask = Task.Run(() => { return(this.SocialManager.DoWork()); });
IList <SocialEvent> socialEvents = await socialDoWorkTask;
foreach (SocialEvent ev in socialEvents)
{
string msg;
msg = "SocialEvent: " + ev.EventType.ToString();
Debug.WriteLine(msg);
RefreshSocialGroups();
}
}
// don't run again for at least 200 milliseconds
await Task.Delay(200);
}
}
/// <summary>
/// Load the leaderboard result data from the service into the view.
/// </summary>
/// <param name="result"></param>
private void LoadResult(LeaderboardResult result)
{
if (this.stat == null || (result.HasNext && (this.stat.ID != result.GetNextQuery().StatName || this.socialGroup != result.GetNextQuery().SocialGroup)))
{
return;
}
this.leaderboardData = result;
uint displayCurrentPage = this.currentPage + 1;
if (this.leaderboardData.TotalRowCount == 0)
{
this.totalPages = 0;
displayCurrentPage = 0;
}
else if (this.totalPages == 0)
{
this.totalPages = (uint)Mathf.Ceil(this.leaderboardData.TotalRowCount / this.entryCount);
}
this.pageText.text = string.Format("Page: {0} / {1}", displayCurrentPage, this.totalPages);
while (this.contentPanel.childCount > 0)
{
var entry = this.contentPanel.GetChild(0).gameObject;
this.entryObjectPool.ReturnObject(entry);
}
var xuids = new List <string>();
foreach (LeaderboardRow row in this.leaderboardData.Rows)
{
xuids.Add(row.XboxUserId);
GameObject entryObject = this.entryObjectPool.GetObject();
LeaderboardEntry entry = entryObject.GetComponent <LeaderboardEntry>();
entry.Data = row;
entryObject.transform.SetParent(this.contentPanel);
}
userGroup = SocialManager.SingletonInstance.CreateSocialUserGroupFromList(XboxLiveUserManager.Instance.UserForSingleUserMode.User, xuids);
// Reset the scroll view to the top.
this.scrollRect.verticalNormalizedPosition = 1;
this.UpdateButtons();
}
/// <summary>
/// Load the leaderboard result data from the service into the view.
/// </summary>
/// <param name="result"></param>
private void LoadResult(LeaderboardResult result)
{
if (this.stat == null || this.stat.ID != result.NextQuery.StatName || this.socialGroup != result.NextQuery.SocialGroup)
{
return;
}
this.leaderboardData = result;
uint displayCurrentPage = this.currentPage + 1;
if (this.leaderboardData.TotalRowCount == 0)
{
this.totalPages = 0;
displayCurrentPage = 0;
}
else if (this.totalPages == 0)
{
this.totalPages = (this.leaderboardData.TotalRowCount - 1) / (this.entryCount + 1);
}
this.pageText.text = string.Format("Page: {0} / {1}", displayCurrentPage, this.totalPages);
while (this.contentPanel.childCount > 0)
{
var entry = this.contentPanel.GetChild(0).gameObject;
this.entryObjectPool.ReturnObject(entry);
}
foreach (LeaderboardRow row in this.leaderboardData.Rows)
{
GameObject entryObject = this.entryObjectPool.GetObject();
LeaderboardEntry entry = entryObject.GetComponent <LeaderboardEntry>();
entry.Data = row;
entryObject.transform.SetParent(this.contentPanel);
}
// Reset the scroll view to the top.
this.scrollRect.verticalNormalizedPosition = 1;
this.UpdateButtons();
}
private static void VerifyLeaderboardResult(LeaderboardResult result, JObject resultToVerify)
{
Assert.AreNotEqual(result, null, "LeaderboardResult was null.");
JObject leaderboardInfoJson = JObject.Parse(resultToVerify["leaderboardInfo"].ToString());
Assert.AreEqual(result.TotalRowCount, (uint)leaderboardInfoJson["totalCount"]);
JObject jsonColumn = JObject.Parse(leaderboardInfoJson["columnDefinition"].ToString());
VerifyLeaderboardColumn(result.Columns[0], jsonColumn);
JArray jsonRows = (JArray)(resultToVerify)["userList"];
int index = 0;
foreach (var row in jsonRows)
{
VerifyLeaderboardRow(result.Rows[index++], (JObject)row);
}
}
// Initialize Play Services variables upon login.
private void InitializeServicesVariables()
{
if (initPlayServices)
{
return;
}
initPlayServices = true;
highestSubmittedScores = new Dictionary <string, long>();
leaderboardData = null;
curLeaderboardIndex = 0;
leaderboardListLoadState = LeaderboardLoadState.DoneLoading;
leaderboardUserLoadState = LeaderboardLoadState.DoneLoading;
leaderboardCollectionSetting = LeaderboardCollection.Public;
leaderboardTimeSpanSetting = LeaderboardTimeSpan.AllTime;
// Initialize data instances for each entry in a page.
leaderboardResults = new LeaderboardResult[LEADERBOARD_ENTRIES_PER_PAGE];
leaderboardListUi = new LeaderboardItemUI[LEADERBOARD_ENTRIES_PER_PAGE];
leaderboardPageCount = 0;
curUserFilter = new string[1] {
PlayGamesPlatform.Instance.localUser.id
};
// Configure dropdowns for leaderboards.
leaderboardTimeFrame.ForceItems("Today", "This Week", "All Time");
leaderboardCollection.ForceItems("Global", "Friends");
leaderboardTimeFrame.SelectItem(2); // All Time.
leaderboardCollection.SelectItem(0); // Global.
for (int i = 0; i < LEADERBOARD_ENTRIES_PER_PAGE; i++)
{
leaderboardResults[i] = new LeaderboardResult();
leaderboardListUi[i] = SetupLeaderboardListItem(leaderboardListStart);
leaderboardListUi[i].cachedGo.SetActive(false);
}
curUserLeaderboardItem = SetupLeaderboardListItem(leaderboardCurPlayerStart);
curUserLeaderboardItem.cachedGo.SetActive(false);
}
private async void GetLeaderboard()
{
if (m_context == null)
{
LogLine("A user is required to get leaderboards. Please sign in a user first.");
LogLine("");
}
else
{
LogLine("Getting leaderboard...");
LogLine("");
try
{
LeaderboardResult result = await m_context.LeaderboardService.GetLeaderboardAsync(
m_context.AppConfig.ServiceConfigurationId, "LBEnemyDefeatsDescending");
LogLeaderboardResult(result);
// A single call to GetLeaderboardAsync only returns the top ten entries, so let's
// request a couple more pages.
const int maxResultsToLog = 3;
int resultsLogged = 1;
while (result.HasNext && resultsLogged < maxResultsToLog)
{
result = await result.GetNextAsync(10);
LogLeaderboardResult(result);
resultsLogged++;
}
}
catch (Exception ex)
{
LogLine("GetLeaderboard failed: " + ex.Message);
LogLine("");
}
}
}
private async void StatsDoWork_Click(object sender, RoutedEventArgs e)
{
if (!this.xblUser.IsSignedIn)
{
return;
}
List <StatEvent> events = StatsManager.Singleton.DoWork();
foreach (StatEvent ev in events)
{
if (ev.EventType == StatEventType.GetLeaderboardComplete)
{
LeaderboardResult result = ((LeaderboardResultEventArgs)ev.EventArgs).Result;
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
this.leaderboardData.Text = "\nrows: " + result.Rows.Count + "\n";
foreach (LeaderboardRow row in result.Rows)
{
this.leaderboardData.Text += row.Gamertag + ": " + row.Rank + " - " + row.Values[0] + "\n";
}
});
if (result.HasNext)
{
if (string.IsNullOrEmpty(result.NextQuery.SocialGroup))
{
StatsManager.Singleton.GetLeaderboard(ev.LocalUser, result.NextQuery.StatName, result.NextQuery);
}
else
{
StatsManager.Singleton.GetSocialLeaderboard(ev.LocalUser, result.NextQuery.StatName, result.NextQuery.SocialGroup, result.NextQuery);
}
}
}
}
}
public static async Task <LeaderboardData> GetLeaderboardAsync(string leaderboard)
{
if (_context == null || !SignedIn)
{
return(null);
}
LeaderboardResult lbr = await _context.LeaderboardService.GetLeaderboardAsync(ServiceConfigId, leaderboard);
LeaderboardData ld = new LeaderboardData();
foreach (var item in lbr.Rows)
{
LeaderboardItem li = new LeaderboardItem()
{
Rank = item.Rank,
Gamertag = item.Gamertag,
Value = item.Values[0]
};
ld.Items.Add(li);
}
return(ld);
}
internal LeaderboardResultEventArgs(IntPtr leaderboardResultEventArgsPtr)
{
LEADERBOARD_RESULT_EVENT_ARGS cArgs = MarshalingHelpers.PtrToStructure <LEADERBOARD_RESULT_EVENT_ARGS>(leaderboardResultEventArgsPtr);
Result = new LeaderboardResult(cArgs.Result);
}
public void Refresh(LeaderboardResult item)
{
Refresh(item.rank, item.username, item.score);
}
public virtual void GetLeaderboardDataResponse(LeaderboardResult leaderboardResult)
{
}
public void OnResult(Type type, Message message) {
if (message is PlayerResult) {
PlayerResult playerResult = (PlayerResult)message;
if (playerResult.success) {
//Debug.Log("player result success");
//Debug.Log("PlayerResult : " + type.Name + " success, playerName : " + playerResult.playerName);
playerName = playerResult.playerName;
GameObject.FindObjectOfType<LeaderboardManager>().CloseSetNameUI();
#if !UNITY_WEBGL
if(playerHighScoreDaily > 0)
{
UpdateHighScore(playerHighScoreDaily);
}
else if(type == typeof(GetPlayer))
{
CallGetLeaderboard();
}
#endif
}
else {
Debug.Log("PlayerResult : " + type.Name + " failed");
if (type == typeof(GetPlayer)) {
Debug.Log("No player found. Request name");
GameObject.FindObjectOfType<LeaderboardManager>().RequestName();
}
else
{
Debug.Log(playerResult.reason + " " + type);
GameObject.FindObjectOfType<LeaderboardManager>().playerNameFailReason.text =
LocalizedString.GetString(playerResult.reason);
GameObject.FindObjectOfType<LeaderboardManager>().playerNameFailReason.gameObject.SetActive(true);
}
}
} else if (message is LeaderboardResult) {
LeaderboardResult leaderboardResult = (LeaderboardResult)message;
string leaderboardString = "LeaderboardResult : " + type.Name + ", rank:" + leaderboardResult.playerRank + ", score:" + leaderboardResult.playerScore + ", bestscore:" + leaderboardResult.playerBestScore;
int rank = 1;
foreach (LeaderboardPlayer player in leaderboardResult.leaderboard) {
leaderboardString += "\n " + rank++ + ". " + player.playerName + " : " + player.playerScore;
}
Debug.Log(leaderboardString);
if (type == typeof(GetLeaderboard) || type == typeof(UpdateHighScore)) {
List<LeaderboardPlayer> lpList = leaderboardResult.leaderboard;
if (playerHighScoreDaily < leaderboardResult.playerScore)
{
playerHighScoreDaily = leaderboardResult.playerScore;
}
if (playerHighScore < leaderboardResult.playerBestScore)
{
playerHighScore = leaderboardResult.playerBestScore;
}
GameObject.FindObjectOfType<LeaderboardManager>().playerNameText.text = playerName;
GameObject.FindObjectOfType<LeaderboardManager>().playerHighScoreText.text = LocalizedString.GetString("today") + " " + playerHighScoreDaily.ToString();
if (leaderboardResult.playerRank == -1)
{
GameObject.FindObjectOfType<LeaderboardManager>().playerRank.text
= LocalizedString.GetString("yourRank") + " #";
}
else
{
GameObject.FindObjectOfType<LeaderboardManager>().playerRank.text
= LocalizedString.GetString("yourRank") + " #" +
leaderboardResult.playerRank.ToString();
}
GameObject.FindObjectOfType<LeaderboardManager>().empty.SetActive(lpList.Count < 1);
for (int i = 0; i < lpList.Count; i++)
{
GameObject entry = GameObject.FindObjectOfType<LeaderboardManager>().leaderboardEntryPool.AddToObjectPool();
GameObject.FindObjectOfType<LeaderboardManager>().leaderboardEntries.Clear();
GameObject.FindObjectOfType<LeaderboardManager>().leaderboardEntries.Add(entry);
entry.SetActive(true);
entry.GetComponent<LeaderboardEntry>().UpdateLeaderboardEntry(i + 1, lpList[i]);
}
}
} else if (message is StringMessage) {
string stringMessage = ((StringMessage)message).message;
Debug.Log("StringMessage : " + stringMessage);
} else {
Debug.Log("Unknown result type : " + message._class);
}
}
/// <summary>
/// Load the leaderboard result data from the service into the view.
/// </summary>
/// <param name="result"></param>
private void LoadResult(LeaderboardResult result)
{
if (this.stat == null || (result.HasNext && (this.stat.ID != result.GetNextQuery().StatName || this.socialGroup != result.GetNextQuery().SocialGroup)))
{
return;
}
this.leaderboardData = result;
uint displayCurrentPage = this.currentPage + 1;
if (this.leaderboardData.TotalRowCount == 0)
{
this.totalPages = 0;
displayCurrentPage = 0;
}
else if (this.totalPages == 0)
{
this.totalPages = this.leaderboardData.TotalRowCount / this.entryCount;
}
this.pageText.text = string.Format("{0} | {1}", displayCurrentPage, Mathf.Max(displayCurrentPage, this.totalPages));
this.Clear();
IList <string> xuids = new List <string>();
var rowCount = 0;
foreach (LeaderboardRow row in this.leaderboardData.Rows)
{
xuids.Add(row.XboxUserId);
GameObject entryObject = this.entryObjectPool.GetObject();
PlayerProfile entry = entryObject.GetComponent <PlayerProfile>();
entry.Theme = this.Theme;
entry.IsCurrentPlayer = this.xboxLiveUser != null && row.Gamertag.Equals(this.xboxLiveUser.Gamertag);
entry.BackgroundColor = ((rowCount % 2 == 0) ? PlayerProfileBackgrounds.RowBackground02 : PlayerProfileBackgrounds.RowBackground01);
entry.UpdateGamerTag(row.Gamertag);
entry.UpdateRank(true, row.Rank);
if (row.Values != null && row.Values.Count > 0)
{
entry.UpdateScore(true, row.Values[0]);
}
this.StartCoroutine(entry.Reload());
entryObject.transform.SetParent(this.contentPanel);
this.currentEntries.Add(entry);
rowCount++;
entryObject.transform.localScale = Vector3.one;
}
if (xuids.Count > 0)
{
userGroup = XboxLive.Instance.SocialManager.CreateSocialUserGroupFromList(this.xboxLiveUser, xuids);
}
// Reset the scroll view to the top.
this.scrollRect.verticalNormalizedPosition = 1;
this.UpdateButtons();
}
public LeaderboardResultEventArgs(LeaderboardResult result)
{
this.Result = result;
}
// Used for mock services
internal LeaderboardResultEventArgs(LeaderboardResult result)
{
Result = result;
}
