public static string GetLevelDescription(string levelName)
{
string output = "";
// Fetch data pertaining to the level itself
LevelData levelInfo = GetLevel(levelName);
// Fetch player save data relating to the level
LevelRecord savedLevelData = SaveService.loadedSave.levels[Globals.AUTOPLAY_LIST.IndexOf(levelName)];
output += levelInfo.levelId + " " + levelInfo.levelName + "\n";
if (levelInfo.isPlayable)
{
if (savedLevelData.bestTime == -1)
{
output += "\nUNCLEARED\n\n\n\n";
}
else
{
output += "\nCLEARED\n\n";
output += "Clear Time: " + savedLevelData.bestTime + "\n";
output += "Damage Taken: " + savedLevelData.healthLost + "\n";
output += "Money Collected: " + savedLevelData.loot + "\n\n";
}
}
else
{
output += "\nCUTSCENE\n\n\n";
}
return(output);
}
public NormalDiamondGameModeLogic(GameHandlerScript gameMaster)
{
this.gameMaster = (DiamondMasterScript)gameMaster;
this.level = gameMaster.getCurrentLevelRecord();
gameMaster.setGameTimeLeft(level.timeToSecondReward);
}
public static GameModeLogic createGameModeLogic(GameHandlerScript gameMaster, LevelRecord level)
{
GameModeLogic newGameModeLogic;
switch (level.getLevelType())
{
case LevelRecord.LevelType.NORMAL:
newGameModeLogic = new NormalDiamondGameModeLogic(gameMaster);
break;
case LevelRecord.LevelType.STRESS:
newGameModeLogic = new NormalDiamondGameModeLogic(gameMaster);
break;
case LevelRecord.LevelType.BOSS:
newGameModeLogic = new NormalDiamondGameModeLogic(gameMaster);
break;
case LevelRecord.LevelType.STRESSBOSS:
newGameModeLogic = new NormalDiamondGameModeLogic(gameMaster);
break;
default:
newGameModeLogic = new NormalDiamondGameModeLogic(gameMaster);
break;
}
return newGameModeLogic;
}
// zapisuje dane o "przejsciu" levelu tylko jeżeli obecne przejście jest "lepsze" od poprzedniego
public void SaveLevelsData(LevelInfo level, LevelRecord levelRecord)
{
string key = level.levelID.GetLevelID();
LevelRecord oldRecord = null;
if (PlayerPrefs.HasKey(key))
{
string levelData = PlayerPrefs.GetString(key);
LevelRecord lr = JsonUtility.FromJson <LevelRecord>(levelData);
if (lr != null)
{
oldRecord = lr;
}
}
if (oldRecord != null)
{
if (oldRecord.shootsUsed < levelRecord.shootsUsed)
{
string jsonData = JsonUtility.ToJson(levelRecord);
PlayerPrefs.SetString(key, jsonData);
PlayerPrefs.Save();
}
}
else
{
string jsonData = JsonUtility.ToJson(levelRecord);
PlayerPrefs.SetString(key, jsonData);
PlayerPrefs.Save();
}
}
public void ActivateUI()
{
LevelRecord levelRecord = GameManager.instance.levelRecord;
if (GameManager.instance.levelRecord != null)
{
if (levelRecord.ironCollected != 0 || levelRecord.silverCollected != 0 || levelRecord.goldCollected != 0)
{
CalculateResources();
hangarUi.SetEndLevelText();
SellResources();
}
else
{
GameManager.instance.levelRecord = null;
SetToNavigation();
}
}
else
{
SetToNavigation();
}
PlayerProfile profile = ProfileManager.instance.currentProfile;
if (profile.isDead)
{
profile.isDead = false;
profile.balance -= GameManager.instance.CalcDeathCost();
EventManager.TriggerEvent("ReturnedFromDeath");
ProfileManager.instance.SaveProfile();
}
}
void setupLevelRewardIcons(LevelRecord level)
{
if (level.collectedRewards >= 1)
{
reward1Icon.color = Color.white;
}
else
{
reward1Icon.color = Color.black;
}
if (level.collectedRewards >= 2)
{
reward2Icon.color = Color.white;
}
else
{
reward2Icon.color = Color.black;
}
if (level.collectedRewards >= 3)
{
reward3Icon.color = Color.white;
}
else
{
reward3Icon.color = Color.black;
}
if (level.getRequiredRewards() > GameServiceLayer.serviceLayer.itemService.getRewardCount())
{
lockObject.SetActive(true);
lockLabel.text = level.getRequiredRewards().ToString();
nextUIButton.isEnabled = false;
nextButtonLabel.gameObject.SetActive(false);
}
}
public StressDiamondGameModeLogic(GameHandlerScript gameMaster)
{
this.gameMaster = (DiamondMasterScript) gameMaster;
this.level = gameMaster.getCurrentLevelRecord();
this.gameMaster.CollectedDiamondCountChanged += onDiamondCollected;
}
public void CopyFrom(Level other)
{
Type = other.Type;
IsLocal = other.IsLocal;
OnlineLevel = other.OnlineLevel;
Meta = other.Meta;
Record = other.Record;
Path = other.Path;
}
public static void OnGetLocalUserData(GetUserDataResult Result)
{
MaxLevelReached = Result.TryGetInUserDatas(MaxLevelReachedIdentifier, MaxLevelReached);
for (int LevelId = 1; LevelId <= MaxLevelReached; ++LevelId)
{
LevelRecord Record = GetRecord(LevelId);
Record.OnGetLocalUserData(Result);
}
}
public static void OnGetLocalPlayerStatistics(GetPlayerStatisticsResult Result)
{
AllTimesTotalScore = Result.TryGetInStatistics(AllTimesTotalScoreIdentifier, AllTimesTotalScore);
BiggestScore = Result.TryGetInStatistics(BiggestScoreIdentifier, BiggestScore);
for (int LevelId = 1; LevelId <= MaxLevelReached; ++LevelId)
{
LevelRecord Record = GetRecord(LevelId);
Record.OnGetLocalPlayerStatistics(Result);
}
}
static private LevelRecord GetRecord(int LevelId)
{
LevelRecord record = AllLevelRecords.Find(T => T.Id == LevelId);
if (record == null)
{
record = new LevelRecord(LevelId);
AllLevelRecords.Add(record);
}
return(record);
}
public void SetEndLevelText()
{
LevelRecord record = GameManager.instance.levelRecord;
if (record.ironCollected > 0)
{
string bonusText = string.Empty;
if (record.ironBonusValue > 0f)
{
bonusText = $" (+ {record.ironBonusValue} bonus)";
}
ironText.text = $"Iron: {record.ironCollected} collected - ${record.ironTotalValue}{bonusText}";
ironText.enabled = true;
}
else
{
ironText.enabled = false;
}
if (record.silverCollected > 0)
{
string bonusText = string.Empty;
if (record.silverBonusValue > 0f)
{
bonusText = $" (+ {record.silverBonusValue} bonus)";
}
silverText.text = $"Silver: {record.silverCollected} - ${record.silverTotalValue}{bonusText}";
silverText.enabled = true;
}
else
{
silverText.enabled = false;
}
if (record.goldCollected > 0)
{
string bonusText = string.Empty;
if (record.goldBonusValue > 0f)
{
bonusText = $" (+ {record.goldBonusValue} bonus)";
}
goldText.text = $"Gold: {record.goldCollected} - ${record.goldTotalValue}{bonusText}";
goldText.enabled = true;
}
else
{
goldText.enabled = false;
}
SetScreen("EndLevelScreen");
}
private void SellResources()
{
Debug.Log("Sell Resources called");
LevelRecord record = GameManager.instance.levelRecord;
float total = record.ironTotalValue + record.silverTotalValue + record.goldTotalValue;
ProfileManager.instance.currentProfile.balance += total;
ProfileManager.instance.SaveProfile();
GameManager.instance.levelRecord = null;
EventManager.TriggerEvent("UpdateBalance");
}
public static int GetScore(int LevelId)
{
if (LevelId <= MaxLevelReached)
{
LevelRecord Record = AllLevelRecords.Find(T => T.Id == LevelId);
if (Record != null)
{
return(Record.Score);
}
}
return(0);
}
public LevelRecord getLevelRecordForScene(int sceneIndex)
{
LevelRecord level;
int sceneListIndex = sceneIndex - levelListOffset;
if (sceneIndex > 0 && sceneListIndex < levelList.Count ()) {
level = levelList [sceneListIndex];
} else {
level = new LevelRecord ();
}
return level;
}
public void setLevelResult(LevelRecord currentLevel, int collectedRewards, float elapsedTime)
{
if (collectedRewards > currentLevel.collectedRewards) {
addNewRewardsToStorage (currentLevel, collectedRewards);
currentLevel.collectedRewards = collectedRewards;
}
if (elapsedTime < currentLevel.bestTime || currentLevel.bestTime == 0) {
currentLevel.bestTime = elapsedTime;
}
levelStorage.saveLevelList (levelList);
}
private void CalculateResources()
{
LevelRecord record = GameManager.instance.levelRecord;
float profitMultiplier = hangarUi.stats.currentProfitBoost;
record.ironTotalValue = record.ironCollected * resources.ironValue * profitMultiplier;
record.silverTotalValue = record.silverCollected * resources.silverValue * profitMultiplier;
record.goldTotalValue = record.goldCollected * resources.goldValue * profitMultiplier;
record.ironBonusValue = record.ironTotalValue - (record.ironCollected * resources.ironValue);
record.silverBonusValue = record.silverTotalValue - (record.silverCollected * resources.silverValue);
record.goldBonusValue = record.goldTotalValue - (record.goldCollected * resources.goldValue);
}
/// <summary>
/// Constructor.
/// </summary>
public LevelCompleteMenuScreen(LevelRecord levelRecord, string levelName, string gunName,
ShooterGameType gameType, float targetScoreOrTime)
: base("Level Complete")
{
string doneMenuEntryText = "Done";
this.levelName = levelName;
this.gunName = gunName;
this.levelRecord = levelRecord;
this.gameType = gameType;
this.targetScoreOrTime = targetScoreOrTime;
levelComplete = true;
if (gameType != ShooterGameType.ScoreAttack)
{
MenuTitle = "Challenge Complete";
}
// Check if level was completed
if ((gameType == ShooterGameType.TargetScore && levelRecord.Score < (int)targetScoreOrTime) ||
(gameType == ShooterGameType.TimeTrial && levelRecord.Time > targetScoreOrTime) ||
(gameType == ShooterGameType.BullseyeChallenge && levelRecord.NumBullseyes != levelRecord.NumTargetsShot +
levelRecord.NumKnockdowns) ||
(gameType == ShooterGameType.HeadshotChallenge && levelRecord.NumHeadshots != levelRecord.NumTargetsShot +
levelRecord.NumKnockdowns))
{
levelComplete = false;
MenuTitle = "Challenge Failed";
doneMenuEntryText = "Quit";
}
if (levelComplete)
{
// Update player record
oldLevelRecord = ActivePlayer.Profile.GetLevelRecord(levelName);
newRecord = ActivePlayer.Profile.UpdateLevelRecord(levelName, levelRecord);
}
// Create our menu entries
MenuEntry restartGameMenuEntry = new MenuEntry("Restart");
MenuEntry doneGameMenuEntry = new MenuEntry(doneMenuEntryText);
// Hook up menu event handlers.
restartGameMenuEntry.Selected += RestartLevelMenuEntrySelected;
doneGameMenuEntry.Selected += OnCancel;
// Add entries to the menu.
MenuEntries.Add(doneGameMenuEntry);
MenuEntries.Add(restartGameMenuEntry);
}
// If original method increased or decreased skill level, add it to queue for level event notifications.
static void Postfix(int __state, int ___levelInt, Pawn ___pawn, SkillRecord __instance)
{
if (__state == ___levelInt)
{
return;
}
if (___pawn.Faction == null)
{
return;
}
if (!___pawn.Faction.IsPlayer)
{
return;
}
// Ignores level downs 10 -> 9. Fix for some pawns immediately leveling down again after lvl 10.
if (__state == 10 && ___levelInt == 9)
{
if (Settings.ignoreLvl10To9)
{
return;
}
}
if (!TimerAllowsNotifications(___pawn))
{
return;
}
if (!LevelRecord.ContainsKey(___pawn))
{
LevelRecord.Add(___pawn, new Dictionary <SkillDef, int>());
}
if (!LevelRecord[___pawn].ContainsKey(__instance.def))
{
LevelRecord[___pawn].Add(__instance.def, ___levelInt);
}
else if (LevelRecord[___pawn][__instance.def] == ___levelInt)
{
return;
}
LevelRecord[___pawn][__instance.def] = ___levelInt;
LevelEventType levelEventType = __state < ___levelInt ? LevelEventType.LevelUp : LevelEventType.LevelDown;
LevelEventQueue.Enqueue(new LevelEvent(___pawn, __instance, levelEventType));
}
private void Load_LocalStorage()
{
MaxLevelReached = PlayerPrefsHelpers.TryGet(MaxLevelReachedIdentifier, MaxLevelReached);
AllTimesTotalScore = PlayerPrefsHelpers.TryGet(AllTimesTotalScoreIdentifier, AllTimesTotalScore);
BiggestScore = PlayerPrefsHelpers.TryGet(BiggestScoreIdentifier, BiggestScore);
TutorialVu = PlayerPrefsHelpers.TryGet(TutorialVuIdentifier, TutorialVu);
for (int Level = 1; Level <= MaxLevelReached; ++Level)
{
LevelRecord Record = new LevelRecord(Level);
Record.Load_LocalStorage();
AllLevelRecords.Add(Record);
}
}
public override void saveLevelList(List<LevelRecord> levels)
{
levelList = new List<LevelRecord>();
foreach (var level in levels)
{
LevelRecord newLevelRecord = new LevelRecord(level.getLevelIndex(), level.levelName, level.levelGroup,
level.timeToFirstReward,level.timeToSecondReward, level.isMultiplayer);
newLevelRecord.bestTime = level.bestTime;
newLevelRecord.collectedRewards = level.collectedRewards;
newLevelRecord.isLevelCompleted = level.isLevelCompleted;
levelList.Add(newLevelRecord);
}
}
private void Awake()
{
#region Singleton
if (s_Instance != null)
{
Destroy(gameObject);
return;
}
s_Instance = this;
#endregion
startWait = new WaitForSeconds(startDelay);
endWait = new WaitForSeconds(endDelay);
records = new LevelRecord();
}
// Use this for initialization
protected virtual void Start()
{
levelRecord = GameServiceLayer.serviceLayer.levelService.getLevelRecordForScene(Application.loadedLevel);
playerSpawnerList = playerSpawnerList = GameServiceLayer.serviceLayer.playerSpawnerList;
GameServiceLayer.serviceLayer.setCurrentGameMaster(this);
setGameState(GameState.PREGAME);
Screen.sleepTimeout = SleepTimeout.NeverSleep;
Time.timeScale = 1;
gameModeLogic = createGameModeLogic();
gameModeLogic.initGame();
}
public void setupLevelItem(GameObject parent, LevelRecord level, GameObject currentWindow)
{
levelRecord = level;
levelName.text = level.levelName;
levelInfo.text = "Best time: " + level.bestTime.ToString("0.00");
levelInfo.text += "\nExplosives: " + level.collectedRewards + "/3";
levelInfo.text += "\nRequirement: " + level.getRequiredRewards();
dragPanelContents.draggablePanel = parent.transform.parent.GetComponent<UIDraggablePanel>();
setupLevelRewardIcons(level);
createLevelButton(level, currentWindow);
GameServiceLayer.serviceLayer.itemService.ItemCountChanged += refreshLevelIcons;
}
public static void SetLevelRecord(this LiteDatabase db, LevelRecord record, bool overwrite = false)
{
var col = db.GetCollection <LevelRecord>("level_records");
if (overwrite)
{
col.FindOne(it => it.LevelId == record.LevelId)?.Let(it => col.Delete(it.Id));
}
lock (SetLevelRecordLock)
{
if (!col.Update(record))
{
col.Insert(record);
}
}
}
private void UpdateDataFromPlayerPrefs()
{
foreach (LevelInfo level in levels)
{
string key = level.levelID.GetLevelID();
if (PlayerPrefs.HasKey(key))
{
string levelData = PlayerPrefs.GetString(key);
LevelRecord lr = JsonUtility.FromJson <LevelRecord>(levelData);
if (lr != null)
{
level.levelRecord = lr;
}
}
}
}
public static void RecordCurrentGame()
{
int LevelId = Level.CurrentLevel.Id;
LevelRecord Record = GetRecord(LevelId);
Record.Record(Partie.Stars, Partie.Score);
MaxLevelReached = Mathf.Max(MaxLevelReached, LevelId);
AllTimesTotalScore += Partie.Score;
BiggestScore = Mathf.Max(Partie.Score, BiggestScore);
// Saving
Record.Save_LocalStorage();
Save_LocalStorage();
}
public void initLevelDataCollector()
{
if (GameServiceLayer.serviceLayer.gameMaster != null)
{
if (GameServiceLayer.serviceLayer.gameMaster.GetType() == typeof(DiamondMasterScript))
{
DiamondMasterScript diamondMaster = (DiamondMasterScript)GameServiceLayer.serviceLayer.gameMaster;
diamondMaster.CollectedDiamondCountChanged += onCollectedDiamondCountChanged;
}
GameServiceLayer.serviceLayer.gameMaster.LevelFailed += onLevelFailed;
GameServiceLayer.serviceLayer.gameMaster.LevelPassed += onLevelPassed;
gameTime = GameServiceLayer.serviceLayer.gameMaster.getElapsedTime();
currentLevel = GameServiceLayer.serviceLayer.gameMaster.getCurrentLevelRecord();
diamondCollectionTimes.Clear();
uploadStarted = false;
}
}
private IEnumerator EndLevelProcces(float delayTime, bool succes)
{
float timer = 0f;
while (timer < delayTime)
{
timer += Time.deltaTime;
yield return(null);
}
if (succes)
{
string title = DataBase.DB.GetShout_Succes(DataBase.ShoutType.WinTitle);
string content = DataBase.DB.GetShout_Succes(DataBase.ShoutType.WinContent);
LevelInfo currentLEvel = DataBase.DB.GetCurrentLevel();
if (currentLEvel != null)
{
LevelRecord lr = new LevelRecord(true, GetShootsCount(), System.DateTime.UtcNow.ToShortDateString());
DataBase.DB.SaveLevelsData(currentLEvel, lr);
}
if (DataBase.DB.IsCurrentLevelLastOne() == false)
{
levelHud.simplePrompter.DisplayPrompter(title, content, () => DataBase.DB.LoadNextLevel(), "Next level", () => DataBase.DB.LoadMainMenu(), "Back to menu");
}
else
{
title = "Requiescat in pace";
content = $"Hope you liked it :) \n Best regards : Tomek \"UglyRyjek\" Lipinski";
levelHud.simplePrompter.DisplayPrompter(title, content, () => DataBase.DB.LoadMainMenu(), "Back to menu");
}
}
else
{
string title = DataBase.DB.GetShout_Succes(DataBase.ShoutType.FailTitle);
string content = DataBase.DB.GetShout_Succes(DataBase.ShoutType.FailContent);
levelHud.simplePrompter.DisplayPrompter(title, content, () => DataBase.DB.ReloadLevel(), "Try again", () => DataBase.DB.LoadMainMenu(), "Back to menu");
}
yield return(null);
}
private void _setLevel(int levelId)
{
if (this.curLevelObj != null)
{
Destroy(this.curLevelObj);
}
GameObject.Find("LevelComplete").GetComponent <SpriteRenderer>().enabled = false;
FindObjectOfType <Timer>().ResetTime();
this.curLevel = levels.Find(x => x.id == levelId);
this.levelText.text = this.curLevel.id.ToString();
Debug.Log($"Current level: id: {curLevel.id}, {curLevel.MaxInk}");
this.curLevelObj = Instantiate(curLevel.LevelPrefab, GameObject.Find("LevelZaddy").transform);
this.curLevelObj.transform.Find("Character").GetComponent <PlayerController>().network = this;
Painter p = FindObjectOfType <Painter>();
p.maxInk = this.curLevel.MaxInk;
p.readOnly = false;
GameObject player = this.curLevelObj.transform.Find("Character").gameObject;
player.GetComponent <Rigidbody2D>().bodyType = RigidbodyType2D.Dynamic;
var walls = GameObject.FindGameObjectsWithTag("wall");
if (!Debugging)
{
if (!NetworkManager.Instance.IsServer)
{
this.curLevelObj.transform.Find("Character").gameObject.SetActive(false);
foreach (var wall in walls)
{
wall.GetComponent <SpriteRenderer>().enabled = false;
}
}
else
{
p.readOnly = true;
}
}
}
void setupLevelRewardIcons(LevelRecord level)
{
int currentRewardCount = GameServiceLayer.serviceLayer.itemService.getRewardCount();
if (level.getRequiredRewards() <= currentRewardCount)
{
levelUIButton.isEnabled = true;
lockObject.SetActive(false);
rewardObject.SetActive(true);
if (level.collectedRewards >= 1)
{
reward1Icon.color = Color.white;
} else
{
reward1Icon.color = Color.black;
}
if (level.collectedRewards >= 2)
{
reward2Icon.color = Color.white;
} else
{
reward2Icon.color = Color.black;
}
if (level.collectedRewards >= 3)
{
reward3Icon.color = Color.white;
} else
{
reward3Icon.color = Color.black;
}
} else
{
lockObject.SetActive(true);
rewardObject.SetActive(false);
lockLabel.text = (level.getRequiredRewards() - currentRewardCount) .ToString();
levelUIButton.isEnabled = false;
}
}
/// <summary>
/// Рекорды по умолчанию
/// </summary>
private void CreateRecords()
{
LevelRecord[] levelRecord = new LevelRecord[2];
levelRecord[0] = new LevelRecord()
{
levelName = "1_Level 1", recordTime = 666
};
levelRecord[1] = new LevelRecord()
{
levelName = "2_Level 2", recordTime = 666
};
records.collectionName = "Records";
records.levelRecords = levelRecord;
//
// string playerToJson = JsonHelper.ToJson(levelRecord, true);
// Debug.Log(playerToJson);
using (StreamWriter stream = new StreamWriter(Application.dataPath + RecordPath))
{
string json = JsonUtility.ToJson(records);
stream.Write(json);
}
}
void createLevelButton(LevelRecord level, GameObject currentWindow)
{
levelButton.levelIndex = level.getLevelIndex();
levelButton.currentWindow = currentWindow;
}
private void generateRulesForStressLevel(LevelRecord level)
{
level.setLevelType(LevelRecord.LevelType.STRESS);
levelTypeCounter++;
levelRequirement += 2 * stressMapReward;
mediumLevelResults += 2 * stressMapReward;
}
private void addNewRewardsToStorage(LevelRecord currentLevel, int newCollectedRewards)
{
int newDiamonds = newCollectedRewards - currentLevel.collectedRewards;
int rewardMultiplier = 1;
switch (currentLevel.getLevelType ()) {
case LevelRecord.LevelType.STRESS:
rewardMultiplier = 2;
break;
case LevelRecord.LevelType.BOSS:
rewardMultiplier = 3;
break;
}
itemService.addRewards (newDiamonds * rewardMultiplier);
}
private void generateRulesForBossLevel(LevelRecord level)
{
level.setLevelType(LevelRecord.LevelType.BOSS);
levelTypeCounter = 1;
mediumLevelResults += 2 * bossMapReward;
if (!firstBoss)
{
mediumLevelResults += bossStepOffset;
}
else
{
firstBoss = false;
mediumLevelResults += firstBossStepOffset;
}
levelRequirement = mediumLevelResults;
}
void setupTimeLabels(LevelRecord currentLevel)
{
timeLabel.text = "Time: " + GameServiceLayer.serviceLayer.gameMaster.getElapsedTime ().ToString ("0.00");
bestTimeLabel.text = "Best: " + currentLevel.bestTime.ToString ("0.00");
}
public IPromise <(int, List <RankingEntry>)> GetLevelRankings(string levelId, string chartType)
{
var entries = new List <RankingEntry>();
var top10 = new List <RankingEntry>();
if (IsAuthenticated)
{
return(RestClient.GetArray <RankingEntry>(new RequestHelper
{
Uri = $"{Context.ApiUrl}/levels/{levelId}/charts/{chartType}/records?limit=10",
Headers = GetRequestHeaders(),
EnableDebug = true
})
.Then(data =>
{
top10 = data.ToList();
// Add the first 3
entries.AddRange(top10.GetRange(0, Math.Min(3, top10.Count)));
return RestClient.GetArray <RankingEntry>(new RequestHelper
{
Uri =
$"{Context.ApiUrl}/levels/{levelId}/charts/{chartType}/user_ranking?limit=6",
Headers = GetRequestHeaders(),
EnableDebug = true
});
})
.Then(data =>
{
var list = data.ToList();
// Find user's position
var userRank = -1;
RankingEntry userEntry = null;
for (var index = 0; index < data.Length; index++)
{
var entry = data[index];
if (entry.owner.Uid == Context.Player.Id)
{
userRank = entry.rank;
userEntry = entry;
break;
}
}
if (userRank == -1 || userRank <= 10)
{
// Just use top 10
entries = top10;
}
else
{
// Add previous 6 and next 6, and remove accordingly
var append = new List <RankingEntry>();
append.AddRange(list);
append.RemoveRange(0, Math.Max(3, Math.Max(0, 10 - userRank)));
if (append.Count > 7)
{
append.RemoveRange(7, append.Count - 7);
}
entries.AddRange(append);
}
if (userEntry != null)
{
// Replace local performance only if higher or equal score
var record = Context.Database.GetLevelRecord(levelId);
if (record == null || !record.BestPerformances.ContainsKey(chartType) ||
record.BestPerformances[chartType].Score < userEntry.score ||
(record.BestPerformances[chartType].Score == userEntry.score && record.BestPerformances[chartType].Accuracy < userEntry.accuracy))
{
if (record == null)
{
record = new LevelRecord
{
LevelId = levelId
}
}
;
var newBest = new LevelRecord.Performance
{
Score = userEntry.score,
Accuracy = userEntry.accuracy
};
record.BestPerformances[chartType] = newBest;
Context.Database.SetLevelRecord(record);
if (Context.LevelManager.LoadedLocalLevels.ContainsKey(levelId))
{
Context.LevelManager.LoadedLocalLevels[levelId].Record = record;
}
OnLevelBestPerformanceUpdated.Invoke(levelId);
Debug.Log("Updating: " + levelId);
}
}
return (userRank, entries);
}));
}
return(RestClient.GetArray <RankingEntry>(new RequestHelper
{
Uri = $"{Context.ApiUrl}/levels/{levelId}/charts/{chartType}/records",
EnableDebug = true,
}).Then(array => (-1, array.ToList())));
}
List<LevelRecord> generateCompleteWorld(int worldId, int collectedDiamonds, bool isMultiplayer)
{
List<LevelRecord> levelRecordList = new List<LevelRecord>();
for (int i = 0; i < 90; i++)
{
LevelRecord testLevelRecordWorld = new LevelRecord(Random.Range(0, 120), "test" + worldId + i, "world" + worldId,
30f, 20f, isMultiplayer);
testLevelRecordWorld.collectedRewards = collectedDiamonds;
levelRecordList.Add(testLevelRecordWorld);
}
return levelRecordList;
}
