1146 lines
49 KiB
C#
1146 lines
49 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.IO;
|
|
using System;
|
|
using System.Runtime.Serialization;
|
|
using System.Linq;
|
|
|
|
public class saveElementsOnSceneInfo : saveGameInfo
|
|
{
|
|
public elementOnSceneManager mainElementOnSceneManager;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public List<persistanceElementOnSceneInfo> persistanceInfoList;
|
|
|
|
public persistancePlayerElementOnSceneInfo temporalPersistancePlayerElementOnSceneInfo;
|
|
|
|
bool showCurrentDebugInfo;
|
|
|
|
public override void saveGame (int saveNumber, int playerID, string currentSaveDataPath, bool showDebugInfo, bool savingGameToChangeScene)
|
|
{
|
|
saveGameContent (saveNumber, playerID, currentSaveDataPath, showDebugInfo, savingGameToChangeScene);
|
|
}
|
|
|
|
public override void loadGame (int saveNumberToLoad, int playerID, string currentSaveDataPath, bool showDebugInfo)
|
|
{
|
|
loadGameContent (saveNumberToLoad, playerID, currentSaveDataPath, showDebugInfo);
|
|
}
|
|
|
|
public override void initializeValuesOnComponent ()
|
|
{
|
|
initializeValues ();
|
|
}
|
|
|
|
public void saveGameContent (int currentSaveNumber, int playerID, string currentSaveDataPath, bool showDebugInfo, bool savingGameToChangeScene)
|
|
{
|
|
getMainManager ();
|
|
|
|
if (mainElementOnSceneManager == null) {
|
|
return;
|
|
}
|
|
|
|
if (!mainElementOnSceneManager.isSaveCurrentPlayerElementsOnSceneToSaveFile ()) {
|
|
return;
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("Saving elements on scene");
|
|
}
|
|
|
|
bool saveLocated = false;
|
|
bool playerLocated = false;
|
|
|
|
int saveSlotIndex = -1;
|
|
int listIndex = -1;
|
|
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
FileStream file;
|
|
|
|
persistancePlayerElementOnSceneInfo elementsOnSceneToSave = getPersistanceList (playerID, showDebugInfo);
|
|
|
|
persistanceElementsOnSceneBySaveSlotInfo newPersistancePlayerElementsOnSceneListBySaveSlotInfo = new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
List<persistanceElementsOnSceneBySaveSlotInfo> infoListToSave = new List<persistanceElementsOnSceneBySaveSlotInfo> ();
|
|
|
|
if (File.Exists (currentSaveDataPath)) {
|
|
bf = new BinaryFormatter ();
|
|
file = File.Open (currentSaveDataPath, FileMode.Open);
|
|
object currentData = bf.Deserialize (file);
|
|
infoListToSave = currentData as List<persistanceElementsOnSceneBySaveSlotInfo>;
|
|
|
|
file.Close ();
|
|
}
|
|
|
|
int infoListToSaveCount = infoListToSave.Count;
|
|
|
|
for (int j = 0; j < infoListToSaveCount; j++) {
|
|
if (infoListToSave [j].saveNumber == currentSaveNumber) {
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo = infoListToSave [j];
|
|
saveLocated = true;
|
|
saveSlotIndex = j;
|
|
}
|
|
}
|
|
|
|
if (saveLocated) {
|
|
int playerElementsOnSceneListCount = newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Count;
|
|
|
|
for (int j = 0; j < playerElementsOnSceneListCount; j++) {
|
|
if (newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [j].playerID == elementsOnSceneToSave.playerID) {
|
|
playerLocated = true;
|
|
listIndex = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("EXTRA INFO\n");
|
|
print ("Number of elements on scene: " + elementsOnSceneToSave.elementOnSceneList.Count);
|
|
print ("Current Save Number " + currentSaveNumber);
|
|
print ("Save Located " + saveLocated);
|
|
print ("Player Located " + playerLocated);
|
|
print ("Player ID " + elementsOnSceneToSave.playerID);
|
|
|
|
print ("Scene Index " + menuPause.getCurrentActiveSceneIndex ());
|
|
}
|
|
|
|
int currentSceneIndex = menuPause.getCurrentActiveSceneIndex ();
|
|
|
|
//if the save is located, check if the player id exists
|
|
if (saveLocated) {
|
|
//if player id exists, overwrite it
|
|
if (playerLocated) {
|
|
int elementOnSceneListCount = infoListToSave [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.Count;
|
|
|
|
for (int i = elementOnSceneListCount - 1; i >= 0; i--) {
|
|
if (currentSceneIndex == infoListToSave [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList [i].elementScene) {
|
|
infoListToSave [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.RemoveAt (i);
|
|
}
|
|
}
|
|
|
|
infoListToSave [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.AddRange (elementsOnSceneToSave.elementOnSceneList);
|
|
} else {
|
|
infoListToSave [saveSlotIndex].playerElementsOnSceneList.Add (elementsOnSceneToSave);
|
|
}
|
|
} else {
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo.saveNumber = currentSaveNumber;
|
|
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Add (elementsOnSceneToSave);
|
|
|
|
infoListToSave.Add (newPersistancePlayerElementsOnSceneListBySaveSlotInfo);
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
for (int j = 0; j < elementsOnSceneToSave.elementOnSceneList.Count; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo = elementsOnSceneToSave.elementOnSceneList [j];
|
|
|
|
if (currentPersistanceElementsOnSceneInfo.elementScene == currentSceneIndex) {
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
}
|
|
|
|
bf = new BinaryFormatter ();
|
|
file = File.Open (currentSaveDataPath, FileMode.OpenOrCreate);
|
|
bf.Serialize (file, infoListToSave);
|
|
|
|
file.Close ();
|
|
|
|
if (saveInfoOnRegularTxtFile) {
|
|
writeDetailedDebugInfo (false, currentSaveDataPath);
|
|
}
|
|
}
|
|
|
|
public void loadGameContent (int saveNumberToLoad, int playerID, string currentSaveDataPath, bool showDebugInfo)
|
|
{
|
|
getMainManager ();
|
|
|
|
if (mainElementOnSceneManager == null) {
|
|
return;
|
|
}
|
|
|
|
if (!mainElementOnSceneManager.isSaveCurrentPlayerElementsOnSceneToSaveFile ()) {
|
|
initializeValues ();
|
|
|
|
return;
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("Loading elements on scene");
|
|
}
|
|
|
|
//need to store and check the current slot saved and the player which is saving, to get that concrete info
|
|
persistanceInfoList = new List<persistanceElementOnSceneInfo> ();
|
|
|
|
List<persistanceElementsOnSceneBySaveSlotInfo> infoListToLoad = new List<persistanceElementsOnSceneBySaveSlotInfo> ();
|
|
|
|
if (File.Exists (currentSaveDataPath)) {
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
FileStream file = File.Open (currentSaveDataPath, FileMode.Open);
|
|
object currentData = bf.Deserialize (file);
|
|
infoListToLoad = currentData as List<persistanceElementsOnSceneBySaveSlotInfo>;
|
|
|
|
file.Close ();
|
|
}
|
|
|
|
if (saveNumberToLoad > -1) {
|
|
persistanceElementsOnSceneBySaveSlotInfo newPersistancePlayerElementsOnSceneListBySaveSlotInfo = new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
int infoListToLoadCount = infoListToLoad.Count;
|
|
|
|
for (int j = 0; j < infoListToLoadCount; j++) {
|
|
|
|
if (infoListToLoad [j].saveNumber == saveNumberToLoad) {
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo = infoListToLoad [j];
|
|
}
|
|
}
|
|
|
|
int listIndex = -1;
|
|
|
|
int playerElementsOnSceneListCount = newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Count;
|
|
|
|
for (int j = 0; j < playerElementsOnSceneListCount; j++) {
|
|
|
|
if (newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [j].playerID == playerID) {
|
|
listIndex = j;
|
|
}
|
|
}
|
|
|
|
if (listIndex > -1) {
|
|
int currentSceneIndex = menuPause.getCurrentActiveSceneIndex ();
|
|
|
|
temporalPersistancePlayerElementOnSceneInfo = newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [listIndex];
|
|
|
|
int elementOnSceneListCount = temporalPersistancePlayerElementOnSceneInfo.elementOnSceneList.Count;
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("Total number of elements saved in game " + elementOnSceneListCount);
|
|
}
|
|
|
|
for (int j = 0; j < elementOnSceneListCount; j++) {
|
|
if (currentSceneIndex == temporalPersistancePlayerElementOnSceneInfo.elementOnSceneList [j].elementScene) {
|
|
persistanceInfoList.Add (temporalPersistancePlayerElementOnSceneInfo.elementOnSceneList [j]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("Elements Loaded in Save Number " + saveNumberToLoad);
|
|
print ("Number of Elements: " + persistanceInfoList.Count);
|
|
|
|
print ("Scene Index " + menuPause.getCurrentActiveSceneIndex ());
|
|
|
|
print ("\n\n");
|
|
|
|
for (int j = 0; j < persistanceInfoList.Count; j++) {
|
|
print ("\n\n");
|
|
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo = persistanceInfoList [j];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
showCurrentDebugInfo = showDebugInfo;
|
|
|
|
loadInfoOnMainComponent ();
|
|
|
|
if (saveInfoOnRegularTxtFile) {
|
|
writeDetailedDebugInfo (true, currentSaveDataPath);
|
|
}
|
|
}
|
|
|
|
public persistancePlayerElementOnSceneInfo getPersistanceList (int playerID, bool showDebugInfo)
|
|
{
|
|
persistancePlayerElementOnSceneInfo newElementsOnSceneList = new persistancePlayerElementOnSceneInfo ();
|
|
|
|
newElementsOnSceneList.playerID = playerID;
|
|
|
|
List<persistanceElementOnSceneInfo> newPersistanceElementsOnSceneInfoList = new List<persistanceElementOnSceneInfo> ();
|
|
|
|
mainElementOnSceneManager.checkForInstantiatedElementsOnSceneOnSave ();
|
|
|
|
List<elementOnScene> elementOnSceneList = mainElementOnSceneManager.elementOnSceneList;
|
|
|
|
int elementOnSceneListCount = elementOnSceneList.Count;
|
|
|
|
for (int k = 0; k < elementOnSceneListCount; k++) {
|
|
persistanceElementOnSceneInfo newPersistanceElementsOnSceneInfo = new persistanceElementOnSceneInfo ();
|
|
|
|
elementOnScene currentSlotInfo = elementOnSceneList [k];
|
|
|
|
if (currentSlotInfo != null && currentSlotInfo.isSaveElementEnabled ()) {
|
|
newPersistanceElementsOnSceneInfo.elementScene = currentSlotInfo.elementScene;
|
|
newPersistanceElementsOnSceneInfo.elementID = currentSlotInfo.elementID;
|
|
|
|
newPersistanceElementsOnSceneInfo.elementActiveState = currentSlotInfo.elementActiveState;
|
|
|
|
if (currentSlotInfo.useStats) {
|
|
|
|
currentSlotInfo.checkEventOnStatsSave ();
|
|
|
|
newPersistanceElementsOnSceneInfo.useStats = true;
|
|
|
|
for (int j = 0; j < currentSlotInfo.statInfoList.Count; j++) {
|
|
if (currentSlotInfo.statInfoList [j].statIsAmount) {
|
|
newPersistanceElementsOnSceneInfo.floatValueStatList.Add (currentSlotInfo.statInfoList [j].currentFloatValue);
|
|
} else {
|
|
newPersistanceElementsOnSceneInfo.boolValueStatList.Add (currentSlotInfo.statInfoList [j].currentBoolState);
|
|
}
|
|
}
|
|
}
|
|
|
|
newPersistanceElementsOnSceneInfo.savePositionValues = currentSlotInfo.savePositionValues;
|
|
|
|
Vector3 currentPosition = currentSlotInfo.getElementPosition ();
|
|
|
|
newPersistanceElementsOnSceneInfo.positionX = currentPosition.x;
|
|
newPersistanceElementsOnSceneInfo.positionY = currentPosition.y;
|
|
newPersistanceElementsOnSceneInfo.positionZ = currentPosition.z;
|
|
|
|
newPersistanceElementsOnSceneInfo.saveRotationValues = currentSlotInfo.saveRotationValues;
|
|
|
|
Vector3 currentRotation = currentSlotInfo.getElementRotation ();
|
|
|
|
newPersistanceElementsOnSceneInfo.rotationX = currentRotation.x;
|
|
newPersistanceElementsOnSceneInfo.rotationY = currentRotation.y;
|
|
newPersistanceElementsOnSceneInfo.rotationZ = currentRotation.z;
|
|
|
|
newPersistanceElementsOnSceneInfo.elementPrefabID = currentSlotInfo.elementPrefabID;
|
|
|
|
newPersistanceElementsOnSceneInfo.useElementPrefabID = currentSlotInfo.useElementPrefabID;
|
|
|
|
// if (showDebugInfo) {
|
|
// showDetailedDebugInfo (newPersistanceElementsOnSceneInfo);
|
|
// }
|
|
|
|
newPersistanceElementsOnSceneInfoList.Add (newPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
|
|
List<elementOnSceneManager.temporalElementOnSceneInfo> temporalElementOnSceneList = mainElementOnSceneManager.temporalElementOnSceneInfoList;
|
|
|
|
int temporalElementOnSceneListCount = temporalElementOnSceneList.Count;
|
|
|
|
for (int k = 0; k < temporalElementOnSceneListCount; k++) {
|
|
int elementIndex = getElementOnSceneIndex (newPersistanceElementsOnSceneInfoList, temporalElementOnSceneList [k].elementID,
|
|
temporalElementOnSceneList [k].elementScene);
|
|
|
|
if (elementIndex > -1) {
|
|
newPersistanceElementsOnSceneInfoList [elementIndex].elementActiveState = temporalElementOnSceneList [k].elementActiveState;
|
|
} else {
|
|
persistanceElementOnSceneInfo newPersistanceElementsOnSceneInfo = new persistanceElementOnSceneInfo ();
|
|
|
|
newPersistanceElementsOnSceneInfo.elementScene = temporalElementOnSceneList [k].elementScene;
|
|
newPersistanceElementsOnSceneInfo.elementID = temporalElementOnSceneList [k].elementID;
|
|
|
|
newPersistanceElementsOnSceneInfo.elementActiveState = temporalElementOnSceneList [k].elementActiveState;
|
|
|
|
newPersistanceElementsOnSceneInfo.useElementPrefabID = true;
|
|
|
|
newPersistanceElementsOnSceneInfoList.Add (newPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
newElementsOnSceneList.elementOnSceneList = newPersistanceElementsOnSceneInfoList;
|
|
|
|
return newElementsOnSceneList;
|
|
}
|
|
|
|
int getElementOnSceneIndex (List<persistanceElementOnSceneInfo> newPersistanceElementsOnSceneInfoList, int elementID, int elementScene)
|
|
{
|
|
int newPersistanceElementsOnSceneInfoListCount = newPersistanceElementsOnSceneInfoList.Count;
|
|
|
|
for (int j = 0; j < newPersistanceElementsOnSceneInfoListCount; j++) {
|
|
if (newPersistanceElementsOnSceneInfoList [j].elementID == elementID &&
|
|
newPersistanceElementsOnSceneInfoList [j].elementScene == elementScene) {
|
|
return j;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void loadInfoOnMainComponent ()
|
|
{
|
|
initializeValues ();
|
|
|
|
if (persistanceInfoList != null && persistanceInfoList.Count > 0) {
|
|
|
|
int persistanceInfoListCount = persistanceInfoList.Count;
|
|
|
|
for (int k = 0; k < persistanceInfoListCount; k++) {
|
|
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo = persistanceInfoList [k];
|
|
|
|
elementOnScene currentElementOnScene =
|
|
mainElementOnSceneManager.getElementOnSceneInfo (currentPersistanceElementsOnSceneInfo.elementID, currentPersistanceElementsOnSceneInfo.elementScene);
|
|
|
|
if (currentElementOnScene == null) {
|
|
if (mainElementOnSceneManager.useElementsOnSceneData) {
|
|
if (currentPersistanceElementsOnSceneInfo.useElementPrefabID) {
|
|
if (currentPersistanceElementsOnSceneInfo.elementActiveState) {
|
|
int elementPrefabID = currentPersistanceElementsOnSceneInfo.elementPrefabID;
|
|
|
|
GameObject elementPrefab = mainElementOnSceneManager.mainElementsOnSceneData.getElementScenePrefabById (elementPrefabID);
|
|
|
|
if (elementPrefab != null) {
|
|
GameObject newObject = Instantiate (elementPrefab);
|
|
|
|
newObject.name = elementPrefab.name;
|
|
|
|
currentElementOnScene = newObject.GetComponentInChildren<elementOnScene> ();
|
|
|
|
currentElementOnScene.saveElementEnabled = true;
|
|
|
|
mainElementOnSceneManager.setNewInstantiatedElementOnSceneManagerIngameWithInfo (currentElementOnScene);
|
|
|
|
if (showCurrentDebugInfo) {
|
|
print ("INSTANTIATING ELEMENT ON SCENE FROM PREFAB " + newObject.name + " " + currentElementOnScene.elementID);
|
|
}
|
|
} else {
|
|
if (showCurrentDebugInfo) {
|
|
print ("INSTANTIATING ERROR ON ELEMENT ON SCENE FROM PREFAB ID" + elementPrefabID);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showCurrentDebugInfo) {
|
|
if (currentElementOnScene != null) {
|
|
print ("Element On Scene found " + currentElementOnScene.elementID);
|
|
} else {
|
|
print ("Element On Scene Not Found");
|
|
}
|
|
}
|
|
|
|
if (currentElementOnScene != null) {
|
|
if (showCurrentDebugInfo) {
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
|
|
if (currentElementOnScene.saveElementEnabled) {
|
|
if (currentElementOnScene.savePositionValues) {
|
|
Vector3 newPosition = new Vector3 (currentPersistanceElementsOnSceneInfo.positionX,
|
|
currentPersistanceElementsOnSceneInfo.positionY,
|
|
currentPersistanceElementsOnSceneInfo.positionZ);
|
|
|
|
currentElementOnScene.setNewPositionValues (newPosition);
|
|
}
|
|
|
|
if (currentElementOnScene.saveRotationValues) {
|
|
Vector3 newRotation = new Vector3 (currentPersistanceElementsOnSceneInfo.rotationX,
|
|
currentPersistanceElementsOnSceneInfo.rotationY,
|
|
currentPersistanceElementsOnSceneInfo.rotationZ);
|
|
|
|
currentElementOnScene.setNewRotationValues (newRotation);
|
|
}
|
|
|
|
currentElementOnScene.setElementActiveState (currentPersistanceElementsOnSceneInfo.elementActiveState);
|
|
|
|
currentElementOnScene.checkStateOnLoad ();
|
|
|
|
if (currentPersistanceElementsOnSceneInfo.elementActiveState) {
|
|
bool canCheckStats = true;
|
|
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectIDList) {
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectIDListInfo.Contains (currentElementOnScene.elementID)) {
|
|
canCheckStats = false;
|
|
}
|
|
}
|
|
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectPrefabIDList) {
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectPrefabIDListInfo.Contains (currentElementOnScene.elementPrefabID)) {
|
|
canCheckStats = false;
|
|
}
|
|
}
|
|
|
|
if (currentElementOnScene.useStats && canCheckStats) {
|
|
int boolValueStatListCount = 0;
|
|
int floatValueStatListCount = 0;
|
|
|
|
for (int j = 0; j < currentElementOnScene.statInfoList.Count; j++) {
|
|
if (currentElementOnScene.statInfoList [j].statIsAmount) {
|
|
if (floatValueStatListCount < currentPersistanceElementsOnSceneInfo.floatValueStatList.Count) {
|
|
currentElementOnScene.statInfoList [j].currentFloatValue = currentPersistanceElementsOnSceneInfo.floatValueStatList [floatValueStatListCount];
|
|
}
|
|
|
|
floatValueStatListCount++;
|
|
} else {
|
|
if (boolValueStatListCount < currentPersistanceElementsOnSceneInfo.boolValueStatList.Count) {
|
|
currentElementOnScene.statInfoList [j].currentBoolState = currentPersistanceElementsOnSceneInfo.boolValueStatList [boolValueStatListCount];
|
|
}
|
|
|
|
boolValueStatListCount++;
|
|
}
|
|
}
|
|
|
|
currentElementOnScene.setStatsOnLoad ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void getMainManager ()
|
|
{
|
|
if (mainElementOnSceneManager == null) {
|
|
mainElementOnSceneManager = elementOnSceneManager.Instance;
|
|
|
|
bool mainElementOnSceneManagerLocated = mainElementOnSceneManager != null;
|
|
|
|
if (!mainElementOnSceneManagerLocated) {
|
|
GKC_Utils.instantiateMainManagerOnSceneWithTypeOnApplicationPlaying (elementOnSceneManager.getMainManagerName (), typeof (elementOnSceneManager), true);
|
|
|
|
mainElementOnSceneManager = elementOnSceneManager.Instance;
|
|
|
|
mainElementOnSceneManagerLocated = mainElementOnSceneManager != null;
|
|
}
|
|
|
|
if (!mainElementOnSceneManagerLocated) {
|
|
|
|
mainElementOnSceneManager = FindObjectOfType<elementOnSceneManager> ();
|
|
}
|
|
}
|
|
}
|
|
|
|
void initializeValues ()
|
|
{
|
|
getMainManager ();
|
|
|
|
if (mainElementOnSceneManager != null) {
|
|
mainElementOnSceneManager.initializeValues ();
|
|
}
|
|
}
|
|
|
|
public void setStatsSearchingByInfo (int currentElementScene, int currentElementID, elementOnScene currentElementOnScene)
|
|
{
|
|
if (temporalPersistancePlayerElementOnSceneInfo != null) {
|
|
print ("searching stats on " + currentElementScene + " " + currentElementID + " " + currentElementOnScene.gameObject.name);
|
|
|
|
int elementOnSceneListCount = temporalPersistancePlayerElementOnSceneInfo.elementOnSceneList.Count;
|
|
|
|
for (int k = 0; k < elementOnSceneListCount; k++) {
|
|
if (currentElementScene == temporalPersistancePlayerElementOnSceneInfo.elementOnSceneList [k].elementScene) {
|
|
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo = temporalPersistancePlayerElementOnSceneInfo.elementOnSceneList [k];
|
|
|
|
if (currentPersistanceElementsOnSceneInfo.elementScene == currentElementScene && currentPersistanceElementsOnSceneInfo.elementID == currentElementID) {
|
|
bool canCheckStats = true;
|
|
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectIDList) {
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectIDListInfo.Contains (currentElementOnScene.elementID)) {
|
|
canCheckStats = false;
|
|
}
|
|
}
|
|
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectPrefabIDList) {
|
|
if (mainElementOnSceneManager.ignoreLoadStatsOnObjectPrefabIDListInfo.Contains (currentElementOnScene.elementPrefabID)) {
|
|
canCheckStats = false;
|
|
}
|
|
}
|
|
|
|
if (currentElementOnScene.useStats && canCheckStats) {
|
|
int boolValueStatListCount = 0;
|
|
int floatValueStatListCount = 0;
|
|
|
|
for (int j = 0; j < currentElementOnScene.statInfoList.Count; j++) {
|
|
if (currentElementOnScene.statInfoList [j].statIsAmount) {
|
|
currentElementOnScene.statInfoList [j].currentFloatValue = currentPersistanceElementsOnSceneInfo.floatValueStatList [floatValueStatListCount];
|
|
|
|
floatValueStatListCount++;
|
|
} else {
|
|
currentElementOnScene.statInfoList [j].currentBoolState = currentPersistanceElementsOnSceneInfo.boolValueStatList [boolValueStatListCount];
|
|
|
|
boolValueStatListCount++;
|
|
}
|
|
}
|
|
|
|
currentElementOnScene.setStatsOnLoad ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void deleteGameInfo (int saveNumberToDelete, int playerID, string currentSaveDataPath, bool showDebugInfo)
|
|
{
|
|
getMainManager ();
|
|
|
|
if (mainElementOnSceneManager == null) {
|
|
return;
|
|
}
|
|
|
|
if (!mainElementOnSceneManager.isSaveCurrentPlayerElementsOnSceneToSaveFile ()) {
|
|
initializeValues ();
|
|
|
|
return;
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("Deleting elements on scene");
|
|
}
|
|
|
|
List<persistanceElementsOnSceneBySaveSlotInfo> infoListToLoad = new List<persistanceElementsOnSceneBySaveSlotInfo> ();
|
|
|
|
persistanceElementsOnSceneBySaveSlotInfo newPersistancePlayerElementsOnSceneListBySaveSlotInfo = new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
bool saveLocated = false;
|
|
bool playerLocated = false;
|
|
|
|
int saveSlotIndex = -1;
|
|
int listIndex = -1;
|
|
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
FileStream file;
|
|
|
|
if (File.Exists (currentSaveDataPath)) {
|
|
file = File.Open (currentSaveDataPath, FileMode.Open);
|
|
object currentData = bf.Deserialize (file);
|
|
infoListToLoad = currentData as List<persistanceElementsOnSceneBySaveSlotInfo>;
|
|
|
|
file.Close ();
|
|
}
|
|
|
|
int infoListToLoadCount = infoListToLoad.Count;
|
|
|
|
if (showDebugInfo) {
|
|
print ("info list to load amount " + infoListToLoadCount);
|
|
}
|
|
|
|
for (int j = 0; j < infoListToLoadCount; j++) {
|
|
if (showDebugInfo) {
|
|
print ("checking save number " + infoListToLoad [j].saveNumber);
|
|
}
|
|
|
|
if (infoListToLoad [j].saveNumber == saveNumberToDelete) {
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo = infoListToLoad [j];
|
|
saveLocated = true;
|
|
saveSlotIndex = j;
|
|
}
|
|
}
|
|
|
|
if (saveLocated) {
|
|
int playerElementsOnSceneListCount = newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Count;
|
|
|
|
for (int j = 0; j < playerElementsOnSceneListCount; j++) {
|
|
|
|
if (newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [j].playerID == playerID) {
|
|
playerLocated = true;
|
|
listIndex = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print (saveLocated + " " + playerLocated + " " + playerID + " " + saveNumberToDelete);
|
|
}
|
|
|
|
//if the save is located, check if the player id exists
|
|
if (saveLocated) {
|
|
//if player id exists, overwrite it
|
|
if (playerLocated) {
|
|
|
|
if (showDebugInfo) {
|
|
print ("number of elements " +
|
|
infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.Count);
|
|
|
|
print ("\n\n");
|
|
|
|
int elementOnSceneListCount = infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.Count;
|
|
|
|
for (int j = 0; j < elementOnSceneListCount; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList [j];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.Clear ();
|
|
|
|
bf = new BinaryFormatter ();
|
|
file = File.Open (currentSaveDataPath, FileMode.OpenOrCreate);
|
|
bf.Serialize (file, infoListToLoad);
|
|
|
|
file.Close ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void copyGameInfo (int saveNumberToStoreDuplicate, int saveNumberToDuplicate,
|
|
int playerID, string currentSaveDataPath, bool copyAllInfoWithoutChecks, bool showDebugInfo)
|
|
{
|
|
//showDebugInfo = true;
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("sending signal to copy game info from one slot to another ");
|
|
|
|
print ("copying from save number " + saveNumberToDuplicate + " to " + saveNumberToStoreDuplicate);
|
|
|
|
print ("copyAllInfoWithoutChecks value " + copyAllInfoWithoutChecks);
|
|
}
|
|
|
|
getMainManager ();
|
|
|
|
if (mainElementOnSceneManager == null) {
|
|
return;
|
|
}
|
|
|
|
if (!mainElementOnSceneManager.isSaveCurrentPlayerElementsOnSceneToSaveFile ()) {
|
|
initializeValues ();
|
|
|
|
return;
|
|
}
|
|
|
|
List<persistanceElementsOnSceneBySaveSlotInfo> infoListToLoad = new List<persistanceElementsOnSceneBySaveSlotInfo> ();
|
|
|
|
persistanceElementsOnSceneBySaveSlotInfo persistanceSaveInfoToDuplicate = new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
persistanceElementsOnSceneBySaveSlotInfo persistanceSaveInfoToStoreDuplicate = new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
int currentSceneIndex = menuPause.getCurrentActiveSceneIndex ();
|
|
|
|
bool playerLocatedToDuplicate = false;
|
|
bool playerLocatedToStoreDuplicate = false;
|
|
|
|
int saveSlotIndexToDuplicate = -1;
|
|
int saveSlotIndexToStoreDuplicate = -1;
|
|
|
|
int listIndexToDuplicate = -1;
|
|
int listIndexToStoreDuplicate = -1;
|
|
|
|
|
|
bool saveToDuplicateFound = false;
|
|
bool saveToStoreDuplicateFound = false;
|
|
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
FileStream file;
|
|
|
|
if (File.Exists (currentSaveDataPath)) {
|
|
file = File.Open (currentSaveDataPath, FileMode.Open);
|
|
object currentData = bf.Deserialize (file);
|
|
infoListToLoad = currentData as List<persistanceElementsOnSceneBySaveSlotInfo>;
|
|
|
|
file.Close ();
|
|
}
|
|
|
|
int infoListToLoadCount = infoListToLoad.Count;
|
|
|
|
if (showDebugInfo) {
|
|
print ("info list to load amount " + infoListToLoadCount);
|
|
}
|
|
|
|
for (int j = 0; j < infoListToLoadCount; j++) {
|
|
if (infoListToLoad [j].saveNumber == saveNumberToDuplicate) {
|
|
persistanceSaveInfoToDuplicate = infoListToLoad [j];
|
|
|
|
saveSlotIndexToDuplicate = j;
|
|
|
|
saveToDuplicateFound = true;
|
|
}
|
|
|
|
if (infoListToLoad [j].saveNumber == saveNumberToStoreDuplicate) {
|
|
persistanceSaveInfoToStoreDuplicate = infoListToLoad [j];
|
|
|
|
saveSlotIndexToStoreDuplicate = j;
|
|
|
|
saveToStoreDuplicateFound = true;
|
|
}
|
|
}
|
|
|
|
if (saveToStoreDuplicateFound) {
|
|
int playerElementsOnSceneListCount = persistanceSaveInfoToStoreDuplicate.playerElementsOnSceneList.Count;
|
|
|
|
for (int j = 0; j < playerElementsOnSceneListCount; j++) {
|
|
if (persistanceSaveInfoToStoreDuplicate.playerElementsOnSceneList [j].playerID == playerID) {
|
|
playerLocatedToStoreDuplicate = true;
|
|
|
|
listIndexToStoreDuplicate = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (saveToDuplicateFound) {
|
|
int playerElementsOnSceneListCount = persistanceSaveInfoToDuplicate.playerElementsOnSceneList.Count;
|
|
|
|
for (int j = 0; j < playerElementsOnSceneListCount; j++) {
|
|
if (persistanceSaveInfoToDuplicate.playerElementsOnSceneList [j].playerID == playerID) {
|
|
playerLocatedToDuplicate = true;
|
|
|
|
listIndexToDuplicate = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print (saveToStoreDuplicateFound + " " + playerLocatedToStoreDuplicate + " " + playerID + " " + saveNumberToStoreDuplicate);
|
|
|
|
print (saveToDuplicateFound + " " + playerLocatedToDuplicate + " " + playerID + " " + saveNumberToDuplicate);
|
|
}
|
|
|
|
//if the save is located, check if the player id exists
|
|
if (saveToStoreDuplicateFound && saveToDuplicateFound) {
|
|
//if player id exists, overwrite it
|
|
if (playerLocatedToStoreDuplicate && playerLocatedToDuplicate) {
|
|
|
|
List<persistanceElementOnSceneInfo> elementOnSceneListToStoreDuplicate =
|
|
infoListToLoad [saveSlotIndexToStoreDuplicate].playerElementsOnSceneList [listIndexToStoreDuplicate].elementOnSceneList;
|
|
|
|
if (showDebugInfo) {
|
|
print ("number of elements on list to store duplicated " + elementOnSceneListToStoreDuplicate.Count);
|
|
}
|
|
|
|
List<persistanceElementOnSceneInfo> elementOnSceneListToDuplicate =
|
|
infoListToLoad [saveSlotIndexToDuplicate].playerElementsOnSceneList [listIndexToDuplicate].elementOnSceneList;
|
|
|
|
if (showDebugInfo) {
|
|
print ("number of elements on list to duplicate " + elementOnSceneListToDuplicate.Count);
|
|
}
|
|
|
|
//if the option to copy the list from one save slot to another is active, just override the list
|
|
//of the one to store with the list to duplicate
|
|
|
|
//this is used when loading the game, to copy the info from the loaded slot to the temporal save used
|
|
//to auto save and load in between scenes
|
|
if (copyAllInfoWithoutChecks) {
|
|
if (showDebugInfo) {
|
|
int elementOnSceneListToDuplicateCount = elementOnSceneListToDuplicate.Count;
|
|
|
|
print ("\n\n");
|
|
print ("FINAL LIST COUNT " + elementOnSceneListToDuplicateCount);
|
|
print ("\n\n");
|
|
|
|
for (int j = 0; j < elementOnSceneListToDuplicateCount; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
elementOnSceneListToDuplicate [j];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
|
|
print ("\n\n");
|
|
print ("save number where duplicate is stored " + infoListToLoad [saveSlotIndexToStoreDuplicate].saveNumber);
|
|
}
|
|
|
|
infoListToLoad [saveSlotIndexToStoreDuplicate].playerElementsOnSceneList [listIndexToStoreDuplicate].elementOnSceneList =
|
|
elementOnSceneListToDuplicate;
|
|
} else {
|
|
List<persistanceElementOnSceneInfo> newList = new List<persistanceElementOnSceneInfo> ();
|
|
|
|
|
|
int elementOnSceneListToStoreDuplicateCount = elementOnSceneListToStoreDuplicate.Count;
|
|
|
|
//for (int j = 0; j < elementOnSceneListToStoreDuplicateCount; j++) {
|
|
// persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
// elementOnSceneListToStoreDuplicate [j];
|
|
|
|
// showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
//}
|
|
|
|
int elementOnSceneListToDuplicateCount = elementOnSceneListToDuplicate.Count;
|
|
|
|
for (int j = 0; j < elementOnSceneListToDuplicateCount; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
elementOnSceneListToDuplicate [j];
|
|
|
|
//showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
|
|
if (currentPersistanceElementsOnSceneInfo.elementScene != currentSceneIndex) {
|
|
newList.Add (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
|
|
print ("new list to add count " + newList.Count);
|
|
}
|
|
|
|
//we have now the list of elements stored from other scenes that are not the current scene
|
|
//where the manual save has been made, so from those, we need to compare that list
|
|
//with the list of elements from the current save to store, and remove the elements
|
|
//from the save to store which match on the same scene and id of the new list to add
|
|
//that avoids duplicates and adds the elements info up to date
|
|
|
|
//if the new list is empty, it means it has no info about elements, so the copy is cancelled
|
|
|
|
if (newList.Count > 0) {
|
|
List<persistanceElementOnSceneInfo> matchingItems =
|
|
elementOnSceneListToStoreDuplicate.Where (item1 =>
|
|
newList.Any (item2 => item1.elementScene == item2.elementScene &&
|
|
item1.elementID == item2.elementID)).ToList ();
|
|
|
|
elementOnSceneListToStoreDuplicate = elementOnSceneListToStoreDuplicate.Except (matchingItems).ToList ();
|
|
|
|
elementOnSceneListToStoreDuplicate.AddRange (newList);
|
|
|
|
elementOnSceneListToStoreDuplicateCount = elementOnSceneListToStoreDuplicate.Count;
|
|
|
|
if (showDebugInfo) {
|
|
print ("\n\n");
|
|
print ("FINAL LIST COUNT " + elementOnSceneListToStoreDuplicateCount);
|
|
print ("\n\n");
|
|
|
|
for (int j = 0; j < elementOnSceneListToStoreDuplicateCount; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
elementOnSceneListToStoreDuplicate [j];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
infoListToLoad [saveSlotIndexToStoreDuplicate].playerElementsOnSceneList [listIndexToStoreDuplicate].elementOnSceneList = elementOnSceneListToStoreDuplicate;
|
|
}
|
|
}
|
|
|
|
bf = new BinaryFormatter ();
|
|
file = File.Open (currentSaveDataPath, FileMode.OpenOrCreate);
|
|
bf.Serialize (file, infoListToLoad);
|
|
|
|
file.Close ();
|
|
}
|
|
} else {
|
|
if (saveToDuplicateFound) {
|
|
if (copyAllInfoWithoutChecks) {
|
|
//if the option to copy all the list is active and only the list to copy was found,
|
|
//add the info for the list to store as new
|
|
|
|
|
|
persistanceElementsOnSceneBySaveSlotInfo newPersistancePlayerElementsOnSceneListBySaveSlotInfo
|
|
= new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo.saveNumber = saveNumberToStoreDuplicate;
|
|
|
|
persistancePlayerElementOnSceneInfo newPersistancePlayerElementOnSceneInfo = new persistancePlayerElementOnSceneInfo ();
|
|
|
|
newPersistancePlayerElementOnSceneInfo.playerID = playerID;
|
|
|
|
newPersistancePlayerElementOnSceneInfo.elementOnSceneList =
|
|
infoListToLoad [saveSlotIndexToDuplicate].playerElementsOnSceneList [listIndexToDuplicate].elementOnSceneList;
|
|
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Add (newPersistancePlayerElementOnSceneInfo);
|
|
|
|
infoListToLoad.Add (newPersistancePlayerElementsOnSceneListBySaveSlotInfo);
|
|
|
|
if (showDebugInfo) {
|
|
List<persistanceElementOnSceneInfo> elementOnSceneListToDuplicate =
|
|
newPersistancePlayerElementOnSceneInfo.elementOnSceneList;
|
|
|
|
int elementOnSceneListToDuplicateCount = elementOnSceneListToDuplicate.Count;
|
|
|
|
print ("\n\n");
|
|
print ("FINAL LIST COUNT " + elementOnSceneListToDuplicateCount);
|
|
print ("\n\n");
|
|
|
|
for (int j = 0; j < elementOnSceneListToDuplicateCount; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
elementOnSceneListToDuplicate [j];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
|
|
print ("\n\n");
|
|
print ("save number where duplicate is stored " + newPersistancePlayerElementsOnSceneListBySaveSlotInfo.saveNumber);
|
|
|
|
}
|
|
|
|
bf = new BinaryFormatter ();
|
|
file = File.Open (currentSaveDataPath, FileMode.OpenOrCreate);
|
|
bf.Serialize (file, infoListToLoad);
|
|
|
|
file.Close ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void showSaveInfoDebug (int saveNumberToShow, int playerID, string currentSaveDataPath,
|
|
bool showAllGameInfo, bool showDebugInfo)
|
|
{
|
|
getMainManager ();
|
|
|
|
if (mainElementOnSceneManager == null) {
|
|
return;
|
|
}
|
|
|
|
if (!mainElementOnSceneManager.isSaveCurrentPlayerElementsOnSceneToSaveFile ()) {
|
|
initializeValues ();
|
|
|
|
return;
|
|
}
|
|
|
|
print ("\n\n");
|
|
|
|
List<persistanceElementsOnSceneBySaveSlotInfo> infoListToLoad = new List<persistanceElementsOnSceneBySaveSlotInfo> ();
|
|
|
|
persistanceElementsOnSceneBySaveSlotInfo newPersistancePlayerElementsOnSceneListBySaveSlotInfo = new persistanceElementsOnSceneBySaveSlotInfo ();
|
|
|
|
bool saveLocated = false;
|
|
bool playerLocated = false;
|
|
|
|
int saveSlotIndex = -1;
|
|
int listIndex = -1;
|
|
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
FileStream file;
|
|
|
|
if (File.Exists (currentSaveDataPath)) {
|
|
file = File.Open (currentSaveDataPath, FileMode.Open);
|
|
object currentData = bf.Deserialize (file);
|
|
infoListToLoad = currentData as List<persistanceElementsOnSceneBySaveSlotInfo>;
|
|
|
|
file.Close ();
|
|
}
|
|
|
|
int infoListToLoadCount = infoListToLoad.Count;
|
|
|
|
print ("ELEMENTS ON SCENE SAVE INFO");
|
|
|
|
print ("Info List To Load amount " + infoListToLoadCount);
|
|
|
|
print ("\n\n");
|
|
|
|
if (showAllGameInfo) {
|
|
for (int i = 0; i < infoListToLoadCount; i++) {
|
|
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo = infoListToLoad [i];
|
|
|
|
print ("#####################################################################\n\n");
|
|
|
|
print ("SAVE NUMBER " + newPersistancePlayerElementsOnSceneListBySaveSlotInfo.saveNumber);
|
|
|
|
int playerElementsOnSceneList =
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Count;
|
|
|
|
for (int j = 0; j < playerElementsOnSceneList; j++) {
|
|
persistancePlayerElementOnSceneInfo currentPersistancePlayerElementOnSceneInfo =
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [j];
|
|
|
|
print ("Player ID " + currentPersistancePlayerElementOnSceneInfo.playerID);
|
|
|
|
int elementOnSceneListCount = currentPersistancePlayerElementOnSceneInfo.elementOnSceneList.Count;
|
|
|
|
print ("Number of Elements on Scene " + elementOnSceneListCount);
|
|
|
|
print ("\n\n");
|
|
|
|
for (int k = 0; k < elementOnSceneListCount; k++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
currentPersistancePlayerElementOnSceneInfo.elementOnSceneList [k];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
|
|
print ("\n\n\n");
|
|
}
|
|
} else {
|
|
for (int j = 0; j < infoListToLoadCount; j++) {
|
|
print (infoListToLoad [j].saveNumber);
|
|
|
|
if (infoListToLoad [j].saveNumber == saveNumberToShow) {
|
|
newPersistancePlayerElementsOnSceneListBySaveSlotInfo = infoListToLoad [j];
|
|
saveLocated = true;
|
|
saveSlotIndex = j;
|
|
}
|
|
}
|
|
|
|
if (saveLocated) {
|
|
int playerElementsOnSceneListCount = newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList.Count;
|
|
|
|
print ("\n\n");
|
|
|
|
for (int j = 0; j < playerElementsOnSceneListCount; j++) {
|
|
|
|
print (newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [j].playerID);
|
|
|
|
if (newPersistancePlayerElementsOnSceneListBySaveSlotInfo.playerElementsOnSceneList [j].playerID == playerID) {
|
|
playerLocated = true;
|
|
listIndex = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
print (saveLocated + " " + playerLocated + " " + playerID + " " + saveNumberToShow);
|
|
|
|
//if the save is located, check if the player id exists
|
|
if (saveLocated) {
|
|
//if player id exists, overwrite it
|
|
if (playerLocated) {
|
|
print ("#####################################################################\n\n");
|
|
|
|
print ("SAVE NUMBER " + infoListToLoad [saveSlotIndex].saveNumber);
|
|
|
|
print ("Number of Elements on Scene " + infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.Count);
|
|
|
|
print ("\n\n");
|
|
|
|
int elementOnSceneListCount = infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList.Count;
|
|
|
|
for (int j = 0; j < elementOnSceneListCount; j++) {
|
|
persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo =
|
|
infoListToLoad [saveSlotIndex].playerElementsOnSceneList [listIndex].elementOnSceneList [j];
|
|
|
|
showDetailedDebugInfo (currentPersistanceElementsOnSceneInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void showDetailedDebugInfo (persistanceElementOnSceneInfo currentPersistanceElementsOnSceneInfo)
|
|
{
|
|
print ("Element Scene " + currentPersistanceElementsOnSceneInfo.elementScene);
|
|
print ("Element ID " + currentPersistanceElementsOnSceneInfo.elementID);
|
|
print ("Element Active State " + currentPersistanceElementsOnSceneInfo.elementActiveState);
|
|
|
|
print ("Element Save Position Values " + currentPersistanceElementsOnSceneInfo.savePositionValues);
|
|
print ("Element Position X-Y-Z " + currentPersistanceElementsOnSceneInfo.positionX + " " +
|
|
currentPersistanceElementsOnSceneInfo.positionY + " " +
|
|
currentPersistanceElementsOnSceneInfo.positionZ);
|
|
|
|
print ("Element Save Rotation Values " + currentPersistanceElementsOnSceneInfo.saveRotationValues);
|
|
|
|
print ("Element Rotation X-Y-Z " + currentPersistanceElementsOnSceneInfo.rotationX + " " +
|
|
currentPersistanceElementsOnSceneInfo.rotationY + " " +
|
|
currentPersistanceElementsOnSceneInfo.rotationZ);
|
|
|
|
print ("Element Prefab ID " + currentPersistanceElementsOnSceneInfo.elementPrefabID);
|
|
|
|
print ("\n\n");
|
|
}
|
|
|
|
void writeDetailedDebugInfo (bool loadingFile, string currentSaveDataPath)
|
|
{
|
|
|
|
}
|
|
} |