public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
Data = new List <HeroVarId>();
var deserializeList = new DeserializeList(stream, 1);
if (Type.Values == null)
{
Type.SetValuesType(deserializeList.ListType);
}
for (var index1 = 0U; index1 < deserializeList.Count; ++index1)
{
uint index2;
bool b;
int variableId;
deserializeList.GetFieldIndex(out index2, out b, out variableId);
var heroAnyValue = Create(Type.Values);
heroAnyValue.Deserialize(stream);
Data.Add(new HeroVarId(variableId, heroAnyValue));
if (variableId > NextId)
{
NextId = variableId;
}
}
}
public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
stream.Read(out x);
stream.Read(out y);
stream.Read(out z);
}
public override void Serialize(PackedStream2 stream)
{
if (Type.Id == null)
{
throw new SerializingException("Cannot serialize a non-reference");
}
stream.Write(Type.Id.Id);
}
public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
if (Type.Id == null)
{
Type.Id = new DefinitionId();
}
stream.Read(out Type.Id.Id);
}
public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
stream.Read(out Value);
if (Value != 0L)
{
return;
}
Value = -2305320741190498156L;
}
public override void Serialize(PackedStream2 stream)
{
int count = 0;
if (Variables != null)
{
count = Variables.Count;
}
var serializeClass = new SerializeClass(stream, 1, count);
for (int index = 0; index < count; ++index)
{
serializeClass.WriteFieldData(Variables[index].Field.Id, Variables[index].Value.Type.Type,
Variables[index].VariableId);
Variables[index].Value.Serialize(stream);
}
}
public override void Serialize(PackedStream2 stream)
{
var count = 0;
if (Data != null)
{
count = Data.Count;
}
var serializeList = new SerializeList(stream, 1, Type.Values.Type, count);
for (var index = 0; index < count; ++index)
{
serializeList.SetFieldIndex(index, Data[index].VarId);
Data[index].Value.Serialize(stream);
}
}
public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
Data = new Dictionary <HeroVarId, HeroAnyValue>();
var defaultIndexerType = new HeroType(HeroTypes.None);
if (Type.Indexer != null)
{
defaultIndexerType = Type.Indexer;
}
var deserializeLookupList = new DeserializeLookupList(stream, 1, defaultIndexerType);
if (Type.Indexer == null || Type.Indexer.Type == HeroTypes.None)
{
Type.Indexer = deserializeLookupList.indexerType;
}
else
{
deserializeLookupList.indexerType = Type.Indexer;
}
if (Type.Values == null)
{
Type.Values = deserializeLookupList.valueType;
}
else
{
deserializeLookupList.valueType = Type.Values;
}
for (ulong index = 0UL; index < (ulong)deserializeLookupList.Count; ++index)
{
HeroAnyValue key;
int variableId;
deserializeLookupList.GetKey(out key, out variableId);
HeroAnyValue heroAnyValue = Create(Type.Values);
heroAnyValue.Deserialize(stream);
Data[new HeroVarId(variableId, key)] = heroAnyValue;
if (variableId > nextId)
{
nextId = variableId;
}
}
}
public override void Serialize(PackedStream2 stream)
{
int Count = 0;
if (Data != null)
{
Count = Data.Count;
}
var serializeLookupList = new SerializeLookupList(stream, 1, Type, Count);
if (Data == null)
{
return;
}
foreach (var keyValuePair in Data)
{
serializeLookupList.SetKey(keyValuePair.Key.Value, keyValuePair.Key.VarId);
keyValuePair.Value.Serialize(stream);
}
}
public static void SetTypeInJStream(PackedStream2 stream, HeroType type)
{
stream.WriteVersion(0UL);
stream.Write((ulong)type.Type);
switch (type.Type)
{
case HeroTypes.List:
SetTypeInJStream(stream, type.Values);
break;
case HeroTypes.LookupList:
SetTypeInJStream(stream, type.Indexer);
SetTypeInJStream(stream, type.Values);
break;
case HeroTypes.Class:
case HeroTypes.NodeRef:
stream.Write(type.Id.Id);
break;
}
}
public override void Serialize(PackedStream2 stream)
{
ulong num1 = _08;
long num2 = 3735928559L;
stream.Write(_00);
stream.Write(num1);
stream.Write(_0C);
stream.Write(_10);
stream.Write(_18);
stream.Write(_20);
stream.Write(_28);
stream.Write(_30);
stream.Write(num2);
stream.Write(_38);
if (num2 != 3735928559L)
{
return;
}
stream.Write(_40);
stream.Write(_48);
}
public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
Variables = new VariableList();
var deserializeClass = new DeserializeClass(stream, 1);
for (uint index = 0U; index < deserializeClass.Count; ++index)
{
uint type1 = 0U;
int variableId = 0;
ulong fieldId;
int d;
deserializeClass.ReadFieldData(out fieldId, ref type1, ref variableId, out d);
if (d != 2)
{
var type2 = new HeroType((HeroTypes)type1);
var field = new DefinitionId(fieldId);
if (field.Definition != null)
{
var heroFieldDef = field.Definition as HeroFieldDef;
switch (heroFieldDef.FieldType.Type)
{
case HeroTypes.Enum:
case HeroTypes.ScriptRef:
type2.Id = heroFieldDef.FieldType.Id;
break;
case HeroTypes.LookupList:
type2 = heroFieldDef.FieldType;
break;
}
}
HeroAnyValue heroAnyValue = Create(type2);
heroAnyValue.Deserialize(stream);
Variables.Add(new Variable(field, variableId, heroAnyValue));
}
}
}
public static HeroType GetTypeFromJStream(PackedStream2 stream)
{
ulong num;
stream.ReadVersion(out num);
if ((long)num != 0L)
{
throw new InvalidDataException("incorrect header token for creating HeroValueType");
}
ulong id;
stream.Read(out id);
var heroType = new HeroType((HeroTypes)id);
switch (heroType.Type)
{
case HeroTypes.Enum:
case HeroTypes.Class:
case HeroTypes.NodeRef:
stream.Read(out id);
heroType.Id = new DefinitionId(id);
break;
case HeroTypes.List:
heroType.Values = GetTypeFromJStream(stream);
stream.CheckEnd();
break;
case HeroTypes.LookupList:
heroType.Indexer = GetTypeFromJStream(stream);
stream.CheckEnd();
heroType.Values = GetTypeFromJStream(stream);
stream.CheckEnd();
break;
}
return(heroType);
}
public override void Deserialize(PackedStream2 stream)
{
hasValue = true;
stream.Read(out _00);
ulong num1;
stream.Read(out num1);
stream.Read(out _0C);
stream.Read(out _10);
stream.Read(out _18);
stream.Read(out _20);
stream.Read(out _28);
stream.Read(out _30);
long num2;
stream.Read(out num2);
stream.Read(out _38);
if (num2 == 3735928559L)
{
stream.Read(out _40);
stream.Read(out _48);
}
_08 = (uint)num1;
}
public override void Serialize(PackedStream2 stream)
{
stream.Write(Value);
}
public override void Deserialize(PackedStream2 stream)
{
stream.Read(out Value);
}
public virtual void Serialize(PackedStream2 stream)
{
throw new NotImplementedException();
}
public override void Serialize(PackedStream2 stream)
{
stream.Write(x);
stream.Write(y);
stream.Write(z);
}
public void Serialize()
{
variables = new VariableList();
if (!isProto)
{
Decompress();
int startIndex = version != 1 ? 40 : 36;
uint num1 = BitConverter.ToUInt32(Data, startIndex);
ushort num2 = BitConverter.ToUInt16(Data, startIndex + 4);
serializedData = new byte[num1];
Array.Copy(Data, num2, serializedData, 0L, num1);
_2A = BitConverter.ToUInt16(Data, startIndex + 6);
streamStyle = Data[startIndex + 8];
_2D = (byte)(Data[startIndex + 9] & 3U);
}
if (serializedData.Length == 0)
{
return;
}
byte[] bytes = Encoding.ASCII.GetBytes("azalie");
byte num = 0;
for (int index = 0; index < serializedData.Length; ++index)
{
if (bytes[num] == serializedData[index] || bytes[num] == serializedData[index] + 97 - 65)
{
++num;
if (num == bytes.Length)
{
Console.WriteLine(Name);
break;
}
}
else
{
num = 0;
}
}
var stream = new PackedStream2(streamStyle, serializedData);
var deserializeClass = new DeserializeClass(stream, 1);
for (uint index = 0U; index < deserializeClass.Count; ++index)
{
uint type1 = 0U;
int variableId = 0;
ulong fieldId;
int d;
deserializeClass.ReadFieldData(out fieldId, ref type1, ref variableId, out d);
if (d != 2)
{
var type2 = new HeroType((HeroTypes)type1);
var field = new DefinitionId(fieldId);
if (field.Definition != null)
{
type2 = (field.Definition as HeroFieldDef).FieldType;
}
HeroAnyValue heroAnyValue = HeroAnyValue.Create(type2);
heroAnyValue.Deserialize(stream);
Variables.Add(new Variable(field, variableId, heroAnyValue));
}
}
}
