示例#1
0
        internal void Read(IBitReader reader)
        {
            reader.PushFrameLength(24);

            this._Unknown1 = reader.ReadUInt32();

            // probably a primitive type
            {
                reader.PushFrameLength(24);

                reader.ReadBytes(this._Unknown2);
                reader.ReadBytes(this._Unknown3);
                reader.ReadBytes(this._Unknown4);
                reader.ReadBytes(this._Unknown5);
                this._Unknown6 = reader.ReadUInt32();
                this._Unknown7 = reader.ReadUInt32();

                // probably another primitive type
                {
                    var unknown8Length = reader.ReadUInt32();
                    this._Unknown8 = reader.ReadBytes((int)unknown8Length);
                }

                reader.PopFrameLength();
            }

            reader.PopFrameLength();
        }
        internal void Read(IBitReader reader)
        {
            reader.PushFrameLength(24);
            this._Unknown1.Clear();
            var unknown1Count = reader.ReadUInt16();

            for (int i = 0; i < unknown1Count; i++)
            {
                reader.PushFrameLength(24);
                var unknown1Key   = reader.ReadUInt32();
                var unknown1Value = reader.ReadBytes(16);
                reader.PopFrameLength();
                this._Unknown1.Add(new KeyValuePair <uint, byte[]>(unknown1Key, unknown1Value));
            }
            this._Unknown2.Clear();
            var unknown2Count = reader.ReadUInt16();

            for (int i = 0; i < unknown2Count; i++)
            {
                reader.PushFrameLength(24);
                var unknown2Key   = reader.ReadUInt32();
                var unknown2Value = reader.ReadBytes(16);
                reader.PopFrameLength();
                this._Unknown2.Add(new KeyValuePair <uint, byte[]>(unknown2Key, unknown2Value));
            }
            reader.PopFrameLength();
        }
示例#3
0
 internal void Read(IBitReader reader, uint version)
 {
     this._ActiveSkills.Clear();
     if (version >= 11)
     {
         reader.PushFrameLength(24);
         this._Level                      = reader.ReadInt32();
         this._SkillPointCount            = reader.ReadInt32();
         this._LowestPurchasableSkillCost = reader.ReadInt32();
         this._SkillPointPerLevel         = reader.ReadInt32();
         this._CharacterId                = reader.ReadInt32();
         this._MaximumShields             = reader.ReadInt32();
         this._MaximumHealth              = reader.ReadInt32();
         var activeSkillCount = reader.ReadUInt16();
         for (int i = 0; i < activeSkillCount; i++)
         {
             reader.PushFrameLength(24);
             var activeSkill = new PartyMemberActiveSkill();
             activeSkill.LineHash    = reader.ReadInt32();
             activeSkill.LineRank    = reader.ReadInt32();
             activeSkill.GroupHash   = reader.ReadInt32();
             activeSkill.GroupTypeId = reader.ReadInt32();
             this._ActiveSkills.Add(activeSkill);
             reader.PopFrameLength();
         }
         reader.PopFrameLength();
     }
     else
     {
         reader.PushFrameLength(24);
         throw new NotImplementedException();
         reader.PopFrameLength();
     }
 }
 internal override void Read5(IBitReader reader)
 {
     base.Read5(reader);
     reader.PushFrameLength(24);
     this._Unknown1.Read(reader);
     reader.PopFrameLength();
     reader.PushFrameLength(24);
     this._Unknown2.Read(reader);
     reader.PopFrameLength();
 }
 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();
     reader.PopFrameLength();
 }
 internal override void Read2(IBitReader reader)
 {
     base.Read2(reader);
     reader.PushFrameLength(24);
     this._Unknown.Read(reader, this.ReadVersion);
     reader.PopFrameLength();
 }
示例#7
0
 internal override void Read2(IBitReader reader)
 {
     base.Read2(reader);
     reader.PushFrameLength(24);
     this._Plot.Read(reader);
     reader.PopFrameLength();
 }
示例#8
0
 internal void Read(IBitReader reader)
 {
     reader.PushFrameLength(24);
     this._Unknown1 = reader.ReadUInt32();
     this._Unknown2 = reader.ReadBoolean();
     reader.PopFrameLength();
 }
示例#9
0
        internal void Read(IBitReader reader)
        {
            reader.PushFrameLength(24);
            this._Unknown1 = reader.ReadFloat32();
            this._Unknown2 = reader.ReadUInt32();
            this._Unknown3.Clear();
            var unknown3Count = reader.ReadUInt16();

            for (int i = 0; i < unknown3Count; i++)
            {
                var unknown3 = new EventTrackerUnknown2();
                unknown3.Read(reader);
                this._Unknown3.Add(unknown3);
            }
            this._Unknown4.Clear();
            var unknown4Count = reader.ReadUInt16();

            for (int i = 0; i < unknown4Count; i++)
            {
                var unknown4 = new EventTrackerUnknown2();
                unknown4.Read(reader);
                this._Unknown4.Add(unknown4);
            }
            reader.PopFrameLength();
        }
示例#10
0
 internal void Read(IBitReader reader, ushort version)
 {
     reader.PushFrameLength(24);
     ReadList(reader, this._Unknown1, version);
     ReadList(reader, this._Unknown2, version);
     reader.PopFrameLength();
 }
示例#11
0
        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 void Read(IBitReader reader)
 {
     reader.PushFrameLength(24);
     this._CurrentValue = reader.ReadFloat32();
     this._MaximumValue = reader.ReadFloat32();
     this._Unknown      = reader.ReadBoolean();
     reader.PopFrameLength();
 }
        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();
        }
示例#14
0
 internal void Read(IBitReader reader)
 {
     reader.PushFrameLength(24);
     reader.ReadBytes(this._Unknown1);
     this._Unknown2 = reader.ReadUInt32();
     this._Unknown3 = reader.ReadUInt32();
     this._Unknown4 = reader.ReadUInt32();
     reader.PopFrameLength();
 }
示例#15
0
        internal void Read(IBitReader reader, uint version)
        {
            reader.PushFrameLength(24);
            var dataBytesLength = reader.ReadUInt32();

            this._DataBytes = reader.ReadBytes((int)dataBytesLength);
            this._Unknown1  = version >= 6 && reader.ReadBoolean();
            this._Unknown2  = version >= 6 && reader.ReadBoolean();
            reader.PopFrameLength();
        }
 internal void Read(IBitReader reader)
 {
     reader.PushFrameLength(24);
     this._Unknown1 = reader.ReadUInt32();
     this._Unknown2 = reader.ReadBoolean();
     this._Unknown3 = reader.ReadUInt32();
     // TODO(gibbed): figure out what this actually
     this._Unknown4 = reader.ReadBytes(Math.Max(1, (int)((this._Unknown3 + 31) >> 5)) * 4);
     reader.PopFrameLength();
 }
示例#17
0
        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();
        }
示例#18
0
 public void Read(IBitReader reader)
 {
     reader.PushFrameLength(24);
     this._Unknown1 = reader.ReadUInt32();
     for (int i = 0; i < 5; i++)
     {
         this._Healths[i].Read(reader);
     }
     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();
        }
示例#20
0
        internal override void Read4(IBitReader reader)
        {
            base.Read4(reader);
            var unknown1Length = reader.PushFrameLength(24);

            if (unknown1Length > 0)
            {
                this._Unknown.Read(reader);
            }
            reader.PopFrameLength();
        }
        internal override void Read4(IBitReader reader)
        {
            base.Read4(reader);
            var length = reader.PushFrameLength(24);

            if (length > 0)
            {
                this._Squad.Read(reader);
            }
            reader.PopFrameLength();
        }
