public static Dictionary <string, string> SerializeAll() { var filesToWrite = new Dictionary <string, string>(); foreach (var kvp in _dirtyChunks) { var fileName = kvp.Key.ToString(); var data = new SerializableChunk(kvp.Value).Serialize(); filesToWrite.Add(fileName, data); } foreach (var kvp in _dirtyBuilders) { var fileName = kvp.Key.ToString() + "B"; var data = new SerializableChunkBuilder(kvp.Value).Serialize(); filesToWrite.Add(fileName, data); } foreach (var kvp in _dirtySpaces) { var fileName = kvp.Key; var data = SerializableSpaceHelper.ToSerializableSpace(kvp.Value).Serialize(); filesToWrite.Add(fileName, data); } var characterFile = new SerializableCharacter(CurrentCharacter); filesToWrite.Add(Paths.CHARACTERFILE, characterFile.Serialize()); return(filesToWrite); }
public void Save(SerializableCharacter serializable) { serializable.Name = Name; serializable.AvatarIcon = AvatarIcon; serializable.Faction = Faction.Id; serializable.Relations = Relations.Value; }
public void CanSerialize() { var cha = new SerializableCharacter(); var mock_frame = TestBase.MockGameFrame.GetTestFrame(); for (var i = 0; i < 10; i++) { cha.StoreDecision(mock_frame.ID); } var file_name = System.IO.Path.ChangeExtension(Guid.NewGuid().ToString("N"), SerializableCharacter.CharacterFileExtension); if (System.IO.File.Exists(file_name)) { System.IO.File.Delete(file_name); } Assert.That(System.IO.File.Exists(file_name), Is.False); cha.Save(file_name); Assert.That(System.IO.File.Exists(file_name), Is.True); System.IO.File.Delete(file_name); }
public void AssignsNextIdsSequentially() { var cha = new SerializableCharacter(); var mock_frame = TestBase.MockGameFrame.GetTestFrame(); for (var i = 0; i < 10; i++) { cha.StoreDecision(mock_frame.ID); } Assert.That(cha.DecisionList.Count(), Is.EqualTo(10)); var vals = Enumerable.Range(0, 10).ToList(); var counter = 0; foreach (var decision in cha.DecisionList) { if (vals.Contains(decision.DecisionHistoryOrder)) { vals.Remove(decision.DecisionHistoryOrder); } else { counter++; Logger.ErrorFormat("Value {0} was found in the character's decision history, but it was not expected", decision.DecisionHistoryOrder); } } Assert.That(counter, Is.EqualTo(0), "More than zero values were found that were not as expected"); Assert.That(vals.Count, Is.EqualTo(0), "At least one of the expected values was not found"); }
public Character(SerializableCharacter character, Database database) { ItemId = new ItemId <Character>(character.Id, character.FileName); Name = character.Name; AvatarIcon = character.AvatarIcon; Faction = database.GetFactionId(character.Faction); Relations = new NumericValue <int>(character.Relations, -100, 100); }
/// <summary> /// Saves the current character to file /// </summary> /// <param name="backup_existing">If an current character file already exists, this flag indicates whether to try to back it up</param> public static void SaveCurrentCharacter(bool backup_existing = true) { ICharacter character; if (GameManager.Manager.TryGet <ICharacter>(out character)) { var target = System.IO.Path.ChangeExtension(Properties.Resources.CharacterFileName, SerializableCharacter.CharacterFileExtension); if (backup_existing) { if (System.IO.File.Exists(target)) { try { var c = SerializableCharacter.Load(target); var bck_up_trgt = System.IO.Path.ChangeExtension("Char" + c.ID.ToString(), SerializableCharacter.CharacterFileExtension); if (System.IO.File.Exists(bck_up_trgt)) { System.IO.File.Delete(bck_up_trgt); } System.IO.File.Move(target, bck_up_trgt); logger.InfoFormat("Existing character file backup up to {0}", bck_up_trgt); } catch (Exception e) { logger.Error("Could not backup existing character file.", e); } } else { logger.InfoFormat("No existing file was found @ {0}, so no backup was made.", target); } } else { logger.Info("No backup was requested when saving the current character"); if (System.IO.File.Exists(target)) { logger.InfoFormat("An existing character file was found and will be overwritten @ {0}", target); } } character.Serialize(target); logger.InfoFormat("Current character was saved to the default character file @ {0}", target); } else { logger.Warn("Could not find an existing character instance to save as the interface was not registered"); } }
public SerializableEncounter(Encounter e) { int i = 0; foreach (Character character in e.CharactersInEncounter) { encounter[i] = new SerializableCharacter(character); i++; } }
public void CanStoreDecision() { var cha = new SerializableCharacter(); var mock_frame = TestBase.MockGameFrame.GetTestFrame(); cha.StoreDecision(mock_frame.ID); Assert.That(cha.DecisionList.Length, Is.EqualTo(1)); Assert.That(cha.DecisionList.First().ChosenFrame, Is.EqualTo(mock_frame.ID)); Assert.That(cha.DecisionList.First().DecisionHistoryOrder, Is.EqualTo(0)); }
private static void LoadCharacter() { Character character; if (DataReader.Exists(DataTypes.CurrentCharacter)) { var characterJson = DataReader.Read(DataTypes.CurrentCharacter); character = SerializableCharacter.Deserialize(characterJson).ToObject(); } else { character = new Character(); } CurrentCharacter = character; }
public void SaveCharacters() { if (File.Exists(Application.persistentDataPath + "/characters.dat")) { File.Delete(Application.persistentDataPath + "/characters.dat"); } SerializableCharacters Characters = new SerializableCharacters(); BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.persistentDataPath + "/characters.dat", FileMode.Create); for (int i = 0; i < CharacterManager.CM.Funcionarios.Count; i++) { SerializableCharacter Test = new SerializableCharacter(); Test.SerializeCharacter(CharacterManager.CM.Funcionarios[i]); Characters.Characters.Add(Test); } bf.Serialize(file, Characters); file.Close(); }
/// <summary> /// Creates an entirely new character, overwriting any existing singleton instance currently loaded /// </summary> /// <param name="make_singleton">specifies whether the class should be a singleton. Usually should be true</param> /// <returns></returns> public static ICharacter NewCharacter(bool make_singleton = true, bool backup_current_character_file = true) { logger.InfoFormat("Request to make new character recieved. Singleton? = {0}", make_singleton); var inner = new SerializableCharacter(); GameManager.Manager.RegisterTypeEntry <ISerializableCharacter, SerializableCharacter>(inner, make_singleton, true); var c = new Character(inner); GameManager.instance.RegisterTypeEntry <ICharacter, Character>(c, make_singleton, true); GameManager.SaveCurrentCharacter(backup_current_character_file); var ret = GameManager.Get <ICharacter>(); logger.InfoFormat("New character instance was registered with the GameManager - id = {0}", ret.ID); return(ret); }
/// <summary> /// Registers an entier TypeRegister with the GameManager /// </summary> /// <param name="registery"></param> /// <param name="overwrite_existing_interface_keys"></param> public void RegisterTypeRegister(TypeRegister registery, bool overwrite_existing_interface_keys) { foreach (var entry in registery.Entries.OrderBy(x => x.CreationIndex)) { if (entry.Value.InterfaceType.Equals(typeof(ICharacter))) { var inner = this.GetInstance <ISerializableCharacter>(); entry.Value.Instance = new Character(inner); } else if (entry.Value.InterfaceType.Equals(typeof(ISerializableCharacter))) { var target = System.IO.Path.ChangeExtension(Properties.Resources.CharacterFileName, SerializableCharacter.CharacterFileExtension); if (System.IO.File.Exists(target)) { entry.Value.Instance = SerializableCharacter.Load(target); } } this.RegisterTypeEntry(entry.Value, overwrite_existing_interface_keys); } }
public SavedObject(Character characterInfo, Transform transform, string prefabName) { this.characterInfo = characterInfo; this.transform = transform; this.prefabName = prefabName; }
public SavedObject() { characterInfo = new SerializableCharacter(); transform = new SerializableTransform(); prefabName = ""; }
public void SetsGuidOnInitialize() { var cha = new SerializableCharacter(); Assert.That(cha.ID, Is.Not.Null); }