443 lines
14 KiB
C#
443 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using BitStrap;
|
|
using CodeStage.AntiCheat.ObscuredTypes;
|
|
using Steamworks;
|
|
using UnityEngine;
|
|
|
|
public class LeaderboardsManager : MonoBehaviour
|
|
{
|
|
[Serializable]
|
|
public class LeaderboardPlayerStats
|
|
{
|
|
public string fisheryName = string.Empty;
|
|
|
|
public ObscuredInt leaderboardLevel = -1;
|
|
|
|
public ObscuredInt leaderboardExp = -1;
|
|
|
|
public ObscuredInt leaderboardScore = -1;
|
|
|
|
public ObscuredInt leaderboardTotalFishCount = -1;
|
|
|
|
public ObscuredInt leaderboardTotalFishWeight = -1;
|
|
|
|
public ObscuredInt leaderboardBiggestFishSpecies = -1;
|
|
|
|
public ObscuredInt leaderboardBiggestFishWeight = -1;
|
|
|
|
public ObscuredInt leaderboardBiggestFishLength = -1;
|
|
|
|
public ObscuredInt leaderboardMonth = -1;
|
|
|
|
public LeaderboardPlayerStats(string fName)
|
|
{
|
|
fisheryName = fName;
|
|
}
|
|
}
|
|
|
|
public enum LeaderboardType
|
|
{
|
|
Score = 0,
|
|
FishCount = 1,
|
|
FishWeight = 2,
|
|
BiggestWeight = 3,
|
|
COUNT = 4
|
|
}
|
|
|
|
public enum LeaderboardStats
|
|
{
|
|
LEVEL = 0,
|
|
EXP = 1,
|
|
FISH_COUNT = 2,
|
|
FISH_WEIGHT = 3,
|
|
BIGGEST_SPECIES = 4,
|
|
BIGGEST_WEIGHT = 5,
|
|
SCORE = 6,
|
|
COUNT = 7
|
|
}
|
|
|
|
private static LeaderboardsManager instance;
|
|
|
|
public LeaderboardGUI leaderboardGUI;
|
|
|
|
public const string mainLeaderboardName = ".MAIN.";
|
|
|
|
public ObscuredInt isServerMonthOdd = -1;
|
|
|
|
public ObscuredInt currentServerYear = -1;
|
|
|
|
public ObscuredInt currentServerMonth = -1;
|
|
|
|
public List<LeaderboardPlayerStats> allLeaderboardPlayerStats = new List<LeaderboardPlayerStats>();
|
|
|
|
public List<LeaderboardSettings> leaderboardSettings = new List<LeaderboardSettings>();
|
|
|
|
private GlobalSettings globalSettings;
|
|
|
|
protected CallResult<LeaderboardFindResult_t> onTestLeaderboardFindResult_t;
|
|
|
|
[Header("CreateAllLeaderboards")]
|
|
public string createAllName = ".MAIN.";
|
|
|
|
public int createAllYear = 2018;
|
|
|
|
public int createAllMonth = 1;
|
|
|
|
public static LeaderboardsManager Instance
|
|
{
|
|
get
|
|
{
|
|
return instance;
|
|
}
|
|
}
|
|
|
|
private LeaderboardsManager()
|
|
{
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (instance == null)
|
|
{
|
|
instance = this;
|
|
UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
|
|
}
|
|
else
|
|
{
|
|
UnityEngine.Object.Destroy(base.gameObject);
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
globalSettings = GlobalSettings.Instance;
|
|
if (!SteamManager.Initialized)
|
|
{
|
|
return;
|
|
}
|
|
DLCManager.Instance.ListAllDLCSettings();
|
|
CreateLeaderboardPlayerStats(".MAIN.");
|
|
for (int i = 0; i < globalSettings.levelsManager.fisheryDefinitions.Count; i++)
|
|
{
|
|
if (globalSettings.levelsManager.fisheryDefinitions[i].leaderboardName != string.Empty && globalSettings.levelsManager.fisheryDefinitions[i].leaderboardName != "TODO")
|
|
{
|
|
CreateLeaderboardPlayerStats(globalSettings.levelsManager.fisheryDefinitions[i].leaderboardName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
}
|
|
|
|
public void CreateLeaderboardPlayerStats(string fisheryName)
|
|
{
|
|
allLeaderboardPlayerStats.Add(new LeaderboardPlayerStats(fisheryName + "_N"));
|
|
allLeaderboardPlayerStats.Add(new LeaderboardPlayerStats(fisheryName + "_R"));
|
|
}
|
|
|
|
public LeaderboardPlayerStats GetCurrentLeaderboardPlayerStats(string fisheryName)
|
|
{
|
|
fisheryName = ((GlobalSettings.Instance.playerSettings.difficulty != PlayerSettingsMy.Difficulty.CASUAL) ? (fisheryName + "_R") : (fisheryName + "_N"));
|
|
for (int i = 0; i < allLeaderboardPlayerStats.Count; i++)
|
|
{
|
|
if (allLeaderboardPlayerStats[i].fisheryName == fisheryName)
|
|
{
|
|
return allLeaderboardPlayerStats[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public LeaderboardSettings GetCurrentLeaderboardSettings(LeaderboardType leaderboardType, string fisheryName)
|
|
{
|
|
DateTime currentDateTime = Utilities.GetCurrentDateTime();
|
|
currentServerMonth = currentDateTime.Month;
|
|
currentServerYear = currentDateTime.Year;
|
|
string leaderboardName = string.Format("{0}.{1}_{2}_{3}_{4}", currentServerYear.ToString(), currentServerMonth.ToString("D2"), fisheryName, (!globalSettings.playerSettings.IsCasual()) ? "R" : "N", leaderboardType.ToString());
|
|
LeaderboardSettings leaderboardSettings = GetLeaderboardSettings(leaderboardName);
|
|
if (leaderboardSettings == null)
|
|
{
|
|
leaderboardSettings = new LeaderboardSettings(leaderboardName);
|
|
leaderboardSettings.leaderboardType = leaderboardType;
|
|
leaderboardSettings.fisheryName = fisheryName;
|
|
leaderboardSettings.objectsToInform.Add(base.gameObject);
|
|
this.leaderboardSettings.Add(leaderboardSettings);
|
|
}
|
|
return leaderboardSettings;
|
|
}
|
|
|
|
public LeaderboardSettings GetLeaderboardSettings(string leaderboardName)
|
|
{
|
|
for (int i = 0; i < leaderboardSettings.Count; i++)
|
|
{
|
|
if (leaderboardSettings[i].leaderboardName == leaderboardName)
|
|
{
|
|
return leaderboardSettings[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void FindTestLeaderboardSteam(string testLeaderboardName, CallResult<LeaderboardFindResult_t> onTestLeaderboardFindResult)
|
|
{
|
|
if (SteamManager.Initialized)
|
|
{
|
|
onTestLeaderboardFindResult = CallResult<LeaderboardFindResult_t>.Create(OnFindTestLeaderboardSteam);
|
|
onTestLeaderboardFindResult.Set(SteamUserStats.FindLeaderboard(testLeaderboardName));
|
|
}
|
|
}
|
|
|
|
private void OnFindTestLeaderboardSteam(LeaderboardFindResult_t value, bool ioFailure)
|
|
{
|
|
if (!GlobalSettings.Instance.IsMyProfileCracked())
|
|
{
|
|
Debug.LogError("STEAMWORKS OnFindTestLeaderboardSteam: " + value.m_hSteamLeaderboard.ToString() + " " + value.m_hSteamLeaderboard.m_SteamLeaderboard + " " + value.m_bLeaderboardFound + " " + ioFailure);
|
|
SteamManager.hasProblemWithLeaderboards = value.m_bLeaderboardFound == 0;
|
|
if (value.m_bLeaderboardFound > 0)
|
|
{
|
|
int[] pScoreDetails = new int[1];
|
|
int nScore = 0;
|
|
SteamAPICall_t steamAPICall_t = SteamUserStats.UploadLeaderboardScore(value.m_hSteamLeaderboard, ELeaderboardUploadScoreMethod.k_ELeaderboardUploadScoreMethodForceUpdate, nScore, pScoreDetails, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void FindAllLeaderboards()
|
|
{
|
|
if (!SteamManager.Initialized)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
FindLeaderboard((LeaderboardType)i, ".MAIN.");
|
|
}
|
|
for (int j = 0; j < globalSettings.levelsManager.fisheryDefinitions.Count; j++)
|
|
{
|
|
LevelsManager.FisheryDefinition fisheryDefinition = globalSettings.levelsManager.fisheryDefinitions[j];
|
|
if (fisheryDefinition.leaderboardName != string.Empty && fisheryDefinition.leaderboardName != "TODO")
|
|
{
|
|
for (int k = 0; k < 4; k++)
|
|
{
|
|
FindLeaderboard((LeaderboardType)k, fisheryDefinition.leaderboardName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void FindLeaderboard(LeaderboardType leaderboardType, string fisheryName)
|
|
{
|
|
if (!globalSettings.playerSettings.IsSandbox())
|
|
{
|
|
LeaderboardSettings currentLeaderboardSettings = GetCurrentLeaderboardSettings(leaderboardType, fisheryName);
|
|
if (currentLeaderboardSettings != null)
|
|
{
|
|
currentLeaderboardSettings.FindLeaderboard(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void OnFindLeaderboard(LeaderboardSettings lbSettings)
|
|
{
|
|
if (lbSettings.findResult_t.m_bLeaderboardFound != 0)
|
|
{
|
|
LeaderboardPlayerStats currentLeaderboardPlayerStats = GetCurrentLeaderboardPlayerStats(lbSettings.fisheryName);
|
|
if ((int)currentLeaderboardPlayerStats.leaderboardMonth != -1 && (int)currentLeaderboardPlayerStats.leaderboardMonth != (int)currentServerMonth)
|
|
{
|
|
Debug.LogError(string.Concat("leaderboardPlayerStats.leaderboardMonth != currentServerMonth ", currentLeaderboardPlayerStats.leaderboardMonth, " ", currentServerMonth));
|
|
ClearPlayerStats(currentLeaderboardPlayerStats);
|
|
}
|
|
if ((int)currentLeaderboardPlayerStats.leaderboardScore == -1)
|
|
{
|
|
GetCurrentLeaderboardSettings(LeaderboardType.Score, lbSettings.fisheryName).DownloadMyScore();
|
|
}
|
|
else if ((bool)leaderboardGUI && leaderboardGUI.isVisible)
|
|
{
|
|
UploadScore(leaderboardGUI.currentLeaderboardType, leaderboardGUI.currentLeaderboardFishery);
|
|
SteamStatsManager.Instance.StoreStats();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool DownloadScores(LeaderboardType leaderboardType, string fisheryName)
|
|
{
|
|
if (globalSettings.playerSettings.IsSandbox())
|
|
{
|
|
return false;
|
|
}
|
|
LeaderboardSettings currentLeaderboardSettings = GetCurrentLeaderboardSettings(leaderboardType, fisheryName);
|
|
if (!SteamManager.Initialized || currentLeaderboardSettings == null)
|
|
{
|
|
return false;
|
|
}
|
|
currentLeaderboardSettings.DownloadScores();
|
|
return true;
|
|
}
|
|
|
|
public void OnDownloadScores(LeaderboardSettings lbSettings)
|
|
{
|
|
Debug.Log("STEAMWORKS OnDownloadScores: " + lbSettings.scoresDownloaded_t.m_cEntryCount);
|
|
if ((bool)leaderboardGUI && leaderboardGUI.isVisible)
|
|
{
|
|
leaderboardGUI.Refresh(lbSettings);
|
|
}
|
|
}
|
|
|
|
public void OnDownloadMyScore(LeaderboardSettings lbSettings)
|
|
{
|
|
LeaderboardPlayerStats currentLeaderboardPlayerStats = GetCurrentLeaderboardPlayerStats(lbSettings.fisheryName);
|
|
if ((int)currentLeaderboardPlayerStats.leaderboardScore == -1)
|
|
{
|
|
if (lbSettings.myScoresDownloaded_t.m_cEntryCount == 0)
|
|
{
|
|
ClearPlayerStats(currentLeaderboardPlayerStats);
|
|
return;
|
|
}
|
|
int[] leaderboardMyDetails = GetCurrentLeaderboardSettings(LeaderboardType.Score, lbSettings.fisheryName).leaderboardMyDetails;
|
|
currentLeaderboardPlayerStats.leaderboardLevel = leaderboardMyDetails[0];
|
|
currentLeaderboardPlayerStats.leaderboardExp = leaderboardMyDetails[1];
|
|
currentLeaderboardPlayerStats.leaderboardTotalFishCount = leaderboardMyDetails[2];
|
|
currentLeaderboardPlayerStats.leaderboardTotalFishWeight = leaderboardMyDetails[3];
|
|
currentLeaderboardPlayerStats.leaderboardBiggestFishSpecies = leaderboardMyDetails[4];
|
|
currentLeaderboardPlayerStats.leaderboardBiggestFishWeight = leaderboardMyDetails[5];
|
|
currentLeaderboardPlayerStats.leaderboardBiggestFishLength = 0;
|
|
currentLeaderboardPlayerStats.leaderboardScore = leaderboardMyDetails[6];
|
|
currentLeaderboardPlayerStats.leaderboardMonth = currentServerMonth;
|
|
}
|
|
}
|
|
|
|
public void UploadAllScores(string fisheryName)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
UploadScore((LeaderboardType)i, fisheryName);
|
|
}
|
|
}
|
|
|
|
public bool UploadScore(LeaderboardType leaderboardType, string fisheryName, int score = -1)
|
|
{
|
|
if (globalSettings == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (globalSettings.playerSettings.IsSandbox())
|
|
{
|
|
return false;
|
|
}
|
|
LeaderboardSettings currentLeaderboardSettings = GetCurrentLeaderboardSettings(leaderboardType, fisheryName);
|
|
LeaderboardPlayerStats currentLeaderboardPlayerStats = GetCurrentLeaderboardPlayerStats(fisheryName);
|
|
if (currentLeaderboardPlayerStats == null)
|
|
{
|
|
Debug.LogError("leaderboardPlayerStats == null " + currentLeaderboardSettings.leaderboardName);
|
|
return false;
|
|
}
|
|
if ((int)currentLeaderboardPlayerStats.leaderboardScore < 0 || (int)currentLeaderboardPlayerStats.leaderboardTotalFishCount < 0 || (int)currentLeaderboardPlayerStats.leaderboardTotalFishWeight < 0)
|
|
{
|
|
Debug.LogError("UploadScore score not loaded yet " + currentLeaderboardSettings.leaderboardName);
|
|
}
|
|
if (currentLeaderboardSettings.leaderboardHandle.m_SteamLeaderboard == 0)
|
|
{
|
|
FindLeaderboard(leaderboardType, fisheryName);
|
|
return false;
|
|
}
|
|
if (GlobalSettings.Instance.IsMyProfileCracked())
|
|
{
|
|
return false;
|
|
}
|
|
int[] array = new int[7]
|
|
{
|
|
Mathf.Max(globalSettings.playerSettings.playersLevel, currentLeaderboardPlayerStats.leaderboardLevel),
|
|
Mathf.Max(globalSettings.playerSettings.playersExperience, currentLeaderboardPlayerStats.leaderboardExp),
|
|
currentLeaderboardPlayerStats.leaderboardTotalFishCount,
|
|
currentLeaderboardPlayerStats.leaderboardTotalFishWeight,
|
|
currentLeaderboardPlayerStats.leaderboardBiggestFishSpecies,
|
|
currentLeaderboardPlayerStats.leaderboardBiggestFishWeight,
|
|
currentLeaderboardPlayerStats.leaderboardScore
|
|
};
|
|
if (!globalSettings.playerSettings.CheckMyStatsIntegrity())
|
|
{
|
|
Debug.LogError("Fake leaderboard");
|
|
score = 0;
|
|
}
|
|
else if (score == -1)
|
|
{
|
|
switch (leaderboardType)
|
|
{
|
|
case LeaderboardType.FishCount:
|
|
score = array[2];
|
|
break;
|
|
case LeaderboardType.FishWeight:
|
|
score = array[3];
|
|
break;
|
|
case LeaderboardType.BiggestWeight:
|
|
score = array[5];
|
|
break;
|
|
case LeaderboardType.Score:
|
|
score = array[6];
|
|
break;
|
|
}
|
|
}
|
|
currentLeaderboardSettings.UploadScore(score, array);
|
|
return true;
|
|
}
|
|
|
|
public void OnUploadScore(LeaderboardSettings lbSettings)
|
|
{
|
|
Debug.Log("STEAMWORKS OnUploadScore: " + lbSettings.scoresUploaded_t.m_bScoreChanged + " " + lbSettings.scoresUploaded_t.m_nScore);
|
|
if ((bool)leaderboardGUI && leaderboardGUI.isVisible)
|
|
{
|
|
DownloadScores(leaderboardGUI.currentLeaderboardType, leaderboardGUI.currentLeaderboardFishery);
|
|
}
|
|
}
|
|
|
|
[Button]
|
|
public void CreateAllLeaderboards()
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
object[] obj = new object[5]
|
|
{
|
|
createAllYear.ToString(),
|
|
createAllMonth.ToString("D2"),
|
|
createAllName,
|
|
(i != 0) ? "R" : "N",
|
|
null
|
|
};
|
|
LeaderboardType leaderboardType = (LeaderboardType)j;
|
|
obj[4] = leaderboardType.ToString();
|
|
string pchLeaderboardName = string.Format("{0}.{1}_{2}_{3}_{4}", obj);
|
|
SteamAPICall_t steamAPICall_t = SteamUserStats.FindOrCreateLeaderboard(pchLeaderboardName, ELeaderboardSortMethod.k_ELeaderboardSortMethodDescending, ELeaderboardDisplayType.k_ELeaderboardDisplayTypeNumeric);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ClearPlayerStats(LeaderboardPlayerStats leaderboardPlayerStats)
|
|
{
|
|
leaderboardPlayerStats.leaderboardLevel = globalSettings.playerSettings.playersLevel;
|
|
leaderboardPlayerStats.leaderboardExp = globalSettings.playerSettings.playersExperience;
|
|
leaderboardPlayerStats.leaderboardTotalFishCount = 0;
|
|
leaderboardPlayerStats.leaderboardTotalFishWeight = 0;
|
|
leaderboardPlayerStats.leaderboardBiggestFishSpecies = -1;
|
|
leaderboardPlayerStats.leaderboardBiggestFishWeight = -1;
|
|
leaderboardPlayerStats.leaderboardBiggestFishLength = -1;
|
|
leaderboardPlayerStats.leaderboardScore = 0;
|
|
leaderboardPlayerStats.leaderboardMonth = currentServerMonth;
|
|
}
|
|
|
|
public LeaderboardSettings FindLeaderboardSettings(string leaderboardName)
|
|
{
|
|
for (int i = 0; i < leaderboardSettings.Count; i++)
|
|
{
|
|
if (leaderboardSettings[i].leaderboardName == leaderboardName)
|
|
{
|
|
return leaderboardSettings[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|