private void LoadSaveResult()
{
if (!FileSystem.LoadEncrypt(FILE_LEADERBOARD, out _resultAll))
{
_resultAll = new List <LeaderboardData>();
}
_result = new LeaderboardData()
{
CorrectQuestions = _correctQuestions,
Date = DateTime.UtcNow,
Points = _points,
TotalQuestions = _questions.Length
};
_resultAll.Add(_result);
_resultAll.Sort((r1, r2) =>
{
var comparation = r2.Points.CompareTo(r1.Points);
if (comparation == 0)
{
comparation = r1.Date.CompareTo(r2.Date);
}
return(comparation);
});
for (int i = _resultAll.Count - 1; i >= COUNT_QUESTION_LEADERBOARD; i--)
{
_resultAll.RemoveAt(i);
}
FileSystem.SaveEncrypt(_resultAll, FILE_LEADERBOARD);
}
public void AddHighScore(string playerName, string playerScore)
{
float playerScoreFloat = float.Parse(playerScore);
LeaderboardData leaderboardDataToFind = null;
foreach (LeaderboardData leaderboardData in top30Scores)
{
float entryScore = float.Parse(leaderboardData.playerScore);
if (entryScore <= playerScoreFloat)
{
leaderboardDataToFind = leaderboardData;
break;
}
}
if (leaderboardDataToFind != null)
{
LinkedListNode <LeaderboardData> leaderboardNode = top30Scores.Find(leaderboardDataToFind);
if (leaderboardNode != null)
{
LeaderboardData newLeaderBoardData = new LeaderboardData(playerName, playerScore);
lastAddedData = newLeaderBoardData;
top30Scores.AddBefore(leaderboardNode, newLeaderBoardData);
}
}
PopulateUI();
Save();
}
//TO WORK WITH - WAY OF RETURNING PLACES
public override void ReadData(LeaderboardData parent)
{
FirebaseDatabase.DefaultInstance.GetReference("LeaderBoard").GetValueAsync().ContinueWith(task => {
if (task.IsFaulted)
{
Debug.LogWarning("Reading data from firebase failed. Exception : " + task.Exception);
return;
}
else if (task.IsCompleted)
{
DataSnapshot data = task.Result;
PlaceData[] output = new PlaceData[3];
int i = 0;
foreach (DataSnapshot d in data.Children)
{
int x = 0;
int.TryParse(d.Value.ToString(), out x);
output[i] = new PlaceData();
output[i].placePoints = x;
i++;
}
parent.initComplete = true;
parent.places = output;
}
});
}
void Start()
{
data = FindObjectOfType <LeaderboardData>();
sceneManager = FindObjectOfType <OgoSceneManager>();
ScoreInputField.ActivateInputField();
}
/// <summary>
/// Check if there is a leaderboard saved and, if there's one,
/// store it in the leaderboard variable
/// </summary>
public void CheckLeaderboard()
{
leaderboardPresence = false;
// take the string from the playerprefs
string _leaderboard = PlayerPrefs.GetString("leaderboard", "empty");
if (_leaderboard == "empty")
{
leaderboardPresence = false;
return;
}
// save data in LeaderboardData class
LeaderboardData _temp = JsonUtility.FromJson <LeaderboardData>(_leaderboard);
leaderboard = _temp.leaderboard;
// sort the list by player position
if (leaderboard.Count > 1)
{
leaderboard.Sort((LeaderboardEntry a, LeaderboardEntry b) => a.position.CompareTo(b.position));
}
leaderboardPresence = true;
}
private void AddHistoryScore()
{
if (Score <= 0)
{
return;
}
if (data.LeaderboardDatas.Count >= 10)
{
for (int i = 0; i < data.LeaderboardDatas.Count; i++)
{
if (Score > data.LeaderboardDatas[i].score)
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.score = _score;
leaderboardData.name = data.playerName;
data.LeaderboardDatas.Add(leaderboardData);
}
}
}
else
{
LeaderboardData leaderboadrData = new LeaderboardData();
leaderboadrData.score = _score;
leaderboadrData.name = data.playerName;
data.LeaderboardDatas.Add(leaderboadrData);
}
}
void SetLeaderboardData(string jsonText)
{
var jsonData = Json.Deserialize(jsonText) as Dictionary <string, object>;
Dictionary <string, object> data = null;
if (NetworkConfig.IsUsingEncryption)
{
var enc = jsonData [TAG_DATA] as string;
data = Json.Deserialize(AES.Decrypt(enc)) as Dictionary <string, object>;
}
else
{
data = jsonData[TAG_DATA] as Dictionary <string, object>;
}
//Load leaderboard point
listLeaderboardDataPoint.Clear();
var leaderboardPoint = data[TAG_LEADERBOARD_POINT] as List <object>;
for (int i = 0; i < leaderboardPoint.Count; i++)
{
var rawData = leaderboardPoint[i] as Dictionary <string, object>;
LeaderboardData pointLeaderboardData = new LeaderboardData(rawData);
pointLeaderboardData.leaderboardType = 1;
pointLeaderboardData.totalPoint = JsonUtility.GetLong(rawData, "score");
listLeaderboardDataPoint.Add(pointLeaderboardData);
}
//Load leaderboard timeplay
listLeaderboardDataTime.Clear();
var leaderboardTimeplay = data[TAG_LEADERBOARD_TIMEPLAY] as List <object>;
for (int i = 0; i < leaderboardTimeplay.Count; i++)
{
var rawData = leaderboardTimeplay[i] as Dictionary <string, object>;
LeaderboardData timeplayLeaderboardData = new LeaderboardData(rawData);
timeplayLeaderboardData.leaderboardType = 2;
timeplayLeaderboardData.totalTimePlay = JsonUtility.GetLong(rawData, "playtime");
listLeaderboardDataTime.Add(timeplayLeaderboardData);
}
//Load leaderboard eat / fish kill
listLeaderboardDataEat.Clear();
var leaderboardFishKill = data[TAG_LEADERBOARD_FISHKILL] as List <object>;
for (int i = 0; i < leaderboardFishKill.Count; i++)
{
var rawData = leaderboardFishKill[i] as Dictionary <string, object>;
LeaderboardData eatLeaderboardData = new LeaderboardData(rawData);
eatLeaderboardData.leaderboardType = 3;
eatLeaderboardData.totalEat = JsonUtility.GetLong(rawData, "fish_killed");
listLeaderboardDataEat.Add(eatLeaderboardData);
}
}
public void Awake()
{
GetLeaderboard();
SendLeaderboard();
entryContainer = transform.Find("highscoreEntryContainer");
entryTemplate = EntryContainer.Find("highscoreEntryTemplate");
entryTemplate.gameObject.SetActive(false);
for (int i = 0; i < leaderboarddata.Count; i++)
{
for (int j = i + 1; j < leaderboarddata.Count; j++)
{
if (leaderboarddata[j].high_score > leaderboarddata[i].high_score)
{
//swap
LeaderboardData tmp = leaderboarddata[i];
leaderboarddata[i] = leaderboarddata[j];
leaderboarddata[j] = tmp;
}
}
}
leaderboarddataEntryTransformList = new List <Transform>();
foreach (LeaderboardData leaderboardData in leaderboarddata)
{
CreateHighscoreEntryTransform(leaderboardData, entryContainer, leaderboarddataEntryTransformList);
}
}
private void PlaceScoreInPosition(LeaderboardDataObject leaderboardDataObject)
{
LeaderboardData leaderboardData = leaderboardDataObject.LeaderboardData;
if (leaderboardDataObjects.ContainsKey(leaderboardData.Place))
{
LeaderboardDataObject oldData = SwapData(leaderboardDataObject.LeaderboardData.Place, leaderboardDataObject);
for (int i = leaderboardData.Place + 1; i < leaderboardDataObjects.Count + 1; i++)
{
if (leaderboardDataObjects.ContainsKey(i))
{
oldData = SwapData(i, oldData);
}
else
{
leaderboardDataObjects.Add(i, oldData);
oldData.LeaderboardData = new LeaderboardData(i, oldData.LeaderboardData);
oldData.gameObject.transform.SetSiblingIndex(i);
break;
}
}
}
else
{
leaderboardDataObjects.Add(leaderboardData.Place, leaderboardDataObject);
}
}
private IEnumerator GameOver()
{
isCoR = true;
yield return(new WaitForSecondsRealtime(.1f));
if (Time.timeScale != 0)
{
Time.timeScale = 0;
gm.cwis1Turret.enabled = false;
gm.cwis2Turret.enabled = false;
gm.isGameRunning = false;
for (int i = 0; i < ms.activeMissiles.Count; i++)
{
ms.activeMissiles[i].SetActive(false);
}
//#if UNITY_STANDALONE
LeaderboardData _data = new LeaderboardData();
_data.name = PlayerPrefs.GetString("PlayerName");
_data.score = gm.score;
StartCoroutine(OnlineLeaderboardManager.SendDataOnline(_data));
//#endif
ms.enabled = false;
}
}
IEnumerator GetLeaderboard()
{
string uri = "https://2t6es54bpd.execute-api.us-west-2.amazonaws.com/public";
UnityWebRequest uwr = UnityWebRequest.Get(uri);
yield return(uwr.SendWebRequest());
if (uwr.isNetworkError)
{
Debug.Log("Error While Sending: " + uwr.error);
}
else
{
string json_response = uwr.downloadHandler.text;
Debug.Log("Received: " + json_response);
string jsonBody = GetRequestBody(json_response).Replace("\\", "");
Debug.Log("JSONBODY: " + jsonBody);
LeaderboardData leaders = JsonUtility.FromJson <LeaderboardData>(jsonBody);
Debug.Log("Entries: " + leaders);
for (int i = 0; i < leaders.entries.Length; i++)
{
GameObject newButtonPrefab = Instantiate(ButtonPrefab, new Vector3(0, 0, 0), Quaternion.identity);
newButtonPrefab.transform.parent = gameObject.transform;
newButtonPrefab.transform.GetChild(0).GetComponent <Text>().text = "" + (i + 1) + ". " + leaders.entries[i].name + " - " + leaders.entries[i].score;
}
}
}
void OnLeaderboardComplete(CallbackResponse <LeaderboardData> response)
{
Debug.Log("OnLeaderboardComplete");
if (response.Status == CallbackStatus.Success)
{
LeaderboardData ld = response.Result;
GameObject prefab = Resources.Load("Prefabs/LeaderboardItemPanel") as GameObject;
var canvas = GameObject.Find("Canvas");
var container = canvas.transform.FindChild("LeaderboardContainer");
int row = 0;
int rowSize = 50;
foreach (LeaderboardItem li in ld.Items)
{
Vector2 startPosition = new Vector2(0, 0);
var item = Instantiate(prefab);
var renderer = item.GetComponent <LeaderboardItemRenderer>();
item.transform.SetParent(container.transform);
item.SetActive(true);
var rectTransform = item.GetComponent <RectTransform>();
if (rectTransform)
{
rectTransform.anchorMin = new Vector2(0f, 1f);
rectTransform.anchorMax = rectTransform.anchorMin;
rectTransform.anchoredPosition = new Vector2(startPosition.x, startPosition.y - (row * rowSize));
}
renderer.Initialize(li.Rank.ToString(), li.Gamertag, li.Value);
row++;
}
}
}
// Start is called before the first frame update
void Start()
{
m_PInfo = GameObject.Find("PersistentStorage").GetComponent <PersistentInfo_Script>();
m_LocalUser = m_PInfo.m_UserData;
m_LocalData = SaveGameSystem.LoadGame("LeaderboardData") as LeaderboardData;
if (m_LocalData != null)
{
string top;
if (m_LocalData.FindUser(m_LocalUser) > -1)
{
m_LocalUser = m_LocalData.GetUser(m_LocalUser.m_UserName);
top = m_LocalUser.m_UserName + " " + m_LocalUser.m_Score + " Rank: " + m_LocalUser.m_Rank;
}
else
{
top = "You have not scored yet.";
}
ChangeTopText(top);
PopulateBoard();
}
else
{
string top = "No Leaderboard Available";
ChangeTopText(top);
}
}
public static void LeaderboardRetrieved(LeaderboardData rankData)
{
if (rankData.init)
{
PostGameRankCalculator.gameRank = SessionManager.CalculatePlayerRank(rankData.position);
SessionManager s = SessionManager.SessionInstance;
if (s != null)
{
switch (gameRank)
{
case PlayerRanks.Top100:
SessionManager.currentRank = s.standardRank;
break;
case PlayerRanks.Top50:
SessionManager.currentRank = s.bronzeRank;
break;
case PlayerRanks.Top10:
SessionManager.currentRank = s.silverRank;
break;
case PlayerRanks.Top3:
SessionManager.currentRank = s.goldRank;
break;
}
}
}
}
public static void LoadLeaderboardData(int limit, Action <Task, LeaderboardData> callback)
{
CollectionReference collectionRef = db.Collection(leaderboardId);
Query query = collectionRef.OrderByDescending(UserScoreData.USER_SCORE_PROPERTY_NAME).Limit(limit);
query.GetSnapshotAsync().ContinueWithOnMainThread(task =>
{
if (!task.IsCompleted)
{
return;
}
QuerySnapshot querySnapshot = task.Result;
LeaderboardData leaderboardData = new LeaderboardData();
foreach (DocumentSnapshot docSnapshot in querySnapshot.Documents)
{
UserScoreData userScoreData = docSnapshot.ConvertTo <UserScoreData>();
leaderboardData.scores.Add(userScoreData);
}
callback?.Invoke(task, leaderboardData);
});
}
//Populate UI elements with leaderboard data get from server
public void UpdateLeaderboard(LeaderboardData data)
{
int numCachedItems = leaderboardCachedItems.Count;
List <LeaderboardItemData> items = data.items;
int numItems = items.Count;
//Add new UI object if the cache doesn't have enough
while (numItems > numCachedItems)
{
GameObject newObj = GameObject.Instantiate(leaderboardItemPrefab, leaderboardContentPanel.transform);
leaderboardCachedItems.Add(newObj.GetComponent <NameWithData>());
numCachedItems++;
}
//Remove unused cached UI objects
if (numCachedItems > numItems)
{
for (int i = numItems; i < numCachedItems; ++i)
{
GameObject.Destroy(leaderboardCachedItems[i].gameObject);
}
leaderboardCachedItems.RemoveRange(numItems, numCachedItems - numItems);
}
for (int i = 0; i < numItems; ++i)
{
//Populate the UI object with the data
LeaderboardItemData item = items[i];
leaderboardCachedItems[i].Init(item.name, item.score.ToString());
}
}
public void Init(int level)
{
string fileName = string.Format("leaderboard{0}.dat", level);
dataPath = Path.Combine(Application.persistentDataPath, fileName);
BinaryFormatter formatter = new BinaryFormatter();
if (!System.IO.File.Exists(dataPath))
{
Debug.Log("SaveData not exist, create a new one");
LeaderboardData newData = new LeaderboardData();
newData.list = new List <LeaderboardItem>();
FileStream stream = new FileStream(dataPath, FileMode.Create);
formatter.Serialize(stream, newData);
stream.Close();
data = newData;
}
else
{
Debug.Log("Load data");
FileStream stream = new FileStream(dataPath, FileMode.Open);
data = formatter.Deserialize(stream) as LeaderboardData;
stream.Close();
}
}
private void AddHistoryTimer()
{
if (CurrentTimer <= 0)
{
return;
}
if (data.LeaderboardDatas.Count >= 10)
{
for (int i = 0; i < data.LeaderboardDatas.Count; i++)
{
if (CurrentTimer > data.LeaderboardDatas[i].timer)
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.endtimer = data.endTimer;
leaderboardData.timer = data.minTimer;
leaderboardData.name = data.playerName;
data.LeaderboardDatas.Add(leaderboardData);
break;
}
}
if (data.LeaderboardDatas.Count > 10)
{
data.LeaderboardDatas.RemoveAt(data.LeaderboardDatas.Count - 2);
}
}
else
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.endtimer = data.endTimer;
leaderboardData.timer = data.minTimer;
leaderboardData.name = data.playerName;
data.LeaderboardDatas.Add(leaderboardData);
}
}
private void AddHistoryScore()
{
if (Score <= 0)
{
return;
}
if (data.LeaderboardDatas.Count >= 10)
{
for (int i = 0; i < data.LeaderboardDatas.Count; i++)
{
if (Score > data.LeaderboardDatas[i].score)
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.score = score;
leaderboardData.date = System.DateTime.Now.ToString("yy-MM-dd,h:mm:ss tt");
data.LeaderboardDatas.Add(leaderboardData);
break;
}
}
if (data.LeaderboardDatas.Count > 10)
{
data.LeaderboardDatas.RemoveAt(data.LeaderboardDatas.Count - 2);
}
}
else
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.score = score;
leaderboardData.date = System.DateTime.Now.ToString("yy-MM-dd,h:mm:ss tt");
data.LeaderboardDatas.Add(leaderboardData);
}
}
//Update leaderboard data (not called from main thread)
public void SetLeaderboard_Thread(LeaderboardData data)
{
lock (actionQueueLock)
{
actionQueue.Add(() => SetLeaderboard(data));
}
}
private void AddHistoryScore()
{
if (CurrentScore <= 0)
{
return;
}
if (m_data.LeaderboardDatas.Count >= 10)
{
for (int i = 0; i < m_data.LeaderboardDatas.Count; i++)
{
if (CurrentScore > m_data.LeaderboardDatas[i].currentScore)
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.currentScore = _currentScore;
leaderboardData.nowTime = System.DateTime.Now.ToString("y年m月dd 日 \n h··mm··ss tt");
leaderboardData.numText = _endNumString;
m_data.LeaderboardDatas.Add(leaderboardData);
break;
}
}
if (m_data.LeaderboardDatas.Count > 10)
{
m_data.LeaderboardDatas.RemoveAt(m_data.LeaderboardDatas.Count - 2);
}
}
else
{
LeaderboardData leaderboardData = new LeaderboardData();
leaderboardData.currentScore = _currentScore;
leaderboardData.nowTime = System.DateTime.Now.ToString("y年m月dd 日 \n h··mm··ss tt");
leaderboardData.numText = _endNumString;
m_data.LeaderboardDatas.Add(leaderboardData);
}
}
public void RankRetrieved(LeaderboardData rankData)
{
if (rankData.init)
{
PlayerRanks rank = SessionManager.CalculatePlayerRank(rankData.position);
switch (rank)
{
case PlayerRanks.Top100:
standard.SetActive(true);
break;
case PlayerRanks.Top50:
bronze.SetActive(true);
break;
case PlayerRanks.Top10:
silver.SetActive(true);
break;
case PlayerRanks.Top3:
gold.SetActive(true);
break;
}
}
}
private void ProcessReplyLeaderboard(byte[] data)
{
LeaderboardData leaderboardData = new LeaderboardData();
lock (bufferLock)
{
buffer.Data = data;
buffer.Position = 1;
int numItems = buffer.ReadByte();
for (int i = 0; i < numItems; ++i)
{
int nameLen = buffer.ReadByte();
int bufferOffset = buffer.Position;
string name = Encoding.UTF8.GetString(buffer.Data, bufferOffset, nameLen);
buffer.Skip(nameLen);
int score = (int)buffer.ReadUInt32();
leaderboardData.AddItem(name, score);
}
}
if (game != null)
{
game.SetLeaderboard_Thread(leaderboardData);
}
}
// Use this for initialization
void Start()
{
// get the two panes
gameoverView = (RectTransform)transform.Find("GameoverView");
leaderboardView = (RectTransform)transform.Find("LeaderboardView");
gameoverView.gameObject.SetActive(true);
leaderboardView.gameObject.SetActive(true);
// update text fields
int score = Score.instance.getScore;
gameoverView.transform.Find("YourScore").GetComponent <Text>().text = "You directed " + score.ToString() + " car" + (score == 1 ? "" : "s") + " through your city!";
if (PlayerPrefs.HasKey("Name"))
{
GameObject.Find("InputField").GetComponent <InputField> ().text = PlayerPrefs.GetString("Name");
}
leaderboardView.transform.Find("LeaderboardText").GetComponent <Text>().text = "Loading...";
leaderboardView.transform.Find("YourScore").GetComponent <Text> ().text = "Your score: " + score.ToString();
leaderboardView.gameObject.SetActive(false);
// set focus on the input field
//EventSystem.current.SetSelectedGameObject(GameObject.Find ("InputField"));
// get leaderboard data to get scores from
leaderboardData = GameObject.Find("LeaderboardData").GetComponent <LeaderboardData>();
}
/// <summary>
/// Loads player data
/// </summary>
public void LoadData()
{
//DeleteFile ();
BinaryFormatter bf = new BinaryFormatter();
//Check whether file exists
if (File.Exists(Application.persistentDataPath + filePath))
{
Debug.LogWarning("Loading file");
FileStream file = File.Open(Application.persistentDataPath + filePath, FileMode.Open);
allLeaders = (LeaderboardData)bf.Deserialize(file);
file.Close();
}
else
{
Debug.LogWarning("Created file");
//Create file and parse in faked data
FileStream file = File.Open(Application.persistentDataPath + filePath, FileMode.CreateNew);
LeaderboardData FakeData = new LeaderboardData();
//Loop through moving down players
for (int i = 0; i < 10; i++)
{
LeaderboardData.LeaderBoardPlayer player = new LeaderboardData.LeaderBoardPlayer();
player.PlayerScore = 0;
player.PlayerName = "None";
FakeData.SetLeaderPosition(i, player);
}
allLeaders = FakeData;
bf.Serialize(file, FakeData);
file.Close();
}
}
IEnumerator SocietyGetLeaderboard(int _eventId)
{
var Leaderboard = new List <LeaderboardData> ();
var encoding = new System.Text.UTF8Encoding();
Dictionary <string, string> postHeader = new Dictionary <string, string> ();
var json = new JSONClass();
json ["player_id"] = PlayerPrefs.GetInt("PlayerId").ToString();
json ["event_id"] = _eventId.ToString();
postHeader.Add("Content-Type", "application/json");
postHeader.Add("Content-Length", json.Count.ToString());
print("jsonDtat is ==>> " + json.ToString());
WWW www = new WWW("http://pinekix.ignivastaging.com/societyEvents/getSocietyEventVoteData", encoding.GetBytes(json.ToString()), postHeader);
yield return(www);
if (www.error == null)
{
JSONNode _jsnode = Simple_JSON.JSON.Parse(www.text);
if (_jsnode ["status"].ToString().Contains("200"))
{
for (int i = 0; i < _jsnode ["data"].Count; i++)
{
var data = _jsnode ["data"] [i];
var LB = new LeaderboardData();
int vote_count = 0;
int vote_bonus = 0;
int friend_bonus = 0;
int totalScore = 0;
int.TryParse(data ["vote_count"], out vote_count);
int.TryParse(data ["vote_bonus"], out vote_bonus);
int.TryParse(data ["friend_bonus"], out friend_bonus);
totalScore = (vote_count * 10) + friend_bonus + vote_bonus;
int.TryParse(data ["society_id"], out LB.player_id);
LB.player_name = data ["society_name"];
LB.player_score = totalScore;
Leaderboard.Add(LB);
}
}
else
{
}
Leaderboard.Sort((s2, s1) => s1.player_score.CompareTo(s2.player_score));
ScreenAndPopupCall.Instance.SocietyLeaderBoard();
GenerateLeaderboard(Leaderboard);
}
else
{
}
}
public void OnSocketLeaderboard(SocketIOEvent ev)
{
if (info != null)
{
LeaderboardData data = LeaderboardData.FromJSONObject(ev.data);
info.UpdateLeaderboard(data);
}
}
private void Initialize()
{
if (data == null)
{
data = new LeaderboardData(Database);
data.UpdateData();
}
}
void Awake()
{
if (instance != null)
{
throw new Exception("Only one LeaderboardData instance should exist");
}
instance = this;
}
public void SetResult(LeaderboardData currentMatch)
{
pointsTXT.text = currentMatch.Points.ToString();
var corrects = currentMatch.CorrectQuestions;
var total = currentMatch.TotalQuestions;
var incorrects = total - corrects;
resultQuestionsTXT.text = $"<color=green>{corrects}</color>/<color=red>{incorrects}</color>/{total}";
}