public uint ShouldReadAByte(int length, byte[] data)
{
_stream = new MemoryStream(data);
_br = new BitReader32(_stream);
uint actual;
_br.Peek(length, out actual);
return actual;
}
public void Read(IBitReader reader, int version)
{
this._Health = reader.ReadFloat32();
this._Unknown2 = reader.ReadBoolean();
this._Unknown3 = reader.ReadBoolean();
this._Shields = reader.ReadFloat32();
this._Unknown5 = reader.ReadUInt32();
this._Unknown6 = reader.ReadUInt32();
this._Unknown7 = reader.ReadUInt32();
this._Unknown8 = reader.ReadFloat32();
this._Unknown9 = reader.ReadUInt32();
this._Unknown10 = reader.ReadUInt32();
this._Unknown11 = reader.ReadUInt32();
this._Unknown12 = reader.ReadFloat32();
}
public static void ReadStringList(this IBitReader reader, List <string> list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
list.Clear();
var count = reader.ReadUInt16();
for (int i = 0; i < count; i++)
{
list.Add(reader.ReadString());
}
}
public void TestThatWhenNumberOfBitsIs9AndArrayHas65536ElementsFixedSaveModeCanReadWhatItWrote()
{
var longArray = SaveModesTestsCommon.GetRandom65536Array();
var expectedBitsToRead = GetExpectedBitsToRead(longArray);
using (bitWriter = SaveModesTestsCommon.GetBitWriter(outputFilePath))
fixedSaveMode.WriteValues(longArray, bitWriter);
int[] returnedArray;
using (bitReader = SaveModesTestsCommon.GetBitReader(outputFilePath))
returnedArray = fixedSaveMode.ReadValues(expectedBitsToRead, bitReader);
CollectionAssert.AreEqual(longArray, returnedArray);
}
internal void Read(IBitReader reader)
{
reader.PushFrameLength(24);
this._Unknown1 = reader.ReadUInt32();
this._Unknown2.Clear();
var unknown2Count = reader.ReadUInt16();
for (int i = 0; i < unknown2Count; i++)
{
var unknown2 = new DestructionUnknown5();
unknown2.Read(reader);
this._Unknown2.Add(unknown2);
}
reader.PopFrameLength();
}
internal void Read(IBitReader reader)
{
reader.PushFrameLength(24);
reader.ReadBytes(this._Unknown1);
this._Unknown2.Clear();
var unknown2Count = reader.ReadUInt16();
for (int i = 0; i < unknown2Count; i++)
{
var unknown2 = new WorldMapUnknown1();
unknown2.Read(reader);
this._Unknown2.Add(unknown2);
}
reader.PopFrameLength();
}
internal override void Read3(IBitReader reader, ushort arg1)
{
base.Read3(reader, arg1);
reader.PushFrameLength(24);
if (arg1 >= 2)
{
this._NextItemId = reader.ReadUInt32();
}
this._HasActiveSquad = arg1 < 3 || reader.ReadBoolean();
if (this._HasActiveSquad == true)
{
this._ActiveSquad.Read(reader);
}
reader.PopFrameLength();
}
internal void Read(IBitReader reader)
{
this._Unknown1 = reader.ReadUInt32();
this._Unknown2.Clear();
if (this._Unknown1 >= 1)
{
var unknown2Count = reader.ReadUInt16();
for (int i = 0; i < unknown2Count; i++)
{
var unknown2 = new CodexListUnknown1();
unknown2.Read(reader);
this._Unknown2.Add(unknown2);
}
}
}
public static ClassSkills Read(IBitReader reader, int playerClass)
{
var classSkills = new ClassSkills
{
Header = reader.ReadUInt16()
};
uint offset = SKILL_OFFSETS[playerClass];
for (uint i = 0; i < SKILL_COUNT; i++)
{
var skill = ClassSkill.Read(offset + i, reader.ReadByte());
classSkills.Skills.Add(skill);
}
return(classSkills);
}
public static int ReadBitSequence(IBitReader reader, out long value, int length)
{
value = 0L;
for (int index = 0; index < length; ++index)
{
bool bit;
if (reader.ReadBit(out bit) != 1)
{
return(index);
}
long num = (bit ? 1L : 0L) << index;
value |= num;
}
return(length);
}
public Command[] Decode(IBitReader reader)
{
byte num1 = reader != null?reader.ReadByte() : throw new ArgumentNullException(nameof(reader));
Command[] commandArray = new Command[1]
{
CommandEncoding.Instance.Decode(reader)
};
byte num2 = reader.ReadByte();
if (num1 != num2)
{
throw new ApplicationException("Incorrect number of commands");
}
return(commandArray);
}
internal override void Read4(IBitReader reader)
{
base.Read4(reader);
var unknown1Count = reader.ReadUInt16();
this._Unknown.Clear();
for (int i = 0; i < unknown1Count; i++)
{
reader.PushFrameLength(24);
var unknown1Key = reader.ReadUInt32();
var unknown1ValueLength = reader.ReadUInt32();
var unknown1Value = reader.ReadBytes((int)unknown1ValueLength);
reader.PopFrameLength();
this._Unknown.Add(new KeyValuePair <uint, byte[]>(unknown1Key, unknown1Value));
}
}
public static WaypointsSection Read(IBitReader reader)
{
var waypointsSection = new WaypointsSection
{
Header = reader.ReadUInt16(),
Version = reader.ReadUInt32(),
Length = reader.ReadUInt16()
};
for (int i = 0; i < waypointsSection._difficulties.Length; i++)
{
waypointsSection._difficulties[i] = WaypointsDifficulty.Read(reader);
}
return(waypointsSection);
}
internal void Read(IBitReader reader, ushort version)
{
reader.PushFrameLength(24);
this._Unknown1 = reader.ReadUInt32();
this._Unknown2 = reader.ReadUInt32();
reader.PushFrameLength(24);
this._Unknown3.Read(reader, version);
reader.PopFrameLength();
reader.PushFrameLength(24);
this._Unknown4.Read(reader, version);
reader.PopFrameLength();
this._Unknown5 = reader.ReadUInt32();
this._Unknown6 = reader.ReadUInt32();
this._Unknown7 = reader.ReadUInt32();
reader.PopFrameLength();
}
public const ulong Signature = 0x0A45564153004246; // 'FB\0SAVE\n'
public virtual void Read(IBitReader reader)
{
var magic = reader.ReadUInt64();
if (magic != Signature)
{
throw new SaveFormatException("invalid save data signature");
}
var hasExtraValue = reader.ReadBoolean();
if (hasExtraValue == true)
{
reader.SkipUInt32(27);
}
}
public void Read(IBitReader reader, ushort version)
{
this._ReadVersion = version;
var count = reader.ReadUInt16();
for (int i = 0; i < count; i++)
{
reader.PushFrameLength(24);
RawItemData itemData;
itemData.Id = reader.ReadUInt32();
itemData.DataLength = (int)reader.ReadUInt32(24);
itemData.DataBytes = reader.ReadBits(itemData.DataLength);
this._Items.Add(itemData);
reader.PopFrameLength();
}
}
public GpsElementExt Decode(IBitReader reader)
{
int x = reader != null?reader.ReadInt32() : throw new ArgumentNullException(nameof(reader));
int y = reader.ReadInt32();
short altitude = (short)Math.Round(reader.ReadInt16() / 10.0);
short angle = (short)Math.Round(reader.ReadUInt16() / 100.0);
byte satellites = reader.ReadByte();
short speed = reader.ReadInt16();
IoProperty ioProperty = IoProperty.Create(500001, reader.ReadByte());
return(new GpsElementExt(new GpsElement(x, y, altitude, speed, angle, satellites), new IoElement(0, new List <IoProperty>(1)
{
ioProperty
})));
}
public static QuestsSection Read(IBitReader reader)
{
var questSection = new QuestsSection
{
Magic = reader.ReadUInt32(),
Header = reader.ReadUInt32(),
Version = reader.ReadUInt32(),
Length = reader.ReadUInt16()
};
for (int i = 0; i < questSection._difficulties.Length; i++)
{
questSection._difficulties[i] = QuestsDifficulty.Read(reader);
}
return(questSection);
}
internal void Read(IBitReader reader, uint version)
{
reader.PushFrameLength(20);
this._Unknown1 = reader.ReadUInt32();
this._Unknown2 = reader.ReadTransform();
if (version >= 5)
{
this._Unknown3 = reader.ReadBoolean();
if (this._Unknown3 == true)
{
this._Unknown4 = reader.ReadGuid();
this._Unknown5 = reader.ReadGuid();
this._Unknown6 = reader.ReadGuid();
}
}
reader.PopFrameLength();
}
internal override void Read1(IBitReader reader, ushort arg1)
{
base.Read1(reader, arg1);
reader.PushFrameLength(24);
this._Unknown.Clear();
var unknown1Count = reader.ReadUInt16();
for (int i = 0; i < unknown1Count; i++)
{
reader.PushFrameLength(24);
var unknown1Key = reader.ReadString();
var unknown1Value = reader.ReadString();
reader.PopFrameLength();
this._Unknown.Add(new KeyValuePair <string, string>(unknown1Key, unknown1Value));
}
reader.PopFrameLength();
}
public int[] ReadValues(long bitsToRead, IBitReader bitReader)
{
bitsToRead -= bitsToRead % numberOfBitsForValue;
var values = new List <int>();
while (bitsToRead > 0)
{
var readValue = bitReader.ReadNBits(numberOfBitsForValue);
var parsedValue = ParseValueToInt(readValue);
values.Add(parsedValue);
bitsToRead -= numberOfBitsForValue;
}
return(values.ToArray());
}
public Command Decode(IBitReader reader)
{
byte num = reader != null?reader.ReadByte() : throw new ArgumentNullException(nameof(reader));
Command command;
if (CommandIdToType.ContainsKey(num))
{
command = ((Command)Activator.CreateInstance(CommandIdToType[num])).Decode(num, reader);
}
else
{
command = new Command(num);
int count = reader.ReadInt32();
command.Data = reader.ReadBytes(count);
}
return(command);
}
internal override void Read4(IBitReader reader)
{
base.Read4(reader);
this._Unknown1 = reader.ReadUInt16();
reader.PushFrameLength(24);
var unknown2Count = reader.ReadUInt16();
this._Unknown2.Clear();
for (int i = 0; i < unknown2Count; i++)
{
reader.PushFrameLength(24);
var unknown2Key = reader.ReadUInt32();
var unknown2Value = reader.ReadUInt32();
reader.PopFrameLength();
this._Unknown2.Add(new KeyValuePair <uint, uint>(unknown2Key, unknown2Value));
}
reader.PopFrameLength();
}
internal void Read(IBitReader reader)
{
reader.PushFrameLength(24);
reader.PushFramePosition(26);
this._Unknown1.Clear();
var unknown1Count = reader.ReadUInt16();
for (int i = 0; i < unknown1Count; i++)
{
var unknown1 = new DestructionUnknown4();
unknown1.Read(reader);
this._Unknown1.Add(unknown1);
}
reader.PopFramePosition();
reader.PushFrameLength(24);
this._Unknown2 = reader.ReadUInt32();
reader.PopFrameLength();
reader.PopFrameLength();
}
public static void ReadStringDictionary(this IBitReader reader, Dictionary <string, string> dictionary)
{
if (dictionary == null)
{
throw new ArgumentNullException("dictionary");
}
dictionary.Clear();
var count = reader.ReadUInt16();
for (var i = 0; i < count; i++)
{
reader.PushFrameLength(24);
var key = reader.ReadString();
var value = reader.ReadString();
reader.PopFrameLength();
dictionary.Add(key, value);
}
}
internal override void Read2(IBitReader reader)
{
base.Read2(reader);
reader.PushFrameLength(24);
if (this.ReadVersion >= 2)
{
reader.PushFrameLength(24);
this._CurrentSystem = reader.ReadGuid();
this._CurrentDestination = reader.ReadGuid();
reader.PopFrameLength();
}
this._Unknown3.Read(reader, this.ReadVersion);
this._Unknown4.Read(reader, this.ReadVersion);
reader.PopFrameLength();
}
public virtual object Decode(Stream stream)
{
IBitReader reader = stream != null?stream.CreateSuitableBitReader() : throw new ArgumentNullException(nameof(stream));
byte num = reader.ReadByte();
if (Id != num)
{
throw new CodecException("Incorrect data codec ID " + num + "; expected " + Id);
}
try
{
return(new TEncoding().Decode(reader));
}
catch (Exception ex)
{
throw new CodecException("Unable to decode", ex);
}
}
private static void ReadList(IBitReader reader, List <KeyValuePair <Guid, uint> > list, ushort version)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
list.Clear();
if (version >= 1)
{
var count = reader.ReadUInt32();
for (int i = 0; i < count; i++)
{
var key = reader.ReadGuid();
var value = reader.ReadUInt32();
list.Add(new KeyValuePair <Guid, uint>(key, value));
}
}
}
public AvlData[] Decode(IBitReader reader)
{
byte num1 = reader != null?reader.ReadByte() : throw new ArgumentNullException(nameof(reader));
TAvlDataEncoding avlDataEncoding = new TAvlDataEncoding();
List <AvlData> avlDataList = new List <AvlData>();
for (int index = 0; index < num1; ++index)
{
avlDataList.Add(avlDataEncoding.Decode(reader));
}
byte num2 = reader.ReadByte();
if (num1 != avlDataList.Count)
{
throw new ApplicationException(string.Format("Incorrect number of data: num1={0}, num2={1}, avlDataArray.Count={2}", num1, num2, avlDataList.Count));
}
return(avlDataList.ToArray());
}
public static NPCDialogSection Read(IBitReader reader)
{
var npcDialogSection = new NPCDialogSection
{
Header = reader.ReadUInt16(),
Length = reader.ReadUInt16()
};
Span <byte> bytes = stackalloc byte[0x30];
reader.ReadBytes(bytes);
using var bits = new InternalBitArray(bytes);
for (int i = 0; i < npcDialogSection._difficulties.Length; i++)
{
npcDialogSection._difficulties[i] = NPCDialogDifficulty.Read(bits);
}
return(npcDialogSection);
}
public AvlData Decode(IBitReader reader)
{
DateTime dateTime = reader != null?DateTimeExt.FromAvl(reader.ReadInt64()) : throw new ArgumentNullException(nameof(reader));
AvlDataPriority priority = AvlDataPriority.Low;
byte num = reader.ReadByte();
if (num > 10 && num <= 20)
{
priority = AvlDataPriority.High;
}
GpsElement gps = DefaultGpsElementEncoding.Instance.Decode(reader);
IoElement data = LegacyIoElementEncoding.Instance.Decode(reader);
if (priority == AvlDataPriority.High)
{
data = new IoElement(-1, data.Properties);
}
return(new AvlData(priority, dateTime, gps, data));
}