示例#22
0
        public override void Read(IBitReader reader, ushort version)
        {
            this._Unknown4 = reader.ReadBoolean();

            var modCount = Math.Min(5, (int)reader.ReadUInt16());

            for (int i = 0; i < modCount; i++)
            {
                reader.PushFrameLength(24);
                if (version >= 9)
                {
                    var modId = reader.ReadUInt32();
                    if (modId != 0)
                    {
                        reader.PushFrameLength(24);
                        var modItem = Components.InventoryComponent.ReadItemData(reader, version);
                        reader.PopFrameLength();
                        this._Mods.Add(new KeyValuePair <uint, ItemData>(modId, modItem));
                    }
                }
                else
                {
                    throw new NotSupportedException();
                }
                reader.PopFrameLength();
            }

            var augmentationCount = reader.ReadUInt16();

            for (int i = 0; i < augmentationCount; i++)
            {
                reader.PushFrameLength(24);
                var augmentationItemHash = reader.ReadUInt32();
                this._AugmentationItemHashes.Add(augmentationItemHash);
                reader.PopFrameLength();
            }

            this._CustomName = reader.ReadString();

            base.Read(reader, version);
        }
 internal void Read(IBitReader reader)
 {
     reader.PushFrameLength(24);
     this._Id = reader.ReadUInt32();
     if (this._Id != 0)
     {
         this._Unknown1 = reader.ReadUInt32();
         this._Unknown2 = reader.ReadUInt32();
         this._Unknown3 = reader.ReadUInt32();
     }
     reader.PopFrameLength();
 }
示例#24
0
 internal void Read(IBitReader reader, ushort version)
 {
     reader.PushFrameLength(24);
     this._Unknown1 = reader.ReadUInt32();
     this._Unknown2.Read(reader, version);
     if (version >= 4)
     {
         this._Unknown3 = reader.ReadString();
     }
     this._Unknown4 = reader.ReadUInt32();
     reader.PopFrameLength();
 }
 public override void Read(IBitReader reader, ushort version)
 {
     if (version >= 1)
     {
         reader.PushFrameLength(24);
         this._Unknown5 = reader.ReadUInt32();
         this._Unknown6 = reader.ReadUInt32();
         this._Unknown7 = reader.ReadBoolean();
         this._Unknown8 = reader.ReadUInt32();
         reader.PopFrameLength();
     }
     base.Read(reader, version);
 }
        internal void Read(IBitReader reader)
        {
            reader.PushFrameLength(24);
            this._Unknown = reader.ReadInt32();
            var skillRankCount = reader.ReadUInt16();

            this._SkillRanks.Clear();
            for (int k = 0; k < skillRankCount; k++)
            {
                this._SkillRanks.Add(reader.ReadInt32());
            }
            reader.PopFrameLength();
        }
示例#27
0
        public void Read(IBitReader reader, int version)
        {
            var unknown1Count = reader.ReadUInt16();

            this._Unknown.Clear();
            for (int i = 0; i < unknown1Count; i++)
            {
                reader.PushFrameLength(24);
                var unknown1Key   = reader.ReadUInt32();
                var unknown1Value = reader.ReadBoolean();
                this._Unknown.Add(new KeyValuePair <uint, bool>(unknown1Key, unknown1Value));
                reader.PopFrameLength();
            }
        }
        internal void Read(IBitReader reader)
        {
            reader.PushFrameLength(24);
            this._ProfileId = reader.ReadInt32();
            var powerCount = reader.ReadUInt16();

            this._Powers.Clear();
            for (int i = 0; i < powerCount; i++)
            {
                var power = new PresetPower();
                power.Read(reader);
                this._Powers.Add(power);
            }
            reader.PopFrameLength();
        }
        internal void Read(IBitReader reader)
        {
            reader.PushFrameLength(24);
            this._Unknown1 = reader.ReadUInt32();
            this._Loot.Clear();
            var lootCount = reader.ReadUInt16();

            for (int i = 0; i < lootCount; i++)
            {
                var lootObject = new LootObject();
                lootObject.Read(reader);
                this._Loot.Add(lootObject);
            }
            reader.PopFrameLength();
        }
示例#30
0
        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();
        }