private void Start()
{
LevelSaveData levelSaveData = SaveSystem.LoadProgress();
if (levelSaveData.firstGameStart)
{
levelSaveData.levelStates = new LevelState[levelChoseButtons.Count];
levelSaveData.levelStates[0] = LevelState.Open;
for (int i = 1; i < levelSaveData.levelStates.Length; i++)
{
levelSaveData.levelStates[i] = LevelState.Blocked;
}
levelSaveData.firstGameStart = false;
SaveSystem.SaveProgress(levelSaveData);
}
for (int i = 0; i < levelSaveData.levelStates.Length; i++)
{
if (levelSaveData.levelStates[i] == LevelState.Open)
{
levelChoseButtons[i].interactable = true;
}
else if (levelSaveData.levelStates[i] == LevelState.Blocked)
{
levelChoseButtons[i].interactable = false;
}
else if (levelSaveData.levelStates[i] == LevelState.Finished)
{
levelChoseButtons[i].interactable = true;
}
}
}
protected override void Execute()
{
string previousLevelName = levelNameStatus.Name;
bool levelWasRenamed = !string.IsNullOrEmpty(previousLevelName) && newLevelName != previousLevelName;
if (levelWasRenamed)
{
string oldLevelFileName = StringHelper.ConvertToXMLCompatible(previousLevelName);
if (File.Exists(LevelDataPath.Path + oldLevelFileName))
{
File.Delete(LevelDataPath.Path + oldLevelFileName);
}
}
List <LevelObjectSaveData> levelObjectsSaveData = ExtractLevelObjectsSaveData();
List <Vector2> standardTilePositions = TileGrid.Instance.GetGridPositionsByTileType(TileType.Standard);
List <Vector2> tileGridPositions = TileGrid.Instance.GetTileGridPositions();
List <Vector2> nonStandardTileGridPositions = tileGridPositions.Except(standardTilePositions).ToList();
List <TileSaveData> nonStandardTileSaveData = ExtractTilesSaveData(nonStandardTileGridPositions);
LevelSaveData levelData = new LevelSaveData {
StandardTileGridPositions = standardTilePositions,
NonStandardTilesSaveData = nonStandardTileSaveData,
LevelObjectsSaveData = levelObjectsSaveData,
};
string levelFileName = StringHelper.ConvertToXMLCompatible(newLevelName);
SerializeHelper.Serialize(LevelDataPath.Path + levelFileName, levelData);
}
public static void SaveLevelData(GameLevel level)
{
GlobalSaveData globalSaveData = GameManager.instance.globalSaveData;
//look for a matching data piece in the level list
LevelSaveData data = globalSaveData.levelSaveData.Where(obj => obj.dataName == level.levelName).SingleOrDefault();
if (data != null)
{
//update global level save data again
data.damageSustainedOnLevel = globalSaveData.damageSustainedOnLevel;
data.earnedQuickTeacup = globalSaveData.currentLevelSaveData.earnedQuickTeacup;
data.earnedSafeTeacup = globalSaveData.currentLevelSaveData.earnedSafeTeacup;
data.timeLeftOnLevel = globalSaveData.timeLeftOnLevel;
}
else
{
//create a new one
LevelSaveData newData = new LevelSaveData();
newData.dataName = level.levelName;
newData.damageSustainedOnLevel = globalSaveData.damageSustainedOnLevel;
newData.teacupsEarnedOnLevel = globalSaveData.currentLevelSaveData.teacupsEarnedOnLevel;
newData.earnedQuickTeacup = globalSaveData.currentLevelSaveData.earnedQuickTeacup;
newData.earnedSafeTeacup = globalSaveData.currentLevelSaveData.earnedSafeTeacup;
newData.timeLeftOnLevel = globalSaveData.timeLeftOnLevel;
globalSaveData.levelSaveData.Add(newData);
}
}
bool InitFromSaveFile()
{
if (File.Exists(savePath))
{
Debug.Log("Loading save from : " + savePath);
string jsonStr = File.ReadAllText(savePath);
Debug.Log("Reading save file: " + jsonStr);
JsonUtility.FromJsonOverwrite(jsonStr, this);
foreach (var kvp in savedLevelsData)
{
string id = kvp.Key;
LevelSaveData saveData = kvp.Value;
var levelProgress = FindLevelProgress(id);
if (levelProgress != null)
{
levelProgress.LoadFromSave(saveData);
}
}
return(true);
}
return(false);
}
/// <summary>
/// When given new LevelSaveData add it to 'level' list and save to file
/// </summary>
/// <param name="path"></param>
/// <param name="lsd"></param>
public bool Save(string path, LevelSaveData lsd)
{
try
{
bool found = false;
//Find if level is already in list, if it is has overwrite it.
for (int i = 0; i < this.levels.Count; i++)
{
if (levels[i].index == lsd.index)
{
levels[i].Overwrite(lsd);
found = true;
break;
}
}
//If level is not in list add it
if (!found)
{
levels.Add(lsd);
}
return(Save(path));
}
catch (Exception ex)
{
Debug.LogError("Could not save file at: " + path + "\nException: " + ex.Message);
return(false);
}
}
public static LevelSaveData LoadLevelData(string levelName)
{
LevelSaveData saveData = null;
string dataPath = Application.persistentDataPath + folderName + levelName + FileExtension;
//make sure the file actually exists
if (File.Exists(dataPath))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = File.Open(dataPath, FileMode.Open);
try
{
saveData = (LevelSaveData)binaryFormatter.Deserialize(fileStream);
}
catch (System.Exception e)
{
PlatformSafeMessage("Level Deserialization Failed: " + e.Message);
}
finally
{
//always close the fileStream
fileStream.Close();
}
}
return(saveData);
}
//--------------------------------------------------------------------------------------------------
//-- LOAD
//--------------------------------------------------------------------------------------------------
public void Load()
{
if (File.Exists(path))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(path, FileMode.Open);
lastSaveData = (GameSaveData)bf.Deserialize(file);
file.Close();
Debug.Log("Current Level:" + lastSaveData.currentLevel);
string level = SceneManager.GetActiveScene().name;
LevelSaveData levelData = lastSaveData.GetLevelDataFor(level);
if (levelData == null)
{
Debug.Log("Level Data null");
}
else
{
Debug.Log("Level Data found!");
ActivateSavePoints(levelData);
DeleteCollectables(levelData);
SetSpawnPosition(levelData);
SkipCutScenes(levelData);
}
}
}
protected override void Execute()
{
string levelFileName = StringHelper.ConvertToXMLCompatible(levelNameStatus.Name);
LevelSaveData levelSaveData = SerializeHelper.Deserialize <LevelSaveData>(LevelDataPath.Path + levelFileName);
deserializedLevelSaveDataStatus.LevelSaveData = levelSaveData;
}
public static LevelSaveData Load(string name)
{
string fullPath;
LevelSaveData levelSaveData = new LevelSaveData();
if (name != "tutorial" && name != "zoo" && name != "parkour")
{
fullPath = Application.persistentDataPath + directory + name + ".txt";
if (File.Exists(fullPath))
{
string json = File.ReadAllText(fullPath);
levelSaveData = JsonUtility.FromJson <LevelSaveData>(json);
}
else
{
Debug.Log("Save file does not exist");
}
}
else
{
TextAsset text = Resources.Load <TextAsset>(name);
string json = text.text;
levelSaveData = JsonUtility.FromJson <LevelSaveData>(json);
}
return(levelSaveData);
}
public void SaveLevelSaveDataEntry(LevelSaveData levelSaveData, string id)
{
var tempDict = LevelProgress;
tempDict [id] = levelSaveData;
LevelProgress = tempDict;
}
public static void Save(LevelSaveData levelSaveData, string name)
{
int saveNumber = 0;
string dir = Application.persistentDataPath + directory;
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
while (File.Exists(dir + name + saveNumber + ".txt") && name != "testedLevel")
{
saveNumber++;
}
GameObject.FindGameObjectWithTag("TestSave").GetComponent <EditorController>().saveNumber = saveNumber;
string json = JsonUtility.ToJson(levelSaveData);
if (name == "testedLevel")
{
File.WriteAllText(dir + name + ".txt", json);
}
else
{
File.WriteAllText(dir + name + saveNumber + ".txt", json);
}
}
public void LoadData(bool shouldSave)
{
foreach (LevelSelectButton levelSelect in allGrassyLevels)
{
LevelSelectInfo lSelect = levelSelect.levelToTravelTo;
string loadString = "LevelData_" + lSelect.buildSceneNumber.ToString();
if (ES3.KeyExists(loadString))
{
LevelSaveData loadedData = ES3.Load <LevelSaveData>(loadString);
lSelect.levelCompletionData = new LevelCompletionData();
lSelect.levelCompletionData.completed = loadedData.completed;
lSelect.levelCompletionData.earnedStars = loadedData.stars;
lSelect.levelCompletionData.cratesUsed = loadedData.cratesDropped;
}
else
{
lSelect.levelCompletionData = new LevelCompletionData();
lSelect.levelCompletionData.completed = false;
lSelect.levelCompletionData.earnedStars = 0;
lSelect.levelCompletionData.cratesUsed = 0;
if (shouldSave)
{
SaveProgress(false, 0, 0, true, lSelect);
}
}
levelSelect.UpdateStars(grassyPalette);
}
UpdateUnlocks();
}
protected override void Execute()
{
string levelFileName = StringHelper.ConvertToXMLCompatible(levelNameStatus.Name);
LevelSaveData levelSaveData = SerializeHelper.Deserialize <LevelSaveData>(LevelDataPath.Path + levelFileName);
List <Vector2> standardTileGridPositions = levelSaveData.StandardTileGridPositions;
List <Vector2> nonStandardTileGridPositions = new List <Vector2>();
foreach (TileSaveData tileSaveData in levelSaveData.NonStandardTilesSaveData)
{
GenerateableTileNode generateableTileNode = GenerateableTileLibrary.GetGeneratableTileNode(tileSaveData.TileType);
if (!generateableTileNode.UserGenerated)
{
continue;
}
nonStandardTileGridPositions.Add(tileSaveData.GridPosition);
}
List <Vector2> userGeneratedTileGridPositions = standardTileGridPositions.Concat(nonStandardTileGridPositions).ToList();
TileGenerator.SpawnTiles(userGeneratedTileGridPositions);
List <LevelObjectSaveData> levelObjectsSaveData = levelSaveData.LevelObjectsSaveData;
SpawnLevelObjects(levelObjectsSaveData);
}
//Figure out how many new cups were earned
public static int UpdateLevelSaveData(LevelSaveData levelSaveData)
{
int teacupsAlreadyEarnedInLevel = levelSaveData.teacupsEarnedOnLevel;
int newTeacupsEarned = 0;
//the first one is for completion
if (teacupsAlreadyEarnedInLevel == 0)
{
newTeacupsEarned++;
}
//only earn it if you don't already have it
if (!levelSaveData.earnedQuickTeacup)
{
if (ShouldEarnQuickTeacup())
{
newTeacupsEarned++;
levelSaveData.earnedQuickTeacup = true;
}
}
if (!levelSaveData.earnedSafeTeacup)
{
if (ShouldEarnCarefulTeacup())
{
newTeacupsEarned++;
levelSaveData.earnedSafeTeacup = true;
}
}
levelSaveData.teacupsEarnedOnLevel = teacupsAlreadyEarnedInLevel + newTeacupsEarned;
return(newTeacupsEarned);
}
/// <summary>
///
/// </summary>
/// <param name="saveData"></param>
public static bool SaveLevelData(LevelSaveData saveData)
{
string dataPath = Application.persistentDataPath + folderName + saveData.levelName + FileExtension;
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = File.Open(dataPath, FileMode.OpenOrCreate);
bool success = false;
try
{
binaryFormatter.Serialize(fileStream, saveData);
if (Web)
{
SyncFiles();
}
success = true;
}
catch (System.Exception e)
{
PlatformSafeMessage("Serialization Failed: " + e.Message);
}
finally
{
//always close the fileStream
fileStream.Close();
}
return(success);
}
public void Save(string levelName)
{
ClearLocalSaveDatas();
string savePath = GetFullPath(levelName);
LevelSaveData toSave = new LevelSaveData();
{
LevelObject[] levelObjects = GameObject.FindObjectsOfType <LevelObject>();
if (levelObjects.Length > 0)
{
foreach (var l in levelObjects)
{
_levelObjectDatas.Add(l.ToSaveData());
}
}
}
toSave._levelObjectDatas = _levelObjectDatas;
//Actual Save
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream(savePath, FileMode.Create, FileAccess.Write, FileShare.None);
formatter.Serialize(stream, toSave);
stream.Close();
}
public static void SaveData(int playerLevel, Dictionary <int, LevelData> levels)
{
// Create a reference to our BinaryFormatter and create a new file at specified path
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(filePath);
// Create new SaveData variable
SaveData data = new SaveData();
// Set the playerLevel value in the SaveData variable to the playerLevel
data.playerLevel = playerLevel;
// Loop through each level and copy level data to save data struct
foreach (LevelData level in levels.Values)
{
LevelSaveData newLevel = new LevelSaveData();
newLevel.rating = level.rating;
newLevel.score = level.score;
data.levelData.Add(newLevel);
}
// Serialize our file with the GameData class and close the file
bf.Serialize(file, data);
file.Close();
Debug.Log("Game saved to: " + filePath + " successfully");
}
public void NewGameProcess()
{
gameSessionData = new GameSessionData();
gameSessionData.wipeAbilityCount = 2;
gameSessionData.doubleDamageAbilityCount = 2;
gameSessionData.freezeAbilityCount = 2;
gameSessionData.shieldAbilityCount = 2;
gameSessionData.planetStatus.Add(1, false);
/*gameSessionData.planetStatus.Add (2, false);
* gameSessionData.planetStatus.Add (3, false);
* gameSessionData.planetStatus.Add (4, false);
* gameSessionData.planetStatus.Add (5, false);
* gameSessionData.planetStatus.Add (6, false);*/
for (int i = 1; i <= 6; i++)
{
LevelSaveData levelSaveData = new LevelSaveData();
levelSaveData.levelID = 1;
levelSaveData.planetID = i;
gameSessionData.levels.Add(i.ToString() + "_1", levelSaveData);
}
SaveGameSessionData();
}
protected override void Execute()
{
LevelSaveData levelSaveData = deserializedLevelSaveDataStatus.LevelSaveData;
List <LevelObjectSaveData> levelObjectsSaveData = levelSaveData.LevelObjectsSaveData;
SpawnLevelObjects(levelObjectsSaveData);
}
private void CreateObjectsFromSaveData(LevelSaveData data)
{
foreach (var l in data._levelObjectDatas)
{
NodeSideInfo info = BoardManager.Instance.CurrentBoard.GetNodeInfoAt(l._boardX, l._boardY, l._boardZ, l._installedSide);
LevelCreator.Instance.InstallObjectAtNode(info, l._prefabIndex, l._offset, l._rotation);
}
}
static void GatherLevelData()
{
if (baseLevels == null)
{
baseLevels = new LevelSaveData();
}
baseLevels.levels = LevelManager.GameLevels;
}
//required for proper teacup progress to be saved
public static void UpdateCurrentLevelDataWithPrevious()
{
LevelSaveData previousLevelData = SaveManager.GetLevelData(GameManager.instance.activeLevel);
GameManager.instance.globalSaveData.currentLevelSaveData.teacupsEarnedOnLevel = previousLevelData.teacupsEarnedOnLevel;
GameManager.instance.globalSaveData.currentLevelSaveData.earnedQuickTeacup = previousLevelData.earnedQuickTeacup;
GameManager.instance.globalSaveData.currentLevelSaveData.earnedSafeTeacup = previousLevelData.earnedSafeTeacup;
}
//retrieve data by finding the matching element in the level save data list
public static LevelSaveData GetLevelData(GameLevel level)
{
GlobalSaveData globalSaveData = GameManager.instance.globalSaveData;
List <LevelSaveData> levelSaveDataList = new List <LevelSaveData>(globalSaveData.levelSaveData);
LevelSaveData data = levelSaveDataList.Where(obj => obj.dataName == level.levelName).SingleOrDefault();
return(data);
}
//initialize using permanent data for a level, savedData can either be passed or a new empty object will be created
public LevelData(LevelPermanentData permanentData, LevelSaveData savedData = null)
{
permData = permanentData;
if (savedData == null)
{
savedData = new LevelSaveData(GetLevelID());
}
saveData = savedData;
}
public void LevelComplete()
{
if (gameSessionData.levels.ContainsKey(level.GetLevelKey()))
{
if (gameSessionData.levels [level.GetLevelKey()].points < currentPoints)
{
Interface.interfaceSt.winWindowOldPoints.text = System.Math.Round(gameSessionData.levels [level.GetLevelKey()].points, 0).ToString();
float plusPoints = currentPoints - gameSessionData.levels [level.GetLevelKey()].points;
Interface.interfaceSt.winWindowCurrentPoints.text = "+" + System.Math.Round(plusPoints, 0).ToString();
gameSessionData.points += plusPoints;
gameSessionData.maximumPoints += plusPoints;
gameSessionData.levels [level.GetLevelKey()].points = currentPoints;
}
else
{
Interface.interfaceSt.winWindowOldPoints.text = System.Math.Round(gameSessionData.levels [level.GetLevelKey()].points, 0).ToString();
Interface.interfaceSt.winWindowCurrentPoints.text = "+0";
}
gameSessionData.levels [level.GetLevelKey()].isComplete = true;
}
else
{
Interface.interfaceSt.winWindowOldPoints.text = "0";
LevelSaveData levelSaveData = new LevelSaveData();
levelSaveData.planetID = level.planetID;
levelSaveData.levelID = level.levelID;
levelSaveData.points = currentPoints;
levelSaveData.isComplete = true;
gameSessionData.levels.Add(level.GetLevelKey(), levelSaveData);
gameSessionData.points += currentPoints;
gameSessionData.maximumPoints += currentPoints;
}
Level nextLevel = Levels.GetNextLevel(level);
LevelSaveData newLevelSaveData = new LevelSaveData();
newLevelSaveData.planetID = nextLevel.planetID;
newLevelSaveData.levelID = nextLevel.levelID;
//Debug.Log (nextLevel.GetLevelKey());
if (!gameSessionData.levels.ContainsKey(nextLevel.GetLevelKey()))
{
gameSessionData.levels.Add(nextLevel.GetLevelKey(), newLevelSaveData);
}
if (level.planetID < nextLevel.planetID)
{
gameSessionData.planetStatus [level.planetID] = true;
if (!gameSessionData.planetStatus.ContainsKey(nextLevel.planetID))
{
gameSessionData.planetStatus.Add(nextLevel.planetID, false);
}
}
LevelController.instance.SaveGameSessionData();
}
public void LoadFromSave(LevelSaveData from)
{
unlocked = from.unlocked;
passed = from.passed;
for (int i = 0; i < 3; i++)
{
bonusTokens[i] = from.bonusTokens[i];
}
}
void SaveLevel()
{
var azure = new AzureMobileServices(_azureEndPoint, _applicationKey);
var data = new LevelSaveData()
{
SaveData = SavePositions(), Id = 1
};
azure.Update <LevelSaveData>(data);
}
void WriteToSaveData(string uid, Action <LevelSaveData> saveAction)
{
LevelSaveData saveData = null;
if (!savedLevelsData.TryGetValue(uid, out saveData))
{
saveData = new LevelSaveData();
savedLevelsData.Add(uid, saveData);
}
saveAction(saveData);
}
public void SaveCurrentSpawnables(string fileName)
{
var levelConfigToSave = new LevelSaveData
{
levelHash = LevelManager.Instance.currentLevel.hash,
levelName = LevelManager.Instance.currentLevel.name,
dateModified = DateTime.Now,
};
var spawnedItems = SpawnableManager.SpawnedObjects;
if (spawnedItems == null || !spawnedItems.Any())
{
return;
}
foreach (var spawnable in spawnedItems)
{
var instance = spawnable.SpawnedInstance;
var objectSaveData = new GameObjectSaveData
{
Id = instance.name,
bundleName = spawnable.BundleName,
position = new SerializableVector3(instance.transform.position),
rotation = new SerializableQuaternion(instance.transform.rotation),
localScale = new SerializableVector3(instance.transform.localScale)
};
foreach (var settings in spawnable.Settings)
{
var settingsSaveData = settings.ConvertToSaveSettings();
if (settingsSaveData != null)
{
objectSaveData.settings.Add(settingsSaveData);
}
}
levelConfigToSave.gameObjects.Add(objectSaveData);
}
string json = JsonConvert.SerializeObject(levelConfigToSave, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto
});
var currentSaveDir = Path.Combine(SaveDir, levelConfigToSave.levelName);
if (!Directory.Exists(currentSaveDir))
{
Directory.CreateDirectory(currentSaveDir);
}
File.WriteAllText(Path.Combine(currentSaveDir, $"{fileName}.json"), json);
}
public void SaveProgress(bool completed, int droppedCrates, int stars, bool shouldLoad, LevelSelectInfo lSave)
{
LoadData(false);
string saveString = "LevelData_" + lSave.buildSceneNumber.ToString();
LevelSaveData lSaveData = new LevelSaveData();
lSaveData.stars = stars;
lSaveData.cratesDropped = droppedCrates;
lSaveData.completed = completed;
ES3.Save <LevelSaveData>(saveString, lSaveData);
}
public void Load(LevelSaveData level)
{
currentLevel = level;
sprite_icon.spriteName = level.icon;
inpt_name.text = level.name;
inpt_spaceObjectsAtScreen.text = level.spaceObjectsAtScreen.ToString ();
inpt_spaceObjectsGenerationFrequency.text = level.spaceObjectsGenerationFrequency.ToString ();
inpt_spaceObjectsInLevel.text = level.spaceObjectsInLevel.ToString ();
inpt_vc_DistanceToPass.text = level.vc_DistanceToPass.ToString ();
inpt_vc_ShipsNumToDestroy.text = level.vc_ShipsNumToDestroy.ToString ();
RefreshSpaceObjectsList ();
poplst_spaceObjects.selection = "-";
poplst_spaceObjects.selection = poplst_spaceObjects.items [0];
}
/// <summary>
/// Clone this instance.
/// </summary>
public object Clone()
{
LevelSaveData ret = new LevelSaveData ();
ret.icon = icon;
ret.name = name;
ret.spaceObjects = new List<string> (spaceObjects);
ret.spaceObjectsAtScreen = spaceObjectsAtScreen;
ret.spaceObjectsGenerationFrequency = spaceObjectsGenerationFrequency;
ret.spaceObjectsInLevel = spaceObjectsInLevel;
ret.vc_DistanceToPass = vc_DistanceToPass;
ret.vc_ShipsNumToDestroy = vc_ShipsNumToDestroy;
return ret;
}
// Use this for initialization
void Start()
{
resultSpawnHeight = (GameManager.SCREENHEIGHT * verticalSpawnOffset) + GameManager.SCREENHEIGHT;
halfSpawnWidth = (GameManager.SCREENWIDTH - (GameManager.SCREENWIDTH * horizontalSpawnOffset)) * 0.5f;
selectedLevel = MidSceneData.Instance.selectedLevel;
}
void SaveLevel()
{
var azure = new AzureMobileServices(_azureEndPoint, _applicationKey);
var data = new LevelSaveData() { SaveData = SavePositions(), Id = 1 };
azure.Update<LevelSaveData>(data);
}
void Start()
{
int r = Random.Range (1000, 9999);
currentLevel = new LevelSaveData ("Level" + r);
}
