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);
}
