public void SendGameStart(MainGameData gameData)
{
GameId = Guid.NewGuid().ToString();
AnalyticsResult analyticsResult = Analytics.CustomEvent(Constants.Analytics.Events.GameStart, new Dictionary <string, object>
{
{ Constants.Analytics.Parameters.User, PlayerGuid },
{ Constants.Analytics.Parameters.AppVersion, appVersion },
{ Constants.Analytics.Parameters.GameId, GameId },
{ Constants.Analytics.Parameters.GameLevel, gameData.Ruleset.Id }
});
DebugLog($"[ANALYTICS] [{analyticsResult}] {Constants.Analytics.Events.GameStart}: {gameData.Ruleset.Id}");
}
public void ResetBoard()
{
validationIcon.sprite = null;
RuleSettings rules = ScriptableObject.CreateInstance <RuleSettings>();
rules.levelData = "000000000000000000000000000000000000000000000000000000000000000000000000000000000";
rules.targetIndexes = new int[] { };
MainGameData data = new MainGameData
{
Ruleset = rules
};
gameplay.ConfigureCreator(data);
}
private void GameSolvedHandler(MainGameData gameData)
{
if (gameData != null)
{
analyticsController.SendGameData(GameSourceType.Finish, gameData);
if (!gameData.Replay && !gameData.Ruleset.IsFtue && !gameData.Ruleset.IsGold)
{
FilmSpentHandler();
}
}
GameSessionCounter++;
DebugLog("[ADS] game session counter: " + GameSessionCounter);
}
public void SetupGame()
{
MainGameData mainGameData = new MainGameData
{
Ruleset = gameController.GetRules(),
Level = gameController.Player.MainGameLevelIndex + 1
};
if (replayData != null)
{
mainGameData.answers = replayData.answers;
replayData = null;
}
gameController.SetupGameHandler(mainGameData);
}
public void StartFtueGame(MainGameData gameData, GridController gridController, KeyboardController keyboardController)
{
if (gameData.Ruleset.levelData.Equals(ftueGameOne.levelData))
{
analyticsController.TutorialStarted();
print("START FTUE LEVEL ONE");
StartGameOne(gridController, keyboardController);
}
else if (gameData.Ruleset.levelData.Equals(ftueGameTwo.levelData))
{
print("START FTUE LEVEL TWO");
StartGameTwo(gridController, keyboardController);
}
else
{
print("UNKNOWN FTUE LEVEL!!!");
}
}
public void SetupGameHandler(MainGameData gameData)
{
print("[GC] Setup game handler");
if (ftueController.ShouldPlayFirstGame)
{
print("Setup FTUE GAME ONE");
sessionScript.SetupFtueGame(gameData);
}
else if (ftueController.ShouldPlaySecondGame)
{
print("Setup FTUE GAME TWO");
sessionScript.SetupFtueGame(gameData);
}
else
{
print("Setup NORMAL GAME");
sessionScript.SetupGame(gameData);
}
}
public int SetGameTime(MainGameData gameData)
{
int secondsLeft = gameData.SecondsLeft;
StartCoroutine(DepleteBarFill());
if (secondsLeft < threeStarSecondsLimit && !thirdStarLost)
{
thirdStarLost = true;
starThree.LoseStar();
}
if (secondsLeft < twoStarSecondsLimit && !secondStarLost)
{
secondStarLost = true;
starTwo.LoseStar();
}
return(secondsLeft >= threeStarSecondsLimit ? 3 : secondsLeft >= twoStarSecondsLimit ? 2 : 1);
}
public static MainGameData LoadMainGameData()
{
string path = Application.persistentDataPath + "/playerData.fun";
if (File.Exists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
MainGameData mainGameData = formatter.Deserialize(stream) as MainGameData;
stream.Close();
return(mainGameData);
}
else
{
return(null);
}
}
public void GameFinished(MainGameData gameData)
{
InterfaceController.Instance.SetButtonsEnabled(false);
replayData = gameData;
checkBoxController.SetupWithAnswers(gameData.answers);
timerController.SetupTimerText(gameData.SecondsUsed);
// Need all correct -> just next level button
// 1/2 correct -> retry and next level buttons
// no correct -> retry button
bool complete = gameData.answers.All(x => x.correct);
string animationTrigger;
int correctCount;
if (complete)
{
if (!gameData.Ruleset.IsFtueGame)
{
gameController.Player.MainGameLevelIndex += 1;
}
correctCount = 3;
replayData = null;
animationTrigger = Constants.Animation.MainMenu.ExitGameComplete;
}
else
{
correctCount = gameData.answers.Where(x => x.correct == true).Count();
animationTrigger = correctCount > 0 ? Constants.Animation.MainMenu.ExitGameIncomplete : Constants.Animation.MainMenu.ExitGameFail;
}
gameController.Player.DeductionScore += gameController.GetDeductionScore(gameData.SecondsUsed, correctCount);
serverController.PersistPlayerProgress(gameController.Player);
//TODO: check for FTUE level
//check which Level it is too
//playButtonLabel.text = $"LEVEL {gameData.Level + 1}";
UpdatePlayButtonText();
animator.SetTrigger(animationTrigger);
}
public void SendGameData(GameSourceType gameSource, MainGameData gameData)
{
LevelID = gameData.Ruleset.Id + "_" + gameData.Ruleset.PuzzleNameKey; //.PuzzleName;
if (gameSource == GameSourceType.Start)
{
GameId = Guid.NewGuid().ToString();
AdjustEvent adjustEvent = new AdjustEvent(Constants.Analytics.AdjustEvents.GamePlayed);
Adjust.trackEvent(adjustEvent);
}
int timeTakenToSolve = 0;
int starsEarned = 0;
if (gameSource == GameSourceType.Finish)
{
timeTakenToSolve = gameData.TimeLimit - gameData.SecondsLeft;
starsEarned = gameData.StarScore;
}
if (ShouldSkipSendEvent)
{
DebugLog($"[ANALYTICS] [Skip] {Constants.Analytics.Events.GameEvent}: {MapGameSource(gameSource).ToString()} " +
$"{Constants.Analytics.Parameters.GameType}: {MapGameType(gameData.GameType).ToString()} " +
$"{Constants.Analytics.Parameters.GameId}: {GameId} " +
$"{Constants.Analytics.Parameters.GameLevel}: {LevelID}" +
$"{Constants.Analytics.Parameters.TimeTakenToSolve}: {timeTakenToSolve}" +
$"{Constants.Analytics.Parameters.StarsEarned}: {starsEarned}" +
$"{Constants.Analytics.Parameters.RemainingFilm}: {gameData.PlayerFilmRemaining}");
return;
}
QLGameEvent gameEvent = new QLGameEvent(MapGameSource(gameSource), MapGameType(gameData.GameType), GameId, LevelID, timeTakenToSolve, starsEarned, gameData.PlayerFilmRemaining);
TrackEvent(gameEvent);
}
public void SendGameFinished(MainGameData gameData)
{
GameId = Guid.NewGuid().ToString();
List <string> answerData = new List <string>();
for (int i = 0; i < gameData.answers.Length; i++)
{
GridAnswer answer = gameData.answers[i];
answerData.Add($"{answer.index}:{answer.number}={answer.correct}");
}
AnalyticsResult analyticsResult = Analytics.CustomEvent(Constants.Analytics.Events.GameFinish, new Dictionary <string, object>
{
{ Constants.Analytics.Parameters.User, PlayerGuid },
{ Constants.Analytics.Parameters.AppVersion, appVersion },
{ Constants.Analytics.Parameters.GameId, GameId },
{ Constants.Analytics.Parameters.GameLevel, gameData.Ruleset.Id },
{ Constants.Analytics.Parameters.GameTime, gameData.SecondsUsed },
{ Constants.Analytics.Parameters.GameData, string.Join(",", answerData) }
});
DebugLog($"[ANALYTICS] [{analyticsResult}] {Constants.Analytics.Events.GameFinish}: {gameData.Ruleset.Id}");
//AdjustEvent adjustEvent = new AdjustEvent(Constants.Analytics.AdjustEvents.GamePlayed);
//Adjust.trackEvent(adjustEvent);
}
public void RemakePlayerProgressString(MainGameData gameData)
{
Player player = SceneActivationBehaviour <GameLogicActivator> .Instance.GameController.Player;
List <string> progressStrings = new List <string>(1000);
string s = player.LevelProgress;
string[] values = s.Split(',');
int currentStarRecord = 1;
for (int i = 0; i < values.Length; i++)
{
progressStrings.Add(values[i]);
if (values[i].Contains(gameData.Ruleset.UniqueID))
{
currentStarRecord = int.Parse(values[i].Substring(values[i].Length - 1));
}
}
StringBuilder builder = new StringBuilder();
for (int j = 0; j < progressStrings.Count; j++)
{
if (progressStrings[j].Contains(gameData.Ruleset.UniqueID))
{
if (gameData.StarScore >= currentStarRecord) // if player has exceeded their record for score on this level
{
builder.Append(string.Concat(gameData.Ruleset.UniqueID, "-", gameData.StarScore));
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
if (!gameData.Replay)
{
player.CompletedLevels += 1;
}
}
else
{
builder.Append(string.Concat(gameData.Ruleset.UniqueID, "-", currentStarRecord));
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
}
}
else
{
builder.Append(progressStrings[j]);
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
}
}
player.LevelProgress = builder.ToString();
serverController.PersistPlayerProgress(player);
SceneActivationBehaviour <MainMenuActivator> .Instance.SetCurrentProgressOnMainMenu(player, globalSettings);
return;
}
public void RemakePlayerGoldString(string uniqueID, GoldLevelCardScript.GoldCardState cardState, MainGameData gameData = null)
{
Player player = SceneActivationBehaviour <GameLogicActivator> .Instance.GameController.Player;
List <string> progressStrings = new List <string>(1000);
string s = player.LevelProgress;
string[] values = s.Split(',');
for (int i = 0; i < values.Length; i++)
{
progressStrings.Add(values[i]);
}
StringBuilder builder = new StringBuilder();
for (int j = 0; j < progressStrings.Count; j++)
{
if (progressStrings[j].Contains(uniqueID))
{
if (cardState.Equals(GoldLevelCardScript.GoldCardState.Unlocked))
{
builder.Append(string.Concat(uniqueID, "-U"));
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
}
else if (cardState.Equals(GoldLevelCardScript.GoldCardState.Purchased))
{
builder.Append(string.Concat(uniqueID, "-P"));
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
}
else if (cardState.Equals(GoldLevelCardScript.GoldCardState.Complete))
{
builder.Append(string.Concat(uniqueID, "-", gameData.StarScore));
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
if (!gameData.Replay)
{
player.CompletedLevels += 1;
}
}
}
else
{
builder.Append(progressStrings[j]);
if (!j.Equals(progressStrings.Count - 1))
{
builder.Append(",");
}
}
}
player.LevelProgress = builder.ToString();
serverController.PersistPlayerProgress(player);
if (gameData != null)
{
SceneActivationBehaviour <MainMenuActivator> .Instance.SetCurrentProgressOnMainMenu(player, globalSettings);
}
return;
}
public void SetupGameHandler(MainGameData gameData)
{
print("[GC] Setup game handler");
sessionScript.SetupGame(gameData);
}
private IEnumerator FinishWithDelay(MainGameData gameData)
{
yield return(new WaitForSeconds(1f));
SceneActivationBehaviour <SPEGameSceneActivator> .Instance.GameFinished(gameData);
}
private void GameFinishedHandler(MainGameData gameData)
{
print($"[GC] Finished Time: {gameData.SecondsUsed} ");
StartCoroutine(FinishWithDelay(gameData));
}
private void GameQuitHandler(MainGameData gameData)
{
print("[GC] Quit");
}
private void GameResumedHandler(MainGameData gameData)
{
print("[GC] Resumed");
}
private void GamePausedHandler(MainGameData gameData)
{
print("[GC] Paused");
}
// called immediately when puzzle is solved
public void RecordLevelCompletion(MainGameData gameData)
{
if (!gameData.Replay)
{
player.MainPuzzleIndex++;
LevelGroupingSettings levelGroupingSettings = globalSettings.levelGroupingSettings[player.GroupIndex];
int nextLevelID = player.CurrentLevelInGroupIndex + 1;
if (levelGroupingSettings.Levels.ElementAtOrDefault(nextLevelID) == null)
{
// collection complete - move group on
if (player.GroupIndex < globalSettings.levelGroupingSettings.Length - 1)
{
if (levelGroupingSettings.GoldLevels.Count > 0)
{
player.MainPuzzleIndex += levelGroupingSettings.GoldLevels.Count;
}
player.GroupIndex++;
player.CurrentLevelInGroupIndex = 0;
player.NewLocation = true;
globalSettings.levelGroupingSettings[player.GroupIndex].Locked = false;
SceneActivationBehaviour <CollectionScreenActivator> .Instance.ShowCollectionEvent(CollectionScreenActivator.CollectionEvent.NewLocationUnlocked, player);
InterfaceController.Instance.Show(GameWindow.PostGameScene);
SceneActivationBehaviour <PostGameSceneActivator> .Instance.ShowBoardPostGame(gameData, nextCollectionUnlocked : true);
}
else
{
player.GameComplete = true;
player.MainPuzzleIndex += levelGroupingSettings.GoldLevels.Count;
SceneActivationBehaviour <CollectionScreenActivator> .Instance.ShowCollectionEvent(CollectionScreenActivator.CollectionEvent.GameComplete);
InterfaceController.Instance.Show(GameWindow.PostGameScene);
SceneActivationBehaviour <PostGameSceneActivator> .Instance.ShowBoardPostGame(gameData);
}
}
else
{
player.CurrentLevelInGroupIndex++;
if (player.GroupIndex > 0)
{
SceneActivationBehaviour <CollectionScreenActivator> .Instance.ShowCollectionEvent(CollectionScreenActivator.CollectionEvent.NextLevelInOrderComplete);
}
InterfaceController.Instance.Show(GameWindow.PostGameScene);
SceneActivationBehaviour <PostGameSceneActivator> .Instance.ShowBoardPostGame(gameData);
}
}
else
{
InterfaceController.Instance.Show(GameWindow.PostGameScene);
SceneActivationBehaviour <PostGameSceneActivator> .Instance.ShowBoardPostGame(gameData);
}
PlayerProgressStringBuilder.Instance.RemakePlayerProgressString(gameData);
ReviewRequestScript.TryRequestReview(player, gameData.StarScore.Equals(3));
}
public void StartFtueGame(MainGameData gameData, GridController gridController, KeyboardController keyboardController)
{
ftueController.StartFtueGame(gameData, gridController, keyboardController);
}
public void CmdSetStatus(GameStatus status)
{
MainGameData.SetStatus(status);
}
private void GameQuitHandler(MainGameData gameData)
{
print("[GC] Quit");
analyticsController.SendGameQuit(gameData);
}
private void GameStartedHandler(MainGameData gameData)
{
print("[GC] Started");
analyticsController.SendGameStart(gameData);
}
//THIS CLASS IS MY IMPLEMENTATION OF FINDING A UNIT'S MOVE RANGE ON A GRAPH OF VARYING TYPES OF TERRAIN
//THIS IS CALLED BEFORE THE A* PATHFINDING, SO THAT THE A* HAS A LIST OF MOVEABLE TILES TO WORK WITH
//THE TILES ARE STORED IN A LIST IN ANOTHER SCRIPT, SO ANY TIME THE TERM INDEX
//OR THE FUNCTION TILEARRAYACTUALFUNCT IS USED, IT IS REFERRING TO THE TILES OR THEIR INDEXES
//STORED IN THE REFERENCED SCRIPT
//this function should be initiated with xPos and yPos corresponding to the unit calling it's x and y positions
//the current move points should be initialized with the unit calling its maximum move points
public void ShowMovementRange(float xPos, float yPos, int currentMovePoints, List <GameObject> tileList, PlayerMovement playMove, MainGameData mainTong, bool canWalkOnMountains, bool canWalkOnWater)
{
int startIndex = mainTong.TileArrayActualFunct(new Vector3(xPos, yPos, 0));
GameObject startTile = tileList[startIndex];
bool startWalkable = true;
bool doorOrNah = false;
bool isWall = true;
bool addedThisRun = false;
//another script stores all the tile's movement points and initalizes them all to 100 before this script is called
//values over 100 mean the tile has been checked and deemed unwalkable to this unit type
//values under 100 mean the tile has been checked, but if you can visit that tile from a path where you have more move points remaining, it can be checked/overwritten again
//this allows the function to iterate through all the relevant tiles and easily check the stored values to see if the current tile is both possible to visit/has been visited by a worse/better path
//higher move points are better, since it means that you are visiting a tile with more spaces left to go from there
int startMove = GameDatabase.database.GetMovementPoints(startTile); //finding the movement points this tile has been visited with
if (startMove == 100) //100 is the value that tiles that haven't been checked yet are set to
{
startWalkable = GameDatabase.database.IsTileTypeWalkableForGroundUnits(mainTong.tileManagerMainGame.typeOfEachTile[startIndex]);
isWall = GameDatabase.database.IsTileTypeWall(mainTong.tileManagerMainGame.typeOfEachTile[startIndex]);
//checking different permutations of unwalkeable/walkable tile types (for tiles that haven't been checked yet)
if (((startWalkable == true && canWalkOnMountains == false && canWalkOnWater == false) || (canWalkOnMountains == true && canWalkOnWater == true && isWall == false)))
{
doorOrNah = ((mainTong.tileManagerMainGame.typeOfEachTile[startIndex] == (int)(GameDatabase.TileTypesInts.Door) && mainTong.tileManagerMainGame.eachExtraUsedOrNot[mainTong.tileManagerMainGame.ExtraIndexNumGetter(startIndex)]) || mainTong.tileManagerMainGame.typeOfEachTile[startIndex] != (int)(GameDatabase.TileTypesInts.Door));
if (doorOrNah == true) //add the tile and set it's value to currentMovePoints
{
listOfMoveableTiles.Add(startTile);
GameDatabase.database.SetMovementPointsMove(startTile, currentMovePoints);
addedThisRun = true;
}
else //set tile to unwalkable and move on to the next one
{
GameDatabase.database.SetMovementPointsMove(startTile, 102);
return;
}
}
else //set tile to unwalkable and move on to the next one
{
GameDatabase.database.SetMovementPointsMove(startTile, 102);
return;
}
}
else if (startMove > 100)
{
return;
}
else
{
//calling a function that tries to set the current tile's move points to the movePoints passed in to this function
//if the movePoints we have currently is lower or the same, the function returns false and we don't do anything
//otherwise, the function returns true and sets the current tile's movePoints to our currentMovePoints
if (GameDatabase.database.SetMovementPointsMove(startTile, currentMovePoints) == false)
{
return;
}
startMove = currentMovePoints;
startWalkable = GameDatabase.database.IsTileTypeWalkableForGroundUnits(mainTong.tileManagerMainGame.typeOfEachTile[startIndex]);
doorOrNah = ((mainTong.tileManagerMainGame.typeOfEachTile[startIndex] == (int)(GameDatabase.TileTypesInts.Door) && mainTong.tileManagerMainGame.eachExtraUsedOrNot[mainTong.tileManagerMainGame.ExtraIndexNumGetter(startIndex)]) || mainTong.tileManagerMainGame.typeOfEachTile[startIndex] != (int)(GameDatabase.TileTypesInts.Door));
isWall = GameDatabase.database.IsTileTypeWall(mainTong.tileManagerMainGame.typeOfEachTile[startIndex]);
}
BaseCharacterClass toonHere = null;
if (addedThisRun == true)
{
//if the tile has just been checked in this function
//check to see if its already occupied by another unit
//if so, add it to the listOfMoveableTilesOccupiedBySame list for reference later
//since it's technically moveable but you can't actually land there, etc.
if (playMove.playersAndEnemyPositions.TryGetValue(startTile.transform.position, out toonHere) == true)
{
if (this.enemyTing == null)
{
if (toonHere.enemyTing == null)
{
listOfMoveableTilesOccupiedBySame.Add(startTile);
}
}
else if (this.enemyTing != null)
{
if (toonHere.enemyTing != null)
{
listOfMoveableTilesOccupiedBySame.Add(startTile);
}
}
}
}
if (((startWalkable == true && canWalkOnMountains == false && canWalkOnWater == false) || (canWalkOnMountains == true && canWalkOnWater == true && isWall == false) || doorOrNah))
{
//getNeighbors is a function that returns a list of all adjacent tiles to the tile passed in
List <GameObject> tileNeighborrs = GetNeighbors(startTile, startIndex);
int getmovePoints = 100;
bool occupiedByOpposite = false;
int nextMoveCost = currentMovePoints;
//now we iterate through all the neighbors of this tile
//and if it passes all the checks (hasn't been visited, or is visitable and has a lower movePoints value, etc.)
//we will call this function recursively on that tile
//otherwise, we continue on
for (int i = 0; i < tileNeighborrs.Count; i++)
{
int neighborIndex = mainTong.TileArrayActualFunct(tileNeighborrs[i].transform.position);
nextMoveCost = currentMovePoints - GameDatabase.database.GetTileMovementCost(mainTong.tileManagerMainGame.typeOfEachTile[neighborIndex]);
if (nextMoveCost >= 0)
{
occupiedByOpposite = false;
getmovePoints = GameDatabase.database.GetMovementPoints(tileNeighborrs[i]);
if (getmovePoints < 100)
{
if (nextMoveCost <= getmovePoints)
{
continue;
}
}
else if (getmovePoints == 100)
{
if (playMove.playersAndEnemyPositions.TryGetValue(tileNeighborrs[i].transform.position, out toonHere) == true)
{
if (this.enemyTing == null)
{
if (toonHere.enemyTing != null)
{
occupiedByOpposite = true;
GameDatabase.database.SetMovementPointsMove(tileNeighborrs[i], 102);
}
}
else if (this.enemyTing != null)
{
if (toonHere.enemyTing == null)
{
occupiedByOpposite = true;
GameDatabase.database.SetMovementPointsMove(tileNeighborrs[i], 102);
}
}
}
}
else if (getmovePoints > 100)
{
continue;
}
if (occupiedByOpposite == false)
{
ShowMovementRange(tileNeighborrs[i].transform.position.x, tileNeighborrs[i].transform.position.y, nextMoveCost, tileList, playMove, mainTong, canWalkOnMountains, canWalkOnWater);
}
}
}
}
}
private void GameStartedHandler(MainGameData gameData)
{
print("[GC] Started");
}
public static void Initialize()
{
// read static game data
GameDataUtils.ReadAllData(out gameData, MainDataFolder, Config.Default.GameDataExtension, Config.Default.GameDataApplication);
// read user game data
MainGameData userGameData = new MainGameData();
if (!UserDataFolder.Equals(MainDataFolder, StringComparison.OrdinalIgnoreCase))
{
GameDataUtils.ReadAllData(out userGameData, UserDataFolder, Config.Default.GameDataExtension, Config.Default.GameDataApplication, true);
}
// creatures
gameData.Creatures.AddRange(userGameData.Creatures);
dinoSpawns = gameData.Creatures.ConvertAll(item => new DinoSpawn {
ClassName = item.ClassName, Mod = item.Mod, KnownDino = true, DinoNameTag = item.NameTag
}).ToArray();
dinoMultipliers = gameData.Creatures.ConvertAll(item => new ClassMultiplier {
ClassName = item.ClassName
}).ToArray();
// engrams
gameData.Engrams.AddRange(userGameData.Engrams);
engrams = gameData.Engrams.ConvertAll(item => new Engram {
EngramClassName = item.ClassName, EngramLevelRequirement = item.Level, EngramPointsCost = item.Points, Mod = item.Mod, KnownEngram = true, IsTekgram = item.IsTekGram
}).ToArray();
// items
gameData.Items.AddRange(userGameData.Items);
items = gameData.Items.ConvertAll(item => new PrimalItem {
ClassName = item.ClassName, Mod = item.Mod, KnownItem = true, Category = item.Category
}).ToArray();
// resources
resourceMultipliers = gameData.Items.Where(item => item.IsHarvestable).ToList().ConvertAll(item => new ResourceClassMultiplier {
ClassName = item.ClassName, Mod = item.Mod, KnownResource = true
}).ToArray();
// map spawners
gameData.MapSpawners.AddRange(userGameData.MapSpawners);
mapSpawners = gameData.MapSpawners.ConvertAll(item => new MapSpawner {
ClassName = item.ClassName, Mod = item.Mod, KnownSpawner = true
}).ToArray();
// supply crates
gameData.SupplyCrates.AddRange(userGameData.SupplyCrates);
var crates = gameData.SupplyCrates.ConvertAll(item => new SupplyCrate {
ClassName = item.ClassName, Mod = item.Mod, KnownSupplyCrate = true
});
// inventories
gameData.Inventories.AddRange(userGameData.Inventories);
crates.AddRange(gameData.Inventories.ConvertAll(item => new SupplyCrate {
ClassName = item.ClassName, Mod = item.Mod, KnownSupplyCrate = true
}));
supplyCrates = crates.ToArray();
// game maps
gameData.GameMaps.AddRange(userGameData.GameMaps);
if (gameData.GameMaps.Count > 0)
{
var maps1 = gameMaps.ToList();
maps1.AddRange(gameData.GameMaps.Where(item => !item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.ClassName, DisplayMember = item.Description
}));
var maps2 = gameMapsSotF.ToList();
maps2.AddRange(gameData.GameMaps.Where(item => item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.ClassName, DisplayMember = item.Description
}));
gameMaps = maps1.ToArray();
gameMapsSotF = maps2.ToArray();
}
// total conversion mods
gameData.Mods.AddRange(userGameData.Mods);
if (gameData.Mods.Count > 0)
{
var mods1 = totalConversions.ToList();
mods1.AddRange(gameData.Mods.Where(item => !item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.ClassName, DisplayMember = item.Description
}));
var mods2 = totalConversionsSotF.ToList();
mods2.AddRange(gameData.Mods.Where(item => item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.ClassName, DisplayMember = item.Description
}));
totalConversions = mods1.ToArray();
totalConversionsSotF = mods2.ToArray();
}
// creature levels
if (userGameData.CreatureLevels.Count > 0)
{
gameData.CreatureLevels = userGameData.CreatureLevels;
}
if (gameData.CreatureLevels.Count > 0)
{
levelsDino = gameData.CreatureLevels.ConvertAll(item => new Level {
XPRequired = item.XPRequired
}).ToArray();
DefaultMaxExperiencePointsDino = levelsDino.Max(l => l.XPRequired) + 1;
}
// player levels
if (userGameData.PlayerLevels.Count > 0)
{
gameData.PlayerLevels = userGameData.PlayerLevels;
}
LevelsPlayerAdditional = userGameData.PlayerAdditionalLevels;
if (gameData.PlayerLevels.Count > 0)
{
levelsPlayer = gameData.PlayerLevels.ConvertAll(item => new Level {
EngramPoints = item.EngramPoints, XPRequired = item.XPRequired
}).ToArray();
DefaultMaxExperiencePointsPlayer = levelsPlayer.Max(l => l.XPRequired) + 1;
}
if (gameData.PlayerAdditionalLevels > LevelsPlayerAdditional)
{
LevelsPlayerAdditional = gameData.PlayerAdditionalLevels;
}
// branches
gameData.Branches.AddRange(userGameData.Branches);
if (gameData.Branches.Count > 0)
{
var branches1 = branches.ToList();
branches1.AddRange(gameData.Branches.Where(item => !item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.BranchName, DisplayMember = item.Description
}));
var branches2 = branchesSotF.ToList();
branches2.AddRange(gameData.Branches.Where(item => item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.BranchName, DisplayMember = item.Description
}));
branches = branches1.ToArray();
branchesSotF = branches2.ToArray();
}
// events
gameData.Events.AddRange(userGameData.Events);
if (gameData.Events.Count > 0)
{
var events1 = events.ToList();
events1.AddRange(gameData.Events.Where(item => !item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.EventName, DisplayMember = item.Description
}));
var events2 = eventsSotF.ToList();
events2.AddRange(gameData.Events.Where(item => item.IsSotF).ToList().ConvertAll(item => new ComboBoxItem {
ValueMember = item.EventName, DisplayMember = item.Description
}));
events = events1.ToArray();
eventsSotF = events2.ToArray();
}
// official mods
gameData.OfficialMods.AddRange(userGameData.OfficialMods);
if (gameData.OfficialMods.Count > 0)
{
ModUtils.AddOfficialMods(gameData.OfficialMods.Where(m => !string.IsNullOrWhiteSpace(m.ModId)).Select(m => m.ModId));
}
}
/// <summary>
/// This is used in the beginning of the GameManager to load game information to put players in place
/// If there is no game progress, meaning that the player hasn't started the game, then load all the player to the first tile
/// </summary>
/// <returns></returns>
private bool LoadGameProgress()
{
MainGameData mainGameData = SaveSystem.LoadMainGameData();
if (mainGameData == null)
{
Debug.LogError("There is no main game data");
// Player hasn't save anything yet
return(false);
}
gameMode = (GameMode)(mainGameData.playerNum - 1);
players = new Player[4];
for (int i = 0; i < players.Length; i++)
{
GameObject player = Instantiate(ResourceManager.Instance.players[i], gameBoard.wayPoints[mainGameData.playersPositionsIndexes[i]].position, Quaternion.identity);
players[i] = player.GetComponent <Player>();
players[i].PositionIndex = mainGameData.playersPositionsIndexes[i];
}
switch (mainGameData.playerTurnIndex)
{
case 0:
gameTurnState = GameTurnState.Player1Turn;
break;
case 1:
gameTurnState = GameTurnState.Player2Turn;
break;
case 2:
gameTurnState = GameTurnState.Player3Turn;
break;
case 3:
gameTurnState = GameTurnState.Player4Turn;
break;
}
for (int i = 0; i < players.Length; i++)
{
players[i].playerIndex = i + 1;
}
foreach (var player in players)
{
player.onPlayerMovementFinished += ToggleGameState;
player.onPlayerMovementFinished += AiBeginMoving;
}
MiniGameData miniGameData = SaveSystem.LoadMiniGameData();
if (miniGameData != null) // If the player comes back from the mini game
{
switch (miniGameData.playerIndex)
{
case 1:
gameTurnState = GameTurnState.Player1Turn;
break;
case 2:
gameTurnState = GameTurnState.Player2Turn;
break;
case 3:
gameTurnState = GameTurnState.Player3Turn;
break;
case 4:
gameTurnState = GameTurnState.Player4Turn;
break;
}
if (miniGameData.state == 1) // Success
{
GetPlayerInTurn().MoveTiles(miniGameData.tileNum);
}
else if (miniGameData.state == 2) // Failure
{
GetPlayerInTurn().MoveTiles(-miniGameData.tileNum);
}
}
else
{
Debug.LogWarning("There is no mini game data yet (Ignore it if this shows in the beginning of the game)");
}
return(true);
}
