public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeBool("IsAmazing", this.IsAmazing);
stream.SerializeString("TheStateMachine", this.TheStateMachine.Name);;
stream.SerializeVector3("SomeUnityType", this.SomeUnityType);
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.ActerId = stream.DeserializeInt("ActerId");;
this.Ready = stream.DeserializeBool("Ready");;
this.IsLocal = stream.DeserializeBool("IsLocal");;
}
public override void Read(ISerializerStream stream) {
base.Read(stream);
if (stream.DeepSerialize) {
this.Screens.Clear();
this.Screens.AddRange(stream.DeserializeObjectArray<SubScreenViewModel>("Screens"));
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.Point = stream.DeserializeInt("Point");;
this.AddTime = stream.DeserializeFloat("AddTime");;
this.Expire = stream.DeserializeFloat("Expire");;
}
public void LoadState(ISerializerStorage storage, ISerializerStream stream)
{
// Enforce required settings for scene state loading
stream.DeepSerialize = true;
stream.TypeResolver = this;
stream.DependencyContainer = Container;
storage.Load(stream);
// STEP 1: Load the viewmodels
var viewModels = stream.DeserializeObjectArray <ViewModel>("ViewModels");
foreach (var viewModel in viewModels)
{
VoidMethod(viewModel);
// Do something here maybe?
}
// STEP 2: LOAD THE VIEWS
stream.TypeResolver = this;
// Clear the reference objects because the view-models will share the same identifier with views.
stream.ReferenceObjects.Clear();
var views = stream.DeserializeObjectArray <ViewBase>("Views").ToArray();
foreach (var view in views)
{
VoidMethod(view);
// Do something here maybe?
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeInt("Point", this.Point);
stream.SerializeFloat("AddTime", this.AddTime);
stream.SerializeFloat("Expire", this.Expire);
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.IsAmazing = stream.DeserializeBool("IsAmazing");;
this._TheStateMachineProperty.SetState(stream.DeserializeString("TheStateMachine"));
this.SomeUnityType = stream.DeserializeVector3("SomeUnityType");;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeInt("ActerId", this.ActerId);
stream.SerializeBool("Ready", this.Ready);
stream.SerializeBool("IsLocal", this.IsLocal);
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize)
{
stream.SerializeArray("Cubes", this.Cubes);
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize)
{
stream.SerializeArray("PlayerItems", this.PlayerItems);
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize)
{
stream.SerializeArray("PanelCollection", this.PanelCollection);
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
if (stream.DeepSerialize)
{
this.PlayerItems.Clear();
this.PlayerItems.AddRange(stream.DeserializeObjectArray <PlayerItemViewModel>("PlayerItems"));
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
if (stream.DeepSerialize)
{
this.PanelCollection.Clear();
this.PanelCollection.AddRange(stream.DeserializeObjectArray <PanelViewModel>("PanelCollection"));
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeFloat("FireRate", this.FireRate);
if (stream.DeepSerialize)
{
stream.SerializeArray("Projectiles", this.Projectiles);
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
if (stream.DeepSerialize)
{
this.Cubes.Clear();
this.Cubes.AddRange(stream.DeserializeObjectArray <CubeViewModel>("Cubes"));
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeInt("CurrentWeaponIndex", this.CurrentWeaponIndex);
if (stream.DeepSerialize)
{
stream.SerializeArray("Weapons", this.Weapons);
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.FireRate = stream.DeserializeFloat("FireRate");;
if (stream.DeepSerialize)
{
this.Projectiles.Clear();
this.Projectiles.AddRange(stream.DeserializeObjectArray <BaseProjectileViewModel>("Projectiles"));
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeFloat("Life", this.Life);
if (stream.DeepSerialize)
{
stream.SerializeObject("PowerUp", this.PowerUp);
}
stream.SerializeVector3("Position", this.Position);
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.Life = stream.DeserializeFloat("Life");;
if (stream.DeepSerialize)
{
this.PowerUp = stream.DeserializeObject <PowerUpBaseViewModel>("PowerUp");
}
this.Position = stream.DeserializeVector3("Position");;
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
if (stream.DeepSerialize)
{
this.CanvasRoot = stream.DeserializeObject <CanvasRootViewModel>("CanvasRoot");
}
;
this._UIFlowStatusProperty.SetState(stream.DeserializeString("UIFlowStatus"));
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.CurrentWeaponIndex = stream.DeserializeInt("CurrentWeaponIndex");;
if (stream.DeepSerialize)
{
this.Weapons.Clear();
this.Weapons.AddRange(stream.DeserializeObjectArray <FPSWeaponViewModel>("Weapons"));
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize)
{
stream.SerializeObject("CanvasRoot", this.CanvasRoot);
}
;
stream.SerializeString("UIFlowStatus", this.UIFlowStatus.Name);;
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this._WavesStateProperty.SetState(stream.DeserializeString("WavesState"));
this.WaveKills = stream.DeserializeInt("WaveKills");;
this.KillsToNextWave = stream.DeserializeInt("KillsToNextWave");;
this.CurrentWave = stream.DeserializeInt("CurrentWave");;
this.SpawnWaitSeconds = stream.DeserializeInt("SpawnWaitSeconds");;
this.EnemiesSpawned = stream.DeserializeInt("EnemiesSpawned");;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeString("WavesState", this.WavesState.Name);;
stream.SerializeInt("WaveKills", this.WaveKills);
stream.SerializeInt("KillsToNextWave", this.KillsToNextWave);
stream.SerializeInt("CurrentWave", this.CurrentWave);
stream.SerializeInt("SpawnWaitSeconds", this.SpawnWaitSeconds);
stream.SerializeInt("EnemiesSpawned", this.EnemiesSpawned);
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.State = (TodoEditorState)stream.DeserializeInt("State");;
if (stream.DeepSerialize)
{
this.TodoItem = stream.DeserializeObject <TodoItemViewModel>("TodoItem");
}
;
this.OriginContent = stream.DeserializeString("OriginContent");;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeInt("State", (int)this.State);;
if (stream.DeepSerialize)
{
stream.SerializeObject("TodoItem", this.TodoItem);
}
;
stream.SerializeString("OriginContent", this.OriginContent);
}
public void SaveState(ISerializerStorage storage, ISerializerStream stream)
{
stream.DeepSerialize = true;
stream.TypeResolver = this;
// Serialize The View Models
stream.SerializeArray("ViewModels", PersistantViewModels);
// Clear the references so view-models and view of the same identifier don't match up
stream.ReferenceObjects.Clear();
// Serialize the views
stream.SerializeArray("Views", PersistantViews);
// Serialize the stream
storage.Save(stream);
}
/// <summary>
/// Load's a set of view-models from a storage medium based on a stream.
/// </summary>
/// <param name="storage">This is for loading the stream from a persistant medium. e.g. File, String..etc</param>
/// <param name="stream">The type of stream to serialize as. eg. Json,Xml,Binary</param>
public void Load(ISerializerStorage storage, ISerializerStream stream)
{
stream.DependencyContainer = Container;
storage.Load(stream);
//stream.TypeResolver = new ViewStateResolver(this);
// ReSharper disable once UnusedVariable
var vms = stream.DeserializeObjectArray <ViewModel>("ViewModels").ToArray();
foreach (var vm in vms)
{
this[vm.Identifier] = vm;
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize)
{
stream.SerializeObject("CurrentPlayer", this.CurrentPlayer);
}
stream.SerializeInt("Score", this.Score);
stream.SerializeInt("Kills", this.Kills);
stream.SerializeString("String1", this.String1);
if (stream.DeepSerialize)
{
stream.SerializeArray("Enemies", this.Enemies);
}
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize)
{
stream.SerializeObject("Player", this.Player);
}
stream.SerializeVector3("SpawnPoint", this.SpawnPoint);
stream.SerializeBool("GameOver", this.GameOver);
stream.SerializeString("NotificationText", this.NotificationText);
if (stream.DeepSerialize)
{
stream.SerializeArray("Asteroids", this.Asteroids);
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
if (stream.DeepSerialize)
{
this.Player = stream.DeserializeObject <PlayerShipViewModel>("Player");
}
this.SpawnPoint = stream.DeserializeVector3("SpawnPoint");;
this.GameOver = stream.DeserializeBool("GameOver");;
this.NotificationText = stream.DeserializeString("NotificationText");;
if (stream.DeepSerialize)
{
this.Asteroids.Clear();
this.Asteroids.AddRange(stream.DeserializeObjectArray <AsteroidViewModel>("Asteroids"));
}
}
public SerializerLimit ExecuteLargePropertyTest(IStreamTest test, ISerializerStream serializerStream)
{
for(int size = DataGenerationStepInBytes * 2; size < 1024 * 1024 * MaxPropertySizeInMB; size+=DataGenerationStepInBytes)
{
Console.Write($"{test.TestName}->{serializerStream.Name}, size={size.Bytes()}...");
var limit = test.Execute(serializerStream,SinglePropertyData[size],size);
if (limit == null)
Console.WriteLine("succeeded");
else
{
Console.WriteLine("failed.");
Console.WriteLine("Reason -> " + limit.FailureException.GetType().FullName);
Console.WriteLine("Starting looking for exact limit...");
const int megabyteInBytes = 1024 * 1024;
for(int exactSize = size - megabyteInBytes; exactSize >= (size - DataGenerationStepInBytes); exactSize-= megabyteInBytes)
{
Console.Write($"Checking {exactSize.Bytes()}...");
limit = test.Execute(serializerStream, new SinglePropertyObject
{
Bytes = Data.Take(exactSize)
}, exactSize);
if (limit != null)
Console.WriteLine("failed");
else
{
Console.WriteLine("succeeded!");
Console.WriteLine($"Maximum workable large property for the serializer can be {exactSize.Bytes().ToString("#.##")}");
return limit;
}
}
return limit;
}
}
return null;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeBool("IsActive", this.IsActive);
}
public void Save(ISerializerStream stream)
{
Result = Encoding.UTF8.GetString(stream.Save());
}
public void Save(ISerializerStream stream)
{
File.WriteAllBytes(Filename, stream.Save());
}
public override void Read(ISerializerStream stream) {
base.Read(stream);
this.GameState = (GameState)stream.DeserializeInt("GameState");;
this.HexGridMatching = stream.DeserializeString("HexGridMatching");;
this.SoldierCount = stream.DeserializeInt("SoldierCount");;
this.EnemyCount = stream.DeserializeInt("EnemyCount");;
if (stream.DeepSerialize) {
this.Soldier.Clear();
this.Soldier.AddRange(stream.DeserializeObjectArray<SoldierViewModel>("Soldier"));
}
if (stream.DeepSerialize) {
this.Enemy.Clear();
this.Enemy.AddRange(stream.DeserializeObjectArray<EnemyViewModel>("Enemy"));
}
if (stream.DeepSerialize) {
this.Memebers.Clear();
this.Memebers.AddRange(stream.DeserializeObjectArray<EntityViewModel>("Memebers"));
}
}
public void Load(ISerializerStream stream)
{
stream.Load(Encoding.UTF8.GetBytes(Result));
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this._InGameStateProperty.SetState(stream.DeserializeString("InGameState"));
this.IdleAnimalsCount = stream.DeserializeInt("IdleAnimalsCount");;
this.NullAnimalsCount = stream.DeserializeInt("NullAnimalsCount");;
this.IsDropping = stream.DeserializeBool("IsDropping");;
if (stream.DeepSerialize) {
this.AnimalCollections.Clear();
this.AnimalCollections.AddRange(stream.DeserializeObjectArray<AnimalViewModel>("AnimalCollections"));
}
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.AnimalType = (AnimalType)stream.DeserializeInt("AnimalType");;
this.SameCount = stream.DeserializeInt("SameCount");;
this.needDestroy = stream.DeserializeBool("needDestroy");;
this._AnimalStateProperty.SetState(stream.DeserializeString("AnimalState"));
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.TimeLimit = stream.DeserializeFloat("TimeLimit");;
this.Score = stream.DeserializeInt("Score");;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeFloat("TimeLimit", this.TimeLimit);
stream.SerializeInt("Score", this.Score);
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.Point = stream.DeserializeInt("Point");;
this.AddTime = stream.DeserializeFloat("AddTime");;
this.Expire = stream.DeserializeFloat("Expire");;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeInt("Point", this.Point);
stream.SerializeFloat("AddTime", this.AddTime);
stream.SerializeFloat("Expire", this.Expire);
}
public override void Write(ISerializerStream stream) {
base.Write(stream);
stream.SerializeInt("AuthorizationState", (int)this.AuthorizationState);;
}
public void Load(ISerializerStream stream)
{
stream.Load(File.ReadAllBytes(Filename));
}
public override void Write(ISerializerStream stream) {
base.Write(stream);
stream.SerializeInt("SoldierState", (int)this.SoldierState);;
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
}
public override void Read(ISerializerStream stream) {
base.Read(stream);
this.AuthorizationState = (AuthorizationState)stream.DeserializeInt("AuthorizationState");;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeString("InGameState", this.InGameState.Name);;
stream.SerializeInt("IdleAnimalsCount", this.IdleAnimalsCount);
stream.SerializeInt("NullAnimalsCount", this.NullAnimalsCount);
stream.SerializeBool("IsDropping", this.IsDropping);
if (stream.DeepSerialize) stream.SerializeArray("AnimalCollections", this.AnimalCollections);
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeInt("AnimalType", (int)this.AnimalType);;
stream.SerializeInt("SameCount", this.SameCount);
stream.SerializeBool("needDestroy", this.needDestroy);
stream.SerializeString("AnimalState", this.AnimalState.Name);;
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
if (stream.DeepSerialize) stream.SerializeArray("Screens", this.Screens);
}
public override void Write(ISerializerStream stream) {
base.Write(stream);
stream.SerializeFloat("Health", this.Health);
stream.SerializeFloat("Max_Health", this.Max_Health);
stream.SerializeInt("AttackSpeed", this.AttackSpeed);
stream.SerializeInt("Movement", (int)this.Movement);;
stream.SerializeInt("Power", this.Power);
stream.SerializeBool("isAttack", this.isAttack);
stream.SerializeInt("Action", (int)this.Action);;
stream.SerializeInt("MAXROUNDS", this.MAXROUNDS);
stream.SerializeFloat("Physique", this.Physique);
stream.SerializeInt("HitPoint", this.HitPoint);
stream.SerializeInt("WeaponProficieny", this.WeaponProficieny);
stream.SerializeFloat("Dodge", this.Dodge);
stream.SerializeFloat("Hurt", this.Hurt);
stream.SerializeFloat("Dead", this.Dead);
stream.SerializeInt("InitialMorale", this.InitialMorale);
stream.SerializeInt("Prestige", this.Prestige);
stream.SerializeBool("DEBUG", this.DEBUG);
stream.SerializeInt("counter", this.counter);
stream.SerializeInt("Counter", this.Counter);
stream.SerializeInt("UpdatePerRound", this.UpdatePerRound);
stream.SerializeInt("ElementsPerSecond", this.ElementsPerSecond);
stream.SerializeInt("WarTimeLimitInSecond", this.WarTimeLimitInSecond);
stream.SerializeFloat("starttime", this.starttime);
stream.SerializeBool("TimeStarted", this.TimeStarted);
stream.SerializeInt("WeaponProficiency", this.WeaponProficiency);
stream.SerializeInt("moraleStandard", this.moraleStandard);
if (stream.DeepSerialize) stream.SerializeObject("Opponent", this.Opponent);;
stream.SerializeInt("BattleState", (int)this.BattleState);;
stream.SerializeInt("Career", (int)this.Career);;
stream.SerializeBool("Moving", this.Moving);
stream.SerializeInt("Sense", (int)this.Sense);;
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.Volume = stream.DeserializeFloat("Volume");;
}
public override void Write(ISerializerStream stream) {
base.Write(stream);
stream.SerializeInt("GameState", (int)this.GameState);;
stream.SerializeString("HexGridMatching", this.HexGridMatching);
stream.SerializeInt("SoldierCount", this.SoldierCount);
stream.SerializeInt("EnemyCount", this.EnemyCount);
if (stream.DeepSerialize) stream.SerializeArray("Soldier", this.Soldier);
if (stream.DeepSerialize) stream.SerializeArray("Enemy", this.Enemy);
if (stream.DeepSerialize) stream.SerializeArray("Memebers", this.Memebers);
}
public override void Write(ISerializerStream stream)
{
base.Write(stream);
stream.SerializeFloat("Volume", this.Volume);
}
public override void Write(ISerializerStream stream) {
base.Write(stream);
stream.SerializeBool("IsAmazing", this.IsAmazing);
stream.SerializeString("TheStateMachine", this.TheStateMachine.Name);;
stream.SerializeVector3("SomeUnityType", this.SomeUnityType);
}
public override void Read(ISerializerStream stream)
{
base.Read(stream);
this.IsActive = stream.DeserializeBool("IsActive");;
}
public override void Read(ISerializerStream stream) {
base.Read(stream);
this.SoldierState = (SoldierState)stream.DeserializeInt("SoldierState");;
}
public override void Read(ISerializerStream stream) {
base.Read(stream);
this.Health = stream.DeserializeFloat("Health");;
this.Max_Health = stream.DeserializeFloat("Max_Health");;
this.AttackSpeed = stream.DeserializeInt("AttackSpeed");;
this.Movement = (MoveStyle)stream.DeserializeInt("Movement");;
this.Power = stream.DeserializeInt("Power");;
this.isAttack = stream.DeserializeBool("isAttack");;
this.Action = (ActionStyle)stream.DeserializeInt("Action");;
this.MAXROUNDS = stream.DeserializeInt("MAXROUNDS");;
this.Physique = stream.DeserializeFloat("Physique");;
this.HitPoint = stream.DeserializeInt("HitPoint");;
this.WeaponProficieny = stream.DeserializeInt("WeaponProficieny");;
this.Dodge = stream.DeserializeFloat("Dodge");;
this.Hurt = stream.DeserializeFloat("Hurt");;
this.Dead = stream.DeserializeFloat("Dead");;
this.InitialMorale = stream.DeserializeInt("InitialMorale");;
this.Prestige = stream.DeserializeInt("Prestige");;
this.DEBUG = stream.DeserializeBool("DEBUG");;
this.counter = stream.DeserializeInt("counter");;
this.Counter = stream.DeserializeInt("Counter");;
this.UpdatePerRound = stream.DeserializeInt("UpdatePerRound");;
this.ElementsPerSecond = stream.DeserializeInt("ElementsPerSecond");;
this.WarTimeLimitInSecond = stream.DeserializeInt("WarTimeLimitInSecond");;
this.starttime = stream.DeserializeFloat("starttime");;
this.TimeStarted = stream.DeserializeBool("TimeStarted");;
this.WeaponProficiency = stream.DeserializeInt("WeaponProficiency");;
this.moraleStandard = stream.DeserializeInt("moraleStandard");;
if (stream.DeepSerialize) this.Opponent = stream.DeserializeObject<EntityViewModel>("Opponent");;
this.BattleState = (BattleState)stream.DeserializeInt("BattleState");;
this.Career = (Career)stream.DeserializeInt("Career");;
this.Moving = stream.DeserializeBool("Moving");;
this.Sense = (SenseStyle)stream.DeserializeInt("Sense");;
}
