public static SaveGameData LoadPlayers(SaveGameFile savegame) { SaveGameData saveData = new SaveGameData(); Dictionary <int, Club_Comp> clubcomps = DataFileLoaders.GetDataFileClubCompetitionDictionary(savegame); Dictionary <int, string> firstnames = GetDataFileStringsDictionary(savegame, DataFileType.First_Names); Dictionary <int, string> secondNames = GetDataFileStringsDictionary(savegame, DataFileType.Second_Names); Dictionary <int, string> commonNames = GetDataFileStringsDictionary(savegame, DataFileType.Common_Names); Dictionary <int, Nation> nations = DataFileLoaders.GetDataFileNationDictionary(savegame); Dictionary <int, Club> clubs = DataFileLoaders.GetDataFileClubDictionary(savegame); List <Staff> duplicates = new List <Staff>(); Dictionary <int, Staff> staffDic = DataFileLoaders.GetDataFileStaffDictionary(savegame, saveData, out duplicates); List <PlayerData> players = GetDataFilePlayerData(savegame); List <Player> searchablePlayers = ConstructSearchablePlayers(staffDic, players).ToList(); saveData.GameDate = savegame.GameDate; saveData.FirstNames = firstnames; saveData.Surnames = secondNames; saveData.CommonNames = commonNames; saveData.Nations = nations; saveData.Clubs = clubs; saveData.Players = searchablePlayers; saveData.ClubComps = clubcomps; return(saveData); }
public static List <SaveGameFile> GetSaveGameFiles(string rootPath) { List <SaveGameFile> saveGameFiles = new List <SaveGameFile>(); DirectoryInfo directoryInfo = new DirectoryInfo(rootPath); FileInfo[] files = directoryInfo.GetFiles("*.sav"); foreach (FileInfo file in files) { SaveGameFile saveGameFile = new SaveGameFile() { RootPath = rootPath, LastChanged = file.LastWriteTime, Name = file.Name, SizeInKb = file.Length / 1024 }; saveGameFiles.Add(saveGameFile); } saveGameFiles = saveGameFiles.OrderByDescending(x => x.LastChanged).ToList(); return(saveGameFiles); }
public SaveGameReader(string saveFilePath) { _savegame = new SaveGameFile(saveFilePath, SaveFileFormat.DUNE_37); _generals = new Generals(_savegame.UncompressedData, new Dune37Offsets()); _offsets = new Dune37Offsets(); _saveFilePath = saveFilePath; }
public static Dictionary <int, Staff> GetDataFileStaffDictionary(SaveGameFile savegame, SaveGameData gameData, out List <Staff> duplicateStaff) { Dictionary <int, Staff> dic = new Dictionary <int, Staff>(); duplicateStaff = new List <Staff>(); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == DataFileType.Staff); var bytes = GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); StaffConverter converter = new StaffConverter(); foreach (var item in bytes) { var staff = converter.Convert(item); staff.Value = staff.Value * gameData.ValueMultiplier; staff.Wage = staff.Wage * gameData.ValueMultiplier; if (staff.StaffPlayerId != -1) { if (dic.ContainsKey(staff.StaffPlayerId)) { duplicateStaff.Add(staff); } else { dic.Add(staff.StaffPlayerId, staff); } } } return(dic); }
private string ReCompressUncompressedSavegameFile(string inputFilePath) { var savegame = new SaveGameFile(File.ReadAllBytes(inputFilePath).ToList(), Enums.SaveFileFormat.DUNE_37, false); savegame.SaveCompressedAs(_options.OutputSaveGameFile); return($"Compressed {_options.Compress} to {_options.OutputSaveGameFile}{Environment.NewLine}"); }
private void EditSavegame(SaveGameFile savegame) { for (int i = 0; i < _options.Write.Count(); i++) { var edit = _options.Write.ElementAt(i); if (string.IsNullOrWhiteSpace(edit) || edit.Contains(',') == false) { throw new ArgumentException($"{nameof(_options.Write)} invalid date found: {edit}"); } var splittedEdit = edit.Split(","); var pos = 0; byte value = 0; if (!byte.TryParse(splittedEdit[0], NumberStyles.HexNumber, CultureInfo.InstalledUICulture, out value)) { throw new ArgumentException($"{nameof(_options.Write)} invalid date found: {edit} for value part"); } if (!int.TryParse(splittedEdit[1], NumberStyles.HexNumber, CultureInfo.InstalledUICulture, out pos)) { throw new ArgumentException($"{nameof(_options.Write)} invalid date found: {edit} for position part"); } savegame.ModifyByteInUncompressedData(value, pos); Console.WriteLine($"Written byte 0x{value:X2} at position 0x{pos:X2}"); } savegame.SaveCompressedAs(_options.OutputSaveGameFile); Console.WriteLine($"Modified and compressed savegame written at {_options.OutputSaveGameFile}"); }
private static void ReadFileHeaders(StreamReader sr, SaveGameFile savegame) { using (var br = new BinaryReader(sr.BaseStream)) { if (br.ReadInt32() == 4) { savegame.IsCompressed = true; } sr.BaseStream.Seek(4, SeekOrigin.Current); var blockCount = br.ReadInt32(); for (int j = 0; j < blockCount; j++) { byte[] fileHeader = new byte[ByteBlockSize]; br.Read(fileHeader, 0, ByteBlockSize); var internalName = ByteHandler.GetStringFromBytes(fileHeader, 8); savegame.DataBlockNameList.Add(new DataFile() { InternalName = internalName, FileType = DataFileFacts.GetDataFileFact(internalName).Type, Position = ByteHandler.GetIntFromBytes(fileHeader, 0), Length = ByteHandler.GetIntFromBytes(fileHeader, 4) }); } } }
private static List <T> GetDataFileConverted <T>(SaveGameFile savegame, DataFileType type) { var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == type); var bytes = DataFileLoaders.GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); var converter = ConverterFactory.CreateConverter <T>(); var collect = ConvertToCMObject <T>(bytes, converter).ToList(); return(collect); }
public void CanLoadVanillaPatch2SaveGame() { var savePath = TestData.GetPath("SaveGames/TestData/slot0014"); using var tempDir = new TempDirectory(); var saveFile = SaveGameFile.Load(savePath, tempDir.Path); Console.WriteLine(); }
private static void LoadGameData(SaveGameFile savegame) { var general = savegame.DataBlockNameList.First(x => x.FileType == DataFileType.General); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == DataFileType.General); ByteHandler.GetAllDataFromFile(general, savegame.FileName, fileFacts.DataSize); var fileData = ByteHandler.GetAllDataFromFile(general, savegame.FileName, fileFacts.DataSize); savegame.GameDate = ByteHandler.GetDateFromBytes(fileData[0], fileFacts.DataSize - 8).Value; }
private static Dictionary <int, string> GetDataFileStringsDictionary(SaveGameFile savegame, DataFileType type) { Dictionary <int, string> fileContents = new Dictionary <int, string>(); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == type); var fileData = DataFileLoaders.GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); for (int i = 0; i < fileData.Count; i++) { fileContents.Add(i, ByteHandler.GetStringFromBytes(fileData[i], 0, fileFacts.StringLength)); } return(fileContents); }
private static List <PlayerData> GetDataFilePlayerData(SaveGameFile savegame) { var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == DataFileType.Players); var bytes = DataFileLoaders.GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); var converter = new PlayerDataConverter(); var collect = new List <PlayerData>(); foreach (var source in bytes) { collect.Add(converter.Convert(source)); } return(collect); }
public void CanEditArbitraryLocation() { var save = Path.Combine(SavesFolder, MidGamesSaveFileName); var output = Path.GetTempFileName(); var writer = new SaveGameEditorCli(new Options { InputSaveGameFiles = new string[] { save }, Write = new string[] { "FF,CC", "11,01" }, OutputSaveGameFile = output }); writer.GetStandardOutput(); var bytes = new SaveGameFile(output, Enums.SaveFileFormat.DUNE_37).UncompressedData; bytes.Should().HaveElementAt(0xCC, 0xFF); bytes.Should().HaveElementAt(0x01, 0x11); }
public static SaveGameData OpenSaveGameIntoMemory(string fileName) { SaveGameFile savegame = new SaveGameFile(); savegame.FileName = fileName; using (var sr = new StreamReader(fileName)) { ReadFileHeaders(sr, savegame); } LoadGameData(savegame); return(PlayerLoader.LoadPlayers(savegame)); }
// Create a .dat file named (saveName) and save game relevent information to it public void saveGame() { //set up data container SaveGameFile save = new SaveGameFile(); //save stuff save.save_playerClass = (int)playerClass; save.save_playerBullet = playerBullet = player.transform.GetComponent <Player>().bullet.name; save.save_difficulty = (int)difficulty; save.save_spawnX = spawnCoordinates.x; save.save_spawnY = spawnCoordinates.y; //save abilities save.abilityNames = new string[3]; Entity entscr = player.transform.GetComponent <Entity> (); for (int i = 0; i < 3; i++) { if (entscr.abilities [i + 2] == null) { save.abilityNames [i] = ""; } else { save.abilityNames [i] = entscr.abilities [i + 2].GetType().AssemblyQualifiedName; } } //save learned abilites Ability[] temp = new Ability[player.transform.GetComponent <Player>().learnedAbilities.Count]; player.transform.GetComponent <Player> ().learnedAbilities.CopyTo(temp); save.learnedAbilityNames = new string[temp.Length]; for (int i = 0; i < temp.Length; i++) { save.learnedAbilityNames [i] = temp [i].GetType().AssemblyQualifiedName; } //save defeated bosses save.defeatedBosses = completedBosses; //serialize and save FileStream file = File.Open(Application.persistentDataPath + "\\" + saveName + ".dat", FileMode.Create); BinaryFormatter bf = new BinaryFormatter(); bf.Serialize(file, save); file.Close(); }
private void LoadFile() { textBoxLog.AppendText("Updating selected file..." + Environment.NewLine); _selectedSaveGame = (SaveGameFile)coBxSaveGames.SelectedItem; textBoxLog.AppendText("Loaded file: " + _selectedSaveGame.FullName + Environment.NewLine); textBoxLog.AppendText("Reading file..." + Environment.NewLine); string fileContent = File.ReadAllText(_selectedSaveGame.FullName); textBoxLog.AppendText("Deserializing..." + Environment.NewLine); _loadedSaveGame = FileManager.DeSerializeFromXml <SaveGameCore>(fileContent).FillAllCollectors().HealAllCharacters().DoAllConstructions(); textBoxLog.AppendText("Computing data..." + Environment.NewLine); UpdateResourceDatagrid(); UpdateCharacterDatagrid(); textBoxLog.AppendText("Done." + Environment.NewLine); }
public void OnAfterLoad(string saveDirectory, SaveGameFile saveFile) { var co8State = saveFile.Co8State; if (co8State != null) { Co8PersistentData.Flags = new Dictionary <string, bool>(co8State.Flags); Co8PersistentData.Vars = new Dictionary <string, int>(co8State.Vars); Co8PersistentData.StringVars = new Dictionary <string, string>(co8State.StringVars); Co8PersistentData.ActiveSpellTargets = co8State.ActiveSpellTargets.ToDictionary( kvp => kvp.Key, kvp => kvp.Value.ToHashSet() ); } else { Co8PersistentData.Reset(); } }
public void OnAfterSave(string saveDirectory, SaveGameFile saveFile) { if (Co8PersistentData.Flags.Count == 0 && Co8PersistentData.Vars.Count == 0 && Co8PersistentData.StringVars.Count == 0 && Co8PersistentData.ActiveSpellTargets.Count == 0) { return; } saveFile.Co8State = new SavedCo8State { Flags = new Dictionary <string, bool>(Co8PersistentData.Flags), Vars = new Dictionary <string, int>(Co8PersistentData.Vars), StringVars = new Dictionary <string, string>(Co8PersistentData.StringVars), ActiveSpellTargets = Co8PersistentData.ActiveSpellTargets.ToDictionary( kvp => kvp.Key, kvp => kvp.Value.ToArray() ) }; }
// Load (saveName).dat and begin a game with its data public void loadGame() { if (File.Exists(Application.persistentDataPath + "\\" + saveName + ".dat")) { //load and deserialize file BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.persistentDataPath + "\\" + saveName + ".dat", FileMode.Open); SaveGameFile save = (SaveGameFile)bf.Deserialize(file); //set GameManager values to match deserialized values playerClass = (PlayerClass)save.save_playerClass; playerBullet = save.save_playerBullet; difficulty = (Difficulty)save.save_difficulty; spawnCoordinates.x = save.save_spawnX; spawnCoordinates.y = save.save_spawnY; //load abilities for (int i = 0; i < save.abilityNames.Length; i++) { if (save.abilityNames [i] == "") { flexAbilities [i] = null; } else { flexAbilities [i] = (Ability)Activator.CreateInstance(Type.GetType(save.abilityNames [i])); } } //load learned abilites for (int i = 0; i < save.learnedAbilityNames.Length; i++) { learnedAbilites.Add((Ability)Activator.CreateInstance(Type.GetType(save.learnedAbilityNames [i]))); } //load defeated bosses completedBosses = save.defeatedBosses; } }
public string GetStandardOutput() { if (_options.Write.Any() && string.IsNullOrWhiteSpace(_options.Compress) == false) { return($"Editing a savegame and recompression of another at the same time is not supported.{Environment.NewLine}"); } if (_options.Write.Any() && _options.InputSaveGameFiles.Any()) { var inputFile = _options.InputSaveGameFiles.ElementAt(0); var savegame = new SaveGameFile(inputFile, Enums.SaveFileFormat.DUNE_37); EditSavegame(savegame); } if (string.IsNullOrWhiteSpace(_options.Compress) == false && string.IsNullOrWhiteSpace(_options.OutputSaveGameFile) == false) { foreach (var inputFilePath in _options.InputSaveGameFiles) { return(ReCompressUncompressedSavegameFile(inputFilePath)); } } return(""); }
public static Dictionary <int, Club> GetDataFileClubDictionary(SaveGameFile savegame) { Dictionary <int, Club> dic = new Dictionary <int, Club>(); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == DataFileType.Clubs); var bytes = GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); ClubConverter converter = new ClubConverter(); foreach (var item in bytes) { var club = converter.Convert(item); if (club.ClubId != -1) { if (!dic.ContainsKey(club.ClubId)) { dic.Add(club.ClubId, club); } } } return(dic); }
public static Dictionary <int, Nation> GetDataFileNationDictionary(SaveGameFile savegame) { Dictionary <int, Nation> dic = new Dictionary <int, Nation>(); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == DataFileType.Nations); var bytes = GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); NationConverter converter = new NationConverter(); foreach (var item in bytes) { var nation = converter.Convert(item); if (nation.Id != -1) { if (!dic.ContainsKey(nation.Id)) { dic.Add(nation.Id, nation); } } } return(dic); }
public static SaveGameFile Load(string basePath, string currentSaveDir) { var result = new SaveGameFile(); var indexPath = basePath + ".tfai"; var archiveIndex = ArchiveIndexReader.ReadIndex(indexPath); using var dataStream = new FileStream(basePath + ".tfaf", FileMode.Open); byte[] gameStateData = null; byte[] spellPacketData = null; byte[] partyConfigData = null; byte[] mapFleeData = null; byte[] uiStateData = null; bool GrabData(ArchiveIndexEntry entry, string filename, ref byte[] bufferOut) { if (entry.Path == filename) { if (bufferOut != null) { throw new CorruptSaveException($"File {filename} exists twice in the save game!"); } var buffer = new byte[entry.Size]; dataStream.Read(buffer); if (Debugger.IsAttached) { var fullPath = Path.Join(currentSaveDir, entry.Path); File.WriteAllBytes(fullPath, buffer); } bufferOut = buffer; return(true); } return(false); } foreach (var entry in archiveIndex) { var fullPath = Path.Join(currentSaveDir, entry.Path); if (entry.Directory) { Directory.CreateDirectory(fullPath); continue; } if (GrabData(entry, MainStateFile, ref gameStateData) || GrabData(entry, ActionSequencesSpellsFile, ref spellPacketData) || GrabData(entry, PartyConfigFile, ref partyConfigData) || GrabData(entry, MapFleeFile, ref mapFleeData) || GrabData(entry, UiStateFile, ref uiStateData)) { continue; } CopyStreamToFile(dataStream, entry.Size, fullPath); } if (gameStateData == null) { throw new CorruptSaveException($"Save file is missing {MainStateFile}"); } if (spellPacketData == null) { throw new CorruptSaveException($"Save file is missing {ActionSequencesSpellsFile}"); } if (partyConfigData == null) { throw new CorruptSaveException($"Save file is missing {PartyConfigFile}"); } if (mapFleeData == null) { throw new CorruptSaveException($"Save file is missing {MapFleeFile}"); } if (uiStateData == null) { throw new CorruptSaveException($"Save file is missing {UiStateFile}"); } result.GameState = SavedGameState.Load(gameStateData, spellPacketData, partyConfigData, mapFleeData); result.UiState = SavedUiState.Load(uiStateData); // Load the optional Co8 data if it exists var co8Path = basePath + ".co8"; if (File.Exists(co8Path)) { result.Co8State = SavedCo8State.Load(co8Path); } return(result); }
public void WriteUncompressedSaveGameInTheSameFolder() => SaveGameFile.SaveUnCompressedAs($"{_saveFilePath}.UNCOMPRESSED", _savegame.UncompressedData);
public static Dictionary <int, T> GetDataFileConvertedIdDictionary <T>(ITupleConverter <T> converter, SaveGameFile savegame, DataFileType type, out List <T> duplicates) where T : class { duplicates = new List <T>(); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == type); var bytes = DataFileLoaders.GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); Dictionary <int, T> dic = new Dictionary <int, T>(); List <T> invalidIds = new List <T>(); foreach (var item in bytes) { var converted = converter.Convert(item); if (converted.Item1 == -1) { invalidIds.Add(converted.Item2 as T); } else { if (dic.ContainsKey(converted.Item1)) { duplicates.Add(converted.Item2 as T); } else { dic.Add(converted.Item1, converted.Item2 as T); } } } return(dic); }
private static Dictionary <int, T> GetDataFileConvertedIdDictionary <T>(SaveGameFile savegame, DataFileType type, out List <T> duplicates) where T : class { var converter = ConverterIdFactory.CreateTupleConverter <T>(); return(GetDataFileConvertedIdDictionary(converter, savegame, type, out duplicates)); }
public static Dictionary <int, Club_Comp> GetDataFileClubCompetitionDictionary(SaveGameFile savegame) { Dictionary <int, Club_Comp> dic = new Dictionary <int, Club_Comp>(); var fileFacts = DataFileFacts.GetDataFileFacts().First(x => x.Type == DataFileType.Club_Comps); var bytes = GetDataFileBytes(savegame, fileFacts.Type, fileFacts.DataSize); var converter = new ClubCompConverter(); foreach (var item in bytes) { var comp = converter.Convert(item); dic.Add(comp.Id, comp); } return(dic); }
public static SaveGameFile LoadSaveGame(SaveGameFile saveGameFile) { return(LoadSaveGame(saveGameFile.FullName)); }
public static List <byte[]> GetDataFileBytes(SaveGameFile savegame, DataFileType fileType, int sizeOfData) { DataFile dataFile = savegame.DataBlockNameList.First(x => x.FileType == fileType); return(ByteHandler.GetAllDataFromFile(dataFile, savegame.FileName, sizeOfData)); }