public void LoadNames(Model_SaveData data)
{
if (data.namesData == null)
{
Debug.Log("There is no names state data to load.");
return;
}
Model_Names names = new Model_Names(
_Player: data.namesData.Player,
_Ids: data.namesData.Ids,
_Ero: data.namesData.Ero,
_Myne: data.namesData.Myne,
_Eileen: data.namesData.Eileen,
_Ellenia: data.namesData.Ellenia,
_Tedwich: data.namesData.Tedwich,
_Ursie: data.namesData.Ursie,
_Kaffe: data.namesData.Kaffe,
_Latte: data.namesData.Latte,
_KingEclaire: data.namesData.KingEclaire,
_Suzette: data.namesData.Suzette,
_Peche: data.namesData.Peche,
_Melba: data.namesData.Melba,
_Moose: data.namesData.Moose,
_Flan: data.namesData.Flan
);
Script_Names.LoadNames(names);
Debug.Log($"-------- LOADED {name} --------");
Script_Utils.DebugToConsole(names);
}
public void LoadDrops(Model_SaveData data)
{
if (data.drops == null)
{
if (Debug.isDebugBuild)
{
Debug.Log("No drops data to load.");
}
return;
}
Model_PersistentDrop[] dropsData = data.drops;
foreach (Model_PersistentDrop drop in dropsData)
{
float[] vectorArray = drop.location;
Vector3 location = new Vector3(vectorArray[0], vectorArray[1], vectorArray[2]);
int dropLevelBehavior = drop.levelBehavior;
if (game.InstantiateDropById(drop.itemId, location, dropLevelBehavior))
{
Debug.Log($"Successful load of persistent drop {drop.itemId}");
}
else
{
Debug.LogError($"Error in loading persistent drop {drop.itemId}");
}
}
}
public void SaveMynesMirror(Model_SaveData data)
{
data.mynesMirrorData = new Model_MynesMirror(
mynesMirrorManager.InteractionCount,
mynesMirrorManager.DidSealingDialogue
);
}
public void LoadPianos(Model_SaveData data)
{
for (int i = 0; i < Script_PianoManager.NumPianos; i++)
{
bool isRemembered = data.pianosStateData != null && data.pianosStateData[i].isRemembered;
pianoManager.Pianos[i].IsRemembered = isRemembered;
}
}
public void LoadLevels(Model_SaveData data)
{
levelBehaviors = transform.GetComponentsInChildren <Script_SaveLoadLevelBehavior>(true);
foreach (Script_SaveLoadLevelBehavior LB in levelBehaviors)
{
LB.Load(data.runData);
}
}
public void SaveDrops(Model_SaveData data)
{
Model_PersistentDrop[] dropsData = game.GetPersistentDrops();
data.drops = dropsData;
foreach (Model_PersistentDrop drop in dropsData)
{
Debug.Log(drop.itemId);
}
}
public void SaveEventCycle(Model_SaveData data)
{
Model_EventCycleData eventCycle = new Model_EventCycleData(
_didInteractPositivelyWithIds: eventCycleManager.DidInteractPositivelyWithIds,
_idsPositiveInteractionCount: eventCycleManager.IdsPositiveInteractionCount,
_didTalkToElleniaCountdown: eventCycleManager.DidTalkToEllenia
);
data.eventCycleData = eventCycle;
}
public void LoadMynesMirror(Model_SaveData data)
{
Model_MynesMirror m = new Model_MynesMirror(
data.mynesMirrorData.interactionCount,
data.mynesMirrorData.didSealingDialogue
);
mynesMirrorManager.InteractionCount = m.interactionCount;
mynesMirrorManager.DidSealingDialogue = m.didSealingDialogue;
}
public void SavePianos(Model_SaveData data)
{
Model_PianoStateData[] pianosStateData = new Model_PianoStateData[Script_PianoManager.NumPianos];
for (int i = 0; i < Script_PianoManager.NumPianos; i++)
{
pianosStateData[i] = new Model_PianoStateData(pianoManager.Pianos[i].IsRemembered);
}
data.pianosStateData = pianosStateData;
}
public void SaveEquipment(Model_SaveData data)
{
Script_Sticker[] equipmentItems = Script_Game.Game.GetEquipmentItems();
string[] equipmentIds = new string[equipmentItems.Length];
for (int i = 0; i < equipmentIds.Length; i++)
{
equipmentIds[i] = equipmentItems[i] != null ? equipmentItems[i].id : null;
}
data.equipmentIds = equipmentIds;
}
public void SaveScarletCipher(Model_SaveData data)
{
Model_ScarletCipher ScarletCipher = new Model_ScarletCipher(
_scarletCipher: scarletCipher.ScarletCipher,
_visibility: scarletCipher.ScarletCipherVisibility,
_mirrorsActivation: scarletCipher.MynesMirrorsActivationStates,
_mirrorsSolved: scarletCipher.MynesMirrorsSolved
);
data.scarletCipherData = ScarletCipher;
}
public void UpdatePlayTime(Model_SaveData data)
{
data.gameData = new Model_GameData(
data.gameData.runIdx,
data.gameData.level,
data.gameData.cycleCount,
game.totalPlayTime,
data.gameData.activeEnding,
data.gameData.faceOffCounter
);
}
public void SavePlayerData(Model_SaveData data)
{
game.UpdatePlayerStateToCurrent();
Model_PlayerState p = game.GetPlayerState();
data.playerData = new Model_PlayerState(
p.spawnX,
p.spawnY,
p.spawnZ,
p.faceDirection
);
}
public void SaveGameData(Model_SaveData data, Model_GameData gameDataOverride)
{
Debug.Log($"Saving Total Time Played {game.totalPlayTime.FormatTotalPlayTime()}");
data.gameData = new Model_GameData(
gameDataOverride?.runIdx ?? game.RunIdx,
gameDataOverride?.level ?? game.level,
gameDataOverride?.cycleCount ?? game.CycleCount,
gameDataOverride?.totalPlayTime ?? game.totalPlayTime,
gameDataOverride?.activeEnding ?? game.ActiveEnding,
gameDataOverride?.faceOffCounter ?? game.faceOffCounter
);
}
public void LoadPlayerData(Model_SaveData data)
{
Model_PlayerState p = new Model_PlayerState(
data.playerData.spawnX,
data.playerData.spawnY,
data.playerData.spawnZ,
data.playerData.faceDirection
);
game.SetPlayerState(p);
Debug.Log($"-------- LOADED {name} --------");
Script_Utils.DebugToConsole(p);
}
public void LoadInventory(Model_SaveData data)
{
if (data.stickersIds == null)
{
if (Debug.isDebugBuild)
{
Debug.Log($"{name} No Sticker inventory items to load.");
}
}
else
{
string[] stickersIds = data.stickersIds;
for (int i = 0; i < stickersIds.Length; i++)
{
if (stickersIds[i] == null)
{
continue;
}
Debug.Log($"Adding Sticker by id: {stickersIds[i]}, to slot: {i}");
Script_Game.Game.AddItemInSlotById(stickersIds[i], i);
}
}
if (data.itemsIds == null)
{
if (Debug.isDebugBuild)
{
Debug.Log($"{name} No Items inventory items to load.");
}
}
else
{
string[] itemsIds = data.itemsIds;
for (int i = 0; i < itemsIds.Length; i++)
{
if (itemsIds[i] == null)
{
continue;
}
Debug.Log($"Adding Item by id: {itemsIds[i]}, to slot: {i}");
Script_Game.Game.AddItemInSlotById(itemsIds[i], i);
}
}
}
public void LoadGameData(Model_SaveData data)
{
game.LoadRun(data.gameData.runIdx, data.gameData.cycleCount);
game.level = data.gameData.level;
game.totalPlayTime = data.gameData.totalPlayTime;
game.ActiveEnding = data.gameData.activeEnding;
game.faceOffCounter = data.gameData.faceOffCounter;
Debug.Log($"---- LOADED {data.gameData} ----");
Debug.Log($"runIdx: {data.gameData.runIdx}");
Debug.Log($"level: {data.gameData.level}");
Debug.Log($"totalPlayTime: {data.gameData.totalPlayTime}");
Debug.Log($"activeEnding: {data.gameData.activeEnding}");
}
public bool Load()
{
SetPath();
try
{
if (File.Exists(saveFilePath))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(saveFilePath, FileMode.Open);
Model_SaveData data = (Model_SaveData)bf.Deserialize(file);
file.Close();
gameHandler.LoadGameData(data);
playerHandler.LoadPlayerData(data);
entriesHandler.LoadEntries(data);
inventoryHandler.LoadInventory(data);
equipmentHandler.LoadEquipment(data);
dropsHandler.LoadDrops(data);
levelsHandler.LoadLevels(data);
namesHandler.LoadNames(data);
scarletCipherHandler.LoadScarletCipher(data);
eventCycleHandler.LoadEventCycle(data);
mynesMirrorHandler.LoadMynesMirror(data);
pianosHandler.LoadPianos(data);
if (Debug.isDebugBuild)
{
Debug.Log("Successful load at: " + saveFilePath);
}
return(true);
}
else
{
if (Debug.isDebugBuild)
{
Debug.Log("Did not load; file not found.");
}
return(false);
}
}
catch (System.Exception e)
{
Debug.LogError("Failed Load with exception: " + e.ToString());
return(false);
}
}
public void SaveEntries(Model_SaveData data)
{
Model_Entry[] entriesData = new Model_Entry[game.entries.Length];
// get entries from game, create a model for each
for (var i = 0; i < entriesData.Length; i++)
{
Script_Entry e = game.entries[i];
entriesData[i] = new Model_Entry(
e.nameId,
e.text,
e.headline,
e.timestamp.ToBinary()
);
}
data.entriesData = entriesData;
}
public void SaveInventory(Model_SaveData data)
{
// Unstuck stickers in Inventory
Script_Item[] stickers = Script_Game.Game.GetStickers();
string[] stickersIds = new string[stickers.Length];
// Items in Inventory
Script_Item[] items = Script_Game.Game.GetItems();
string[] itemsIds = new string[items.Length];
for (int i = 0; i < stickersIds.Length; i++)
{
if (stickers[i] == null)
{
continue;
}
bool isSticker = stickers[i] is Script_Sticker;
if (isSticker)
{
stickersIds[i] = stickers[i]?.id;
}
}
for (int i = 0; i < itemsIds.Length; i++)
{
if (items[i] == null)
{
continue;
}
bool isPersistent = items[i].IsSpecial;
if (isPersistent)
{
itemsIds[i] = items[i]?.id;
}
}
data.stickersIds = stickersIds;
data.itemsIds = itemsIds;
}
public void LoadScarletCipher(Model_SaveData data)
{
if (data.scarletCipherData == null)
{
Debug.Log("There is no ScarletCipher state data to load.");
return;
}
Model_ScarletCipher ScarletCipher = new Model_ScarletCipher(
_scarletCipher: data.scarletCipherData.scarletCipher,
_visibility: data.scarletCipherData.visibility,
_mirrorsActivation: data.scarletCipherData.mirrorsActivation,
_mirrorsSolved: data.scarletCipherData.mirrorsSolved
);
scarletCipher.ScarletCipher = ScarletCipher.scarletCipher;
scarletCipher.ScarletCipherVisibility = ScarletCipher.visibility;
scarletCipher.MynesMirrorsActivationStates = ScarletCipher.mirrorsActivation;
scarletCipher.MynesMirrorsSolved = ScarletCipher.mirrorsSolved;
}
public void LoadEventCycle(Model_SaveData data)
{
if (data.eventCycleData == null)
{
Debug.Log($"There is no {this} state data to load.");
return;
}
Model_EventCycleData eventCycle = new Model_EventCycleData(
_didInteractPositivelyWithIds: data.eventCycleData.didInteractPositivelyWithIds,
_idsPositiveInteractionCount: data.eventCycleData.idsPositiveInteractionCount,
_didTalkToElleniaCountdown: data.eventCycleData.didTalkToElleniaCountdown
);
eventCycleManager.DidInteractPositivelyWithIds = eventCycle.didInteractPositivelyWithIds;
eventCycleManager.IdsPositiveInteractionCount = eventCycle.idsPositiveInteractionCount;
eventCycleManager.DidTalkToEllenia = eventCycle.didTalkToElleniaCountdown;
Debug.Log($"-------- LOADED {name} --------");
Script_Utils.DebugToConsole(eventCycle);
}
public void LoadEquipment(Model_SaveData data)
{
if (data.equipmentIds == null)
{
if (Debug.isDebugBuild)
{
Debug.Log("No sticker items to load.");
}
return;
}
string[] equipmentIds = data.equipmentIds;
for (int i = 0; i < equipmentIds.Length; i++)
{
if (equipmentIds[i] == null)
{
continue;
}
Script_Game.Game.AddEquippedItemInSlotById(equipmentIds[i], i);
}
}
public void LoadEntries(Model_SaveData data)
{
if (data.entriesData == null)
{
if (Debug.isDebugBuild)
{
Debug.Log("No entries data to load.");
}
return;
}
Model_Entry[] entriesData = data.entriesData;
foreach (Model_Entry e in entriesData)
{
entryManager.AddEntry(
e.nameId,
e.text,
DateTime.FromBinary(e.timestamp),
e.headline
);
}
}
public void SaveNames(Model_SaveData data)
{
Model_Names names = new Model_Names(
_Player: Script_Names.Player,
_Ids: Script_Names.Ids,
_Ero: Script_Names.Ero,
_Myne: Script_Names.Myne,
_Eileen: Script_Names.Eileen,
_Ellenia: Script_Names.Ellenia,
_Tedwich: Script_Names.Tedwich,
_Ursie: Script_Names.Ursie,
_Kaffe: Script_Names.Kaffe,
_Latte: Script_Names.Latte,
_KingEclaire: Script_Names.KingEclaire,
_Suzette: Script_Names.Suzette,
_Peche: Script_Names.Peche,
_Melba: Script_Names.Melba,
_Moose: Script_Names.Moose,
_Flan: Script_Names.Flan
);
data.namesData = names;
}
/// <param name="type">SavePoint saves within Kelsingor</param>
/// <param name="playerStateOverride">Option to override player state</param>
public void Save(
Model_PlayerState playerStateOverride = null,
Model_GameData gameDataOverride = null
)
{
SetPath();
try
{
/// Update total play time
game.OnSaveTasks();
BinaryFormatter bf = new BinaryFormatter();
/// Main data to pass around and modify
Model_SaveData saveData = new Model_SaveData();
SaveGame(saveData);
OverridePlayerData(saveData, playerStateOverride);
HandleSaveRun(saveData);
WriteSaveDataFile(bf, saveFilePath, saveData);
/// Create SavedGameTitleData
FileStream titleFile = File.Create(savedGameTitleDataPath);
Model_SavedGameTitleData savedGameTitleData = savedGameTitleDataHandler.Create();
bf.Serialize(titleFile, savedGameTitleData);
titleFile.Close();
if (Debug.isDebugBuild)
{
Debug.Log("Save successful at: " + saveFilePath);
}
}
catch (System.Exception e)
{
Debug.LogError("Failed Save with exception: " + e.ToString());
}
void SaveGame(Model_SaveData data)
{
gameHandler.SaveGameData(data, gameDataOverride);
playerHandler.SavePlayerData(data);
entriesHandler.SaveEntries(data);
inventoryHandler.SaveInventory(data);
equipmentHandler.SaveEquipment(data);
dropsHandler.SaveDrops(data);
namesHandler.SaveNames(data);
scarletCipherHandler.SaveScarletCipher(data);
eventCycleHandler.SaveEventCycle(data);
mynesMirrorHandler.SaveMynesMirror(data);
pianosHandler.SavePianos(data);
}
void WriteSaveDataFile(BinaryFormatter bf, string filePath, Model_SaveData data)
{
// will overwrite existing file
FileStream gameFile = File.Create(filePath);
bf.Serialize(gameFile, data);
gameFile.Close();
}
void OverridePlayerData(Model_SaveData data, Model_PlayerState playerState)
{
data.playerData = playerState ?? data.playerData;
}
void HandleSaveRun(Model_SaveData data)
{
levelsHandler.SaveLevels(data);
}
}
