public override BinaryClassChunk Serialize() { BinaryClassChunk binaryClassChunk = base.Serialize(); binaryClassChunk.AddProperty("direction", (object)this.direction); return(binaryClassChunk); }
private Array DeserializeArray(System.Type type, System.Type arrayType, BitBuffer data) { int num = this._data.ReadInt(); Array instance = Activator.CreateInstance(type, (object)num) as Array; for (int index = 0; index < num; ++index) { bool flag = this._data.ReadBool(); object obj = (object)null; if (flag) { if (typeof(BinaryClassChunk).IsAssignableFrom(arrayType)) { BinaryClassChunk binaryClassChunk = BinaryClassChunk.DeserializeHeader(arrayType, this._data, root: false, skipData: true); binaryClassChunk?.Deserialize(); obj = (object)binaryClassChunk; } else { obj = this._data.Read(arrayType); } } instance.SetValue(obj, index); } return(instance); }
public object GetProperty(string id, bool multiple = false) { if (this._extraProperties == null) { return((object)null); } List <object> list = (List <object>)null; this._extraProperties.TryGetValue(id, out list); if (list != null) { foreach (object obj in list) { if (obj is BinaryClassChunk) { BinaryClassChunk binaryClassChunk = obj as BinaryClassChunk; if (binaryClassChunk._result == DeserializeResult.HeaderDeserialized) { binaryClassChunk.Deserialize(); } } if (obj is BitBuffer) { (obj as BitBuffer).SeekToStart(); } if (!multiple) { return(obj); } } } return((object)list); }
public override BinaryClassChunk Serialize() { BinaryClassChunk binaryClassChunk = base.Serialize(); binaryClassChunk.AddProperty("contains", (object)MysteryGun.SerializeTypeProb(this.contains)); return(binaryClassChunk); }
public static T FromData <T>(BitBuffer data) where T : BinaryClassChunk { BinaryClassChunk instance = Activator.CreateInstance(typeof(T), (object[])null) as BinaryClassChunk; instance.SetData(data); return((T)instance); }
public override bool Deserialize(BinaryClassChunk node) { base.Deserialize(node); this.fireDirection = node.GetProperty <float>("fireDirection"); this.firePower = node.GetProperty <float>("firePower"); return(true); }
public override BinaryClassChunk Serialize() { BinaryClassChunk binaryClassChunk = base.Serialize(); binaryClassChunk.AddProperty("frame", (object)(this.graphic as SpriteMap).frame); return(binaryClassChunk); }
public static BinaryClassChunk DeserializeHeader( System.Type t, BitBuffer data, BinaryClassChunk target = null, bool root = true, bool skipData = false) { if (target == null) { target = Activator.CreateInstance(t, (object[])null) as BinaryClassChunk; } try { long num1 = 0; if (root) { num1 = data.ReadLong(); if (num1 != BinaryClassChunk.MagicNumber(t) && num1 != 5033950674723417L) { target._result = DeserializeResult.InvalidMagicNumber; return(target); } target._checksum = data.ReadUInt(); } ushort num2 = data.ReadUShort(); ushort num3 = BinaryClassChunk.ChunkVersion(t); if ((int)num2 != (int)num3 && (!(target is LevelData) || num2 != (ushort)2)) { target._result = (int)num2 <= (int)num3 ? DeserializeResult.FileVersionTooOld : DeserializeResult.FileVersionTooNew; return(target); } if (num2 == (ushort)2 && target is LevelData && data.ReadBool()) { BinaryClassChunk binaryClassChunk = BinaryClassChunk.DeserializeHeader(Editor.GetType(data.ReadString()), data, root: false); if (binaryClassChunk != null && binaryClassChunk._result == DeserializeResult.HeaderDeserialized) { binaryClassChunk.Deserialize(); target._headerDictionary["metaData"] = binaryClassChunk; } } target._magicNumber = num1; target._version = num2; target._size = data.ReadUInt(); target._offset = (uint)data.position; target._data = data; target._result = DeserializeResult.HeaderDeserialized; if (skipData) { data.position = (int)target._offset + (int)target._size; } return(target); } catch (Exception ex) { target._exception = ex; target._result = DeserializeResult.ExceptionThrown; return(target); } }
public void SetData(BitBuffer data) { BinaryClassChunk.DeserializeHeader(this.GetType(), data, this); if (this._result != DeserializeResult.HeaderDeserialized) { return; } this.Deserialize(); }
public override bool Deserialize(BinaryClassChunk node) { base.Deserialize(node); this.stanceSetting = node.GetProperty <int>("stanceSetting"); this.contains = Editor.GetType(node.GetProperty <string>("contains")); this.chestPlate = node.GetProperty <bool>("chestPlate"); this.helmet = node.GetProperty <bool>("helmet"); return(true); }
public void SerializeField(BinaryClassChunk element, string name) { ClassMember member = Editor.GetMember(this.GetType(), name); if (member == null) { return; } element.AddProperty(name, member.GetValue((object)this)); }
public override BinaryClassChunk Serialize() { BinaryClassChunk binaryClassChunk = base.Serialize(); binaryClassChunk.AddProperty("stanceSetting", (object)this.stanceSetting); binaryClassChunk.AddProperty("contains", this.contains != (System.Type)null ? (object)ModLoader.SmallTypeName(this.contains) : (object)""); binaryClassChunk.AddProperty("chestPlate", (object)this.chestPlate); binaryClassChunk.AddProperty("helmet", (object)this.helmet); return(binaryClassChunk); }
public bool Deserialize(BinaryClassChunk node) { this.DeserializeField(node, "trophy"); this.DeserializeField(node, "bestTime"); this.DeserializeField(node, "profileID"); this.DeserializeField(node, "targets"); this.DeserializeField(node, "goodies"); this.DeserializeField(node, "frameID"); this.DeserializeField(node, "frameImage"); return(true); }
public static LevelData LoadLevel(byte[] data) { LevelData levelData = BinaryClassChunk.FromData <LevelData>(new BitBuffer(data, false)); if (levelData != null && levelData.GetResult() != DeserializeResult.InvalidMagicNumber) { return(levelData); } Promise <LevelData> promise = Tasker.Task <LevelData>((Func <LevelData>)(() => DuckFile.ConvertLevel(data))); promise.WaitForComplete(); return(promise.Result); }
public BinaryClassChunk Serialize() { BinaryClassChunk element = new BinaryClassChunk(); this.SerializeField(element, "trophy"); this.SerializeField(element, "bestTime"); this.SerializeField(element, "profileID"); this.SerializeField(element, "targets"); this.SerializeField(element, "goodies"); this.SerializeField(element, "frameID"); this.SerializeField(element, "frameImage"); return(element); }
public override bool Deserialize(BinaryClassChunk node) { if (!Level.symmetry) { return(this.DoDeserialize(node)); } Level.leftSymmetry = true; Level.loadingOppositeSymmetry = false; this.DoDeserialize(node); List <Thing> thingList = new List <Thing>((IEnumerable <Thing>) this._things); Level.loadingOppositeSymmetry = true; Level.leftSymmetry = false; this.DoDeserialize(node); this._things.AddRange((IEnumerable <Thing>)thingList); return(true); }
public static void SaveChunk(BinaryClassChunk doc, string path) { DuckFile.CreatePath(Path.GetDirectoryName(path)); try { if (File.Exists(path)) { File.SetAttributes(path, FileAttributes.Normal); } } catch (Exception ex) { } BitBuffer bitBuffer = doc.Serialize(); FileStream fileStream = File.Create(path); fileStream.Write(bitBuffer.buffer, 0, bitBuffer.lengthInBytes); fileStream.Close(); DuckFile.SaveCloudFile(path); }
public T GetChunk <T>(string name) { BinaryClassChunk binaryClassChunk = (BinaryClassChunk)null; if (!this._headerDictionary.TryGetValue(name, out binaryClassChunk)) { if (this._data != null) { return(default(T)); } binaryClassChunk = Activator.CreateInstance(typeof(T), (object[])null) as BinaryClassChunk; binaryClassChunk._result = DeserializeResult.Success; this._headerDictionary[name] = binaryClassChunk; } if (binaryClassChunk == null) { return(default(T)); } if (binaryClassChunk._result == DeserializeResult.HeaderDeserialized) { binaryClassChunk.Deserialize(); } return((T)(Object)binaryClassChunk); }
public BitBuffer Serialize(BitBuffer data = null, bool root = true) { if (data == null) { data = new BitBuffer(false); } this._serializedData = data; if (data.allowPacking) { throw new Exception("This class does not support serialization with a packed bit buffer. Construct the buffer with allowPacking set to false."); } System.Type type1 = this.GetType(); List <ClassMember> members = Editor.GetMembers(type1); List <BinaryClassMember> binaryClassMemberList = new List <BinaryClassMember>(); foreach (ClassMember classMember in members) { if (!classMember.isPrivate && (classMember.type.IsEnum || classMember.type.IsPrimitive || (classMember.type.Equals(typeof(string)) || typeof(BinaryClassChunk).IsAssignableFrom(classMember.type)) || classMember.type.IsArray || classMember.type.IsGenericType && (classMember.type.GetGenericTypeDefinition() == typeof(List <>) || classMember.type.GetGenericTypeDefinition() == typeof(HashSet <>)))) { object obj = classMember.GetValue((object)this); if (classMember.type.IsEnum) { obj = (object)(int)obj; } if (obj != null) { BinaryClassMember binaryClassMember = new BinaryClassMember() { name = classMember.name, data = obj }; binaryClassMemberList.Add(binaryClassMember); } } } if (this._extraProperties != null) { foreach (KeyValuePair <string, List <object> > extraProperty in (MultiMap <string, object, List <object> >) this._extraProperties) { if (extraProperty.Value != null) { foreach (object obj1 in extraProperty.Value) { object obj2 = obj1; if (obj2.GetType().IsEnum) { obj2 = (object)(int)obj2; } BinaryClassMember binaryClassMember = new BinaryClassMember() { name = "@" + extraProperty.Key, data = obj2, extra = true }; binaryClassMemberList.Add(binaryClassMember); } } } } if (root) { long val = BinaryClassChunk.MagicNumber(type1); data.Write(val); data.Write(0U); } data.Write(BinaryClassChunk.ChunkVersion(type1)); int position1 = data.position; data.Write(0U); data.Write((ushort)binaryClassMemberList.Count); foreach (BinaryClassMember binaryClassMember in binaryClassMemberList) { data.Write(binaryClassMember.name); if (binaryClassMember.extra) { byte val = 0; System.Type type2 = binaryClassMember.data.GetType(); if (BinaryClassMember.typeMap.TryGetValue(type2, out val)) { val = (byte)((int)val << 1 | 1); } data.Write(val); if (val == (byte)0) { data.Write(ModLoader.SmallTypeName(type2)); } } int position2 = data.position; data.Write(0U); if (binaryClassMember.data is BinaryClassChunk) { (binaryClassMember.data as BinaryClassChunk).Serialize(data, false); } else if (binaryClassMember.data is Array) { this.SerializeArray(binaryClassMember.data as Array, binaryClassMember.data.GetType().GetElementType(), data); } else if (binaryClassMember.data.GetType().IsGenericType&& binaryClassMember.data.GetType().GetGenericTypeDefinition() == typeof(List <>)) { IList data1 = binaryClassMember.data as IList; Array array = (Array) new object[data1.Count]; data1.CopyTo(array, 0); this.SerializeArray(array, binaryClassMember.data.GetType().GetGenericArguments()[0], data); } else if (binaryClassMember.data.GetType().IsGenericType&& binaryClassMember.data.GetType().GetGenericTypeDefinition() == typeof(HashSet <>)) { IEnumerable data1 = binaryClassMember.data as IEnumerable; List <object> objectList = new List <object>(); foreach (object obj in data1) { objectList.Add(obj); } object[] array = new object[objectList.Count]; objectList.CopyTo(array, 0); this.SerializeArray((Array)array, binaryClassMember.data.GetType().GetGenericArguments()[0], data); } else { data.Write(binaryClassMember.data); } int position3 = data.position; data.position = position2; data.Write((uint)(position3 - position2 - 4)); data.position = position3; } int position4 = data.position; data.position = position1; data.Write((uint)(position4 - position1 - 4)); if (root) { this._checksum = Editor.Checksum(data.buffer); data.position = 8; data.Write(this._checksum); } data.position = position4; return(data); }
public static T LoadChunk <T>(string path) where T : BinaryClassChunk { DuckFile.CreatePath(Path.GetDirectoryName(path)); DuckFile.PrepareToLoadCloudFile(path); return(!File.Exists(path) ? default(T) : BinaryClassChunk.FromData <T>(new BitBuffer(File.ReadAllBytes(path), 0, false))); }
public override BinaryClassChunk Serialize() { BinaryClassChunk binaryClassChunk = new BinaryClassChunk(); binaryClassChunk.AddProperty("type", (object)ModLoader.SmallTypeName(this.GetType())); binaryClassChunk.AddProperty("blockType", (object)ModLoader.SmallTypeName(this._type)); BitBuffer bitBuffer1 = new BitBuffer(false); bitBuffer1.Write(this._things.Count); if (typeof(AutoBlock).IsAssignableFrom(this._type)) { foreach (Thing thing in this._things) { AutoBlock autoBlock = thing as AutoBlock; autoBlock.groupedWithNeighbors = false; autoBlock.neighborsInitialized = false; } BitBuffer bitBuffer2 = new BitBuffer(false); bitBuffer2.Write((ushort)0); ushort val = 0; foreach (Thing thing in this._things) { AutoBlock autoBlock = thing as AutoBlock; autoBlock.InitializeNeighbors(); bitBuffer1.Write(thing.x); bitBuffer1.Write(thing.y); bitBuffer1.Write((byte)thing.frame); bitBuffer1.Write(autoBlock.upBlock != null ? (short)this._things.IndexOf((Thing)autoBlock.upBlock) : (short)-1); bitBuffer1.Write(autoBlock.downBlock != null ? (short)this._things.IndexOf((Thing)autoBlock.downBlock) : (short)-1); bitBuffer1.Write(autoBlock.rightBlock != null ? (short)this._things.IndexOf((Thing)autoBlock.rightBlock) : (short)-1); bitBuffer1.Write(autoBlock.leftBlock != null ? (short)this._things.IndexOf((Thing)autoBlock.leftBlock) : (short)-1); BlockGroup blockGroup = autoBlock.GroupWithNeighbors(false); if (blockGroup != null) { bitBuffer2.Write(blockGroup.x); bitBuffer2.Write(blockGroup.y); bitBuffer2.Write(blockGroup.collisionOffset.x); bitBuffer2.Write(blockGroup.collisionOffset.y); bitBuffer2.Write(blockGroup.collisionSize.x); bitBuffer2.Write(blockGroup.collisionSize.y); bitBuffer2.Write(blockGroup.blocks.Count <Block>()); foreach (Block block in blockGroup.blocks) { bitBuffer2.Write((short)this._things.IndexOf((Thing)block)); } ++val; } } bitBuffer2.position = 0; bitBuffer2.Write(val); foreach (Thing thing in this._things) { AutoBlock autoBlock = thing as AutoBlock; autoBlock.groupedWithNeighbors = false; autoBlock.neighborsInitialized = false; } if (bitBuffer2.lengthInBytes > 2) { binaryClassChunk.AddProperty("groupData", (object)bitBuffer2); } } else { foreach (Thing thing in this._things) { bitBuffer1.Write(thing.x); bitBuffer1.Write(thing.y); bitBuffer1.Write((byte)thing.frame); } } binaryClassChunk.AddProperty("data", (object)bitBuffer1); return(binaryClassChunk); }
private bool DoDeserialize(BinaryClassChunk node) { System.Type type = Editor.GetType(node.GetProperty <string>("blockType")); if (type == (System.Type)null) { return(false); } bool flag1 = typeof(AutoBlock).IsAssignableFrom(type); this._things = new List <Thing>(); BitBuffer property1 = node.GetProperty <BitBuffer>("data"); if (!typeof(AutoBlock).IsAssignableFrom(type)) { flag1 = false; } List <AutoBlock> autoBlockList = new List <AutoBlock>(); int num1 = property1.ReadInt(); for (int index = 0; index < num1; ++index) { float num2 = property1.ReadFloat(); float num3 = property1.ReadFloat(); int num4 = (int)property1.ReadByte(); bool flag2 = Level.flipH; if (Level.loadingOppositeSymmetry) { flag2 = !flag2; } if (flag2) { num2 = (float)(192.0 - (double)num2 - 16.0); } Thing thing = Editor.CreateThing(type); if (flag2 && thing is AutoBlock) { (thing as AutoBlock).needsRefresh = true; (thing as AutoBlock).isFlipped = true; } if (thing is BackgroundTile) { if (flag2) { (thing as BackgroundTile).isFlipped = true; } (thing as BackgroundTile).oppositeSymmetry = !Level.loadingOppositeSymmetry; } if (flag2 && thing is AutoPlatform) { (thing as AutoPlatform).needsRefresh = true; } thing.x = num2; thing.y = num3; thing.placed = true; if (thing.isStatic) { this._isStatic = true; } if (flag1) { short num5 = property1.ReadShort(); short num6 = property1.ReadShort(); short num7 = property1.ReadShort(); short num8 = property1.ReadShort(); AutoBlock autoBlock = thing as AutoBlock; autoBlock.northIndex = (int)num5; autoBlock.southIndex = (int)num6; if (flag2) { autoBlock.westIndex = (int)num7; autoBlock.eastIndex = (int)num8; } else { autoBlock.eastIndex = (int)num7; autoBlock.westIndex = (int)num8; } autoBlockList.Add(autoBlock); } bool flag3 = true; if (Level.symmetry) { if (Level.leftSymmetry && (double)num2 > 80.0) { flag3 = false; } if (!Level.leftSymmetry && (double)num2 < 96.0) { flag3 = false; } } if (flag3) { thing.frame = num4; this._things.Add(thing); } } if (flag1 && !(Level.current is Editor)) { foreach (AutoBlock autoBlock in autoBlockList) { if (autoBlock.northIndex != -1) { autoBlock.upBlock = (Block)autoBlockList[autoBlock.northIndex]; } if (autoBlock.southIndex != -1) { autoBlock.downBlock = (Block)autoBlockList[autoBlock.southIndex]; } if (autoBlock.eastIndex != -1) { autoBlock.rightBlock = (Block)autoBlockList[autoBlock.eastIndex]; } if (autoBlock.westIndex != -1) { autoBlock.leftBlock = (Block)autoBlockList[autoBlock.westIndex]; } autoBlock.neighborsInitialized = true; } BitBuffer property2 = node.GetProperty <BitBuffer>("groupData"); if (property2 != null) { ushort num2 = property2.ReadUShort(); int num3; for (int index1 = 0; index1 < (int)num2; index1 = num3 + 1) { BlockGroup blockGroup = new BlockGroup(); blockGroup.position = new Vec2(property2.ReadFloat(), property2.ReadFloat()); bool flag2 = Level.flipH; if (Level.loadingOppositeSymmetry) { flag2 = !flag2; } if (flag2) { blockGroup.position.x = (float)(192.0 - (double)blockGroup.position.x - 16.0); } blockGroup.collisionOffset = new Vec2(property2.ReadFloat(), property2.ReadFloat()); blockGroup.collisionSize = new Vec2(property2.ReadFloat(), property2.ReadFloat()); float num4 = 88f; if (Level.symmetry) { if (Level.leftSymmetry) { if ((double)blockGroup.left < (double)num4 && (double)blockGroup.right > (double)num4) { float num5 = blockGroup.right - num4; float x = blockGroup.collisionSize.x - num5; blockGroup.position.x -= num5; blockGroup.position.x += x / 2f; blockGroup.collisionSize = new Vec2(x, blockGroup.collisionSize.y); blockGroup.collisionOffset = new Vec2((float)-((double)x / 2.0), blockGroup.collisionOffset.y); blockGroup.right = num4; } } else { num4 = 88f; if ((double)blockGroup.right > (double)num4 && (double)blockGroup.left < (double)num4) { float num5 = num4 - blockGroup.left; float x = blockGroup.collisionSize.x - num5; blockGroup.position.x += num5; blockGroup.position.x -= x / 2f; blockGroup.collisionSize = new Vec2(x, blockGroup.collisionSize.y); blockGroup.collisionOffset = new Vec2((float)-((double)x / 2.0), blockGroup.collisionOffset.y); blockGroup.left = num4; } } } int num6 = property2.ReadInt(); for (int index2 = 0; index2 < num6; ++index2) { int index3 = (int)property2.ReadShort(); if (index3 >= 0) { AutoBlock autoBlock = autoBlockList[index3]; bool flag3 = true; if (Level.symmetry) { if (Level.leftSymmetry && (double)autoBlock.x > 80.0) { flag3 = false; } if (!Level.leftSymmetry && (double)autoBlock.x < 96.0) { flag3 = false; } } if (flag3) { autoBlock.groupedWithNeighbors = true; blockGroup.Add((Block)autoBlock); blockGroup.physicsMaterial = autoBlock.physicsMaterial; blockGroup.thickness = autoBlock.thickness; } this._things.Remove((Thing)autoBlock); } } num3 = index1 + num6; if (flag2) { blockGroup.needsRefresh = true; } if (Level.symmetry) { if (Level.leftSymmetry && (double)blockGroup.left < (double)num4) { this._things.Add((Thing)blockGroup); } else if (!Level.leftSymmetry && (double)blockGroup.right > (double)num4) { this._things.Add((Thing)blockGroup); } } else { this._things.Add((Thing)blockGroup); } } } } return(true); }
public void DeserializeField(BinaryClassChunk node, string name) => Editor.GetMember(this.GetType(), name)?.SetValue((object)this, node.GetProperty(name));
public override bool Deserialize(BinaryClassChunk node) { base.Deserialize(node); this.contains = MysteryGun.DeserializeTypeProb(node.GetProperty <string>("contains")); return(true); }
public void Add(BinaryClassChunk obj) => this.objects.Add(obj);
public bool Deserialize() { if (this._data == null) { this._result = DeserializeResult.NoData; return(false); } if (this._result == DeserializeResult.Success) { return(true); } try { this._data.position = (int)this._offset; ushort num1 = this._data.ReadUShort(); for (int index = 0; index < (int)num1; ++index) { string str = this._data.ReadString(); ClassMember classMember = (ClassMember)null; System.Type key = (System.Type)null; if (str.StartsWith("@")) { if (this._extraProperties == null) { this._extraProperties = new MultiMap <string, object>(); } byte num2 = this._data.ReadByte(); if (((int)num2 & 1) != 0) { byte num3 = (byte)((uint)num2 >> 1); BinaryClassMember.typeMap.TryGetKey(num3, out key); } else { key = Editor.GetType(this._data.ReadString()); } str = str.Substring(1, str.Length - 1); } else { classMember = Editor.GetMember(this.GetType(), str); if (classMember != null) { key = classMember.type; } } uint num4 = this._data.ReadUInt(); if (key != (System.Type)null) { int position = this._data.position; if (typeof(BinaryClassChunk).IsAssignableFrom(key)) { BinaryClassChunk binaryClassChunk = BinaryClassChunk.DeserializeHeader(key, this._data, root: false); if (classMember == null) { this._extraProperties.Add(str, (object)binaryClassChunk); } else { this._headerDictionary[str] = binaryClassChunk; } this._data.position = position + (int)num4; } else if (key.IsArray) { Array array = this.DeserializeArray(key, key.GetElementType(), this._data); if (classMember == null) { this._extraProperties.Add(str, (object)array); } else { classMember.SetValue((object)this, (object)array); } } else if (key.IsGenericType && key.GetGenericTypeDefinition() == typeof(List <>)) { Array array = this.DeserializeArray(typeof(object[]), key.GetGenericArguments()[0], this._data); IList instance = Activator.CreateInstance(key) as IList; foreach (object obj in array) { instance.Add(obj); } if (classMember == null) { this._extraProperties.Add(str, (object)instance); } else { classMember.SetValue((object)this, (object)instance); } } else if (key.IsGenericType && key.GetGenericTypeDefinition() == typeof(HashSet <>)) { Array array = this.DeserializeArray(typeof(object[]), key.GetGenericArguments()[0], this._data); IList instance1 = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(key.GetGenericArguments()[0])); foreach (object obj in array) { instance1.Add(obj); } object instance2 = Activator.CreateInstance(key, (object)instance1); if (classMember == null) { this._extraProperties.Add(str, instance2); } else { classMember.SetValue((object)this, instance2); } } else { object element = !key.IsEnum ? this._data.Read(key, false) : (object)this._data.ReadInt(); if (classMember == null) { this._extraProperties.Add(str, element); } else { classMember.SetValue((object)this, element); } } } else { this._data.position += (int)num4; } } } catch (Exception ex) { this._exception = ex; this._result = DeserializeResult.ExceptionThrown; return(false); } this._result = DeserializeResult.Success; return(true); }
public override bool Deserialize(BinaryClassChunk node) { base.Deserialize(node); this.direction = node.GetProperty <int>("direction"); return(true); }
public static long MagicNumber <T>() => BinaryClassChunk.MagicNumber(typeof(T));
public override bool Deserialize(BinaryClassChunk node) { base.Deserialize(node); (this.graphic as SpriteMap).frame = node.GetProperty <int>("frame"); return(true); }
public static ushort ChunkVersion <T>() => BinaryClassChunk.ChunkVersion(typeof(T));