コード例 #1
0
        private bool LoadFile(System.IO.Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic = stream.ReadAscii(8);

            if (magic != "T8BTMA  ")
            {
                return(false);
            }

            uint arteCount   = stream.ReadUInt32().FromEndian(endian);
            uint stringStart = stream.ReadUInt32().FromEndian(endian);

            ArteList = new List <Arte>((int)arteCount);
            for (uint i = 0; i < arteCount; ++i)
            {
                Arte a = new Arte(stream, stringStart, endian, bits);
                ArteList.Add(a);
            }

            ArteIdDict = new Dictionary <uint, Arte>(ArteList.Count);
            foreach (var arte in ArteList)
            {
                ArteIdDict.Add(arte.InGameID, arte);
            }

            return(true);
        }
コード例 #2
0
 public T8BTMA(System.IO.Stream stream, Util.Endianness endian, Util.Bitness bits)
 {
     if (!LoadFile(stream, endian, bits))
     {
         throw new Exception("Loading T8BTMA failed!");
     }
 }
コード例 #3
0
 public TOVNPCT(Stream stream, Util.Endianness endian, Util.Bitness bits)
 {
     if (!LoadFile(stream, endian, bits))
     {
         throw new Exception("Loading TOVNPCT failed!");
     }
 }
コード例 #4
0
 public UnknownSkitData4(System.IO.Stream stream, Util.Endianness endian, Util.Bitness bits)
 {
     ScenarioBegin = stream.ReadUInt32().FromEndian(endian);
     ScenarioEnd   = stream.ReadUInt32().FromEndian(endian);
     DataBegin     = stream.ReadUInt(bits, endian);
     DataCount     = stream.ReadUInt32().FromEndian(endian);
 }
コード例 #5
0
        private bool LoadFile(System.IO.Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic = stream.ReadAscii(8);

            if (magic != "TO8MAPL\0")
            {
                return(false);
            }

            uint filesize             = stream.ReadUInt32().FromEndian(endian);
            uint liststart            = stream.ReadUInt32().FromEndian(endian);
            uint mapcount             = stream.ReadUInt32().FromEndian(endian);
            uint textstart            = stream.ReadUInt32().FromEndian(endian);
            uint littleEndianFilesize = stream.ReadUInt32().FromEndian(Util.Endianness.LittleEndian);               // ???

            MapNames = new List <MapName>();

            stream.Position = liststart;
            for (uint i = 0; i < mapcount; ++i)
            {
                MapNames.Add(new MapName(stream, textstart, endian, bits));
            }

            return(true);
        }
コード例 #6
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic               = stream.ReadAscii(8);
            uint   strategySetCount    = stream.ReadUInt32().FromEndian(endian);
            uint   strategyOptionCount = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart      = stream.ReadUInt32().FromEndian(endian);

            StrategySetList = new List <StrategySet>((int)strategySetCount);
            for (uint i = 0; i < strategySetCount; ++i)
            {
                StrategySet ss = new StrategySet(stream, refStringStart, endian, bits);
                StrategySetList.Add(ss);
            }
            StrategyOptionList = new List <StrategyOption>((int)strategyOptionCount);
            for (uint i = 0; i < strategyOptionCount; ++i)
            {
                StrategyOption so = new StrategyOption(stream, refStringStart, endian, bits);
                StrategyOptionList.Add(so);
            }

            StrategyOptionDict = new Dictionary <uint, StrategyOption>(StrategyOptionList.Count);
            foreach (var option in StrategyOptionList)
            {
                StrategyOptionDict.Add(option.InGameID, option);
            }

            return(true);
        }
コード例 #7
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic                    = stream.ReadAscii(8);
            uint   fileSize                 = stream.ReadUInt32().FromEndian(endian);
            uint   skitInfoCount            = stream.ReadUInt32().FromEndian(endian);
            uint   skitInfoOffset           = stream.ReadUInt32().FromEndian(endian);
            uint   conditionForwarderCount  = stream.ReadUInt32().FromEndian(endian);
            uint   conditionForwarderOffset = stream.ReadUInt32().FromEndian(endian);
            uint   conditionCount           = stream.ReadUInt32().FromEndian(endian);
            uint   conditionOffset          = stream.ReadUInt32().FromEndian(endian);
            uint   uCount4                  = stream.ReadUInt32().FromEndian(endian);
            uint   uOffset4                 = stream.ReadUInt32().FromEndian(endian);
            uint   uCount5                  = stream.ReadUInt32().FromEndian(endian);
            uint   uOffset5                 = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart           = stream.ReadUInt32().FromEndian(endian);

            SkitInfoList    = new List <SkitInfo>((int)skitInfoCount);
            stream.Position = skitInfoOffset;
            for (uint i = 0; i < skitInfoCount; ++i)
            {
                SkitInfo s = new SkitInfo(stream, refStringStart, endian, bits);
                SkitInfoList.Add(s);
            }

            SkitConditionForwarderList = new List <SkitConditionForwarder>((int)conditionForwarderCount);
            stream.Position            = conditionForwarderOffset;
            for (uint i = 0; i < conditionForwarderCount; ++i)
            {
                var s = new SkitConditionForwarder(stream, endian, bits);
                SkitConditionForwarderList.Add(s);
            }

            SkitConditionList = new List <SkitCondition>((int)conditionCount);
            stream.Position   = conditionOffset;
            for (uint i = 0; i < conditionCount; ++i)
            {
                var s = new SkitCondition(stream, endian);
                SkitConditionList.Add(s);
            }

            UnknownSkitData4List = new List <UnknownSkitData4>((int)uCount4);
            stream.Position      = uOffset4;
            for (uint i = 0; i < uCount4; ++i)
            {
                var s = new UnknownSkitData4(stream, endian, bits);
                UnknownSkitData4List.Add(s);
            }

            UnknownSkitData5List = new List <UnknownSkitData5>((int)uCount5);
            stream.Position      = uOffset5;
            for (uint i = 0; i < uCount5; ++i)
            {
                var s = new UnknownSkitData5(stream, endian, bits);
                UnknownSkitData5List.Add(s);
            }

            return(true);
        }
コード例 #8
0
 // NPC dialogue definition files, I think?
 public TOVNPCT(String filename, Util.Endianness endian, Util.Bitness bits)
 {
     using (Stream stream = new System.IO.FileStream(filename, FileMode.Open, System.IO.FileAccess.Read)) {
         if (!LoadFile(stream, endian, bits))
         {
             throw new Exception("Loading TOVNPCT failed!");
         }
     }
 }
コード例 #9
0
 public ShopDefinition(System.IO.Stream stream, Util.Endianness endian, Util.Bitness bits)
 {
     InGameID    = stream.ReadUInt32().FromEndian(endian);
     StringDicID = stream.ReadUInt32().FromEndian(endian);
     stream.ReadUInt32().FromEndian(endian);               // second instance of string dic id?
     stream.ReadUInt32().FromEndian(endian);               // always empty?
     OnTrigger    = stream.ReadUInt32().FromEndian(endian);
     ChangeToShop = stream.ReadUInt32().FromEndian(endian);
     stream.DiscardBytes(4 + bits.NumberOfBytes());               // always empty?
 }
コード例 #10
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic          = stream.ReadAscii(8);
            uint   entryCount     = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart = stream.ReadUInt32().FromEndian(endian);

            GradeShopEntryList = new List <GradeShopEntry>((int)entryCount);
            for (uint i = 0; i < entryCount; ++i)
            {
                GradeShopEntry e = new GradeShopEntry(stream, refStringStart, endian, bits);
                GradeShopEntryList.Add(e);
            }

            return(true);
        }
コード例 #11
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic          = stream.ReadAscii(8);
            uint   floorInfoCount = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart = stream.ReadUInt32().FromEndian(endian);

            FloorList = new List <FloorInfo>((int)floorInfoCount);
            for (uint i = 0; i < floorInfoCount; ++i)
            {
                FloorInfo fi = new FloorInfo(stream, refStringStart, endian, bits);
                FloorList.Add(fi);
            }

            return(true);
        }
コード例 #12
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic          = stream.ReadAscii(8);
            uint   infoCount      = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart = stream.ReadUInt32().FromEndian(endian);

            TreasureInfoList = new List <TreasureInfo>((int)infoCount);
            for (uint i = 0; i < infoCount; ++i)
            {
                TreasureInfo ti = new TreasureInfo(stream, refStringStart, endian, bits);
                TreasureInfoList.Add(ti);
            }

            return(true);
        }
コード例 #13
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic          = stream.ReadAscii(8);
            uint   fileSize       = stream.ReadUInt32().FromEndian(endian);
            uint   dataStart      = stream.ReadUInt32().FromEndian(endian);
            uint   dataCount      = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart = stream.ReadUInt32().FromEndian(endian);

            stream.Position = dataStart;
            NpcFileList     = new List <NpcFileReference>((int)dataCount);
            for (uint i = 0; i < dataCount; ++i)
            {
                NpcFileReference n = new NpcFileReference(stream, refStringStart, endian, bits);
                NpcFileList.Add(n);
            }

            return(true);
        }
コード例 #14
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic            = stream.ReadAscii(8);
            uint   fileSize         = stream.ReadUInt32().FromEndian(endian);
            uint   unknownDataStart = stream.ReadUInt32().FromEndian(endian);
            uint   unknownDataCount = stream.ReadUInt32().FromEndian(endian);
            uint   npcDefStart      = stream.ReadUInt32().FromEndian(endian);
            uint   npcDefCount      = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart   = stream.ReadUInt32().FromEndian(endian);

            stream.Position = npcDefStart;
            NpcDefList      = new List <NpcDialogueDefinition>((int)npcDefCount);
            for (uint i = 0; i < npcDefCount; ++i)
            {
                NpcDialogueDefinition n = new NpcDialogueDefinition(stream, refStringStart, endian, bits);
                NpcDefList.Add(n);
            }

            return(true);
        }
コード例 #15
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic          = stream.ReadAscii(8);
            uint   skillCount     = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart = stream.ReadUInt32().FromEndian(endian);

            SkillList = new List <Skill>((int)skillCount);
            for (uint i = 0; i < skillCount; ++i)
            {
                Skill s = new Skill(stream, refStringStart, endian, bits);
                SkillList.Add(s);
            }

            SkillIdDict = new Dictionary <uint, Skill>(SkillList.Count);
            foreach (Skill s in SkillList)
            {
                SkillIdDict.Add(s.InGameID, s);
            }

            return(true);
        }
コード例 #16
0
        private bool LoadFile(Stream stream, Util.Endianness endian, Util.Bitness bits)
        {
            string magic           = stream.ReadAscii(8);
            uint   enemyGroupCount = stream.ReadUInt32().FromEndian(endian);
            uint   refStringStart  = stream.ReadUInt32().FromEndian(endian);

            EnemyGroupList = new List <EnemyGroup>((int)enemyGroupCount);
            for (uint i = 0; i < enemyGroupCount; ++i)
            {
                EnemyGroup s = new EnemyGroup(stream, refStringStart, endian, bits);
                EnemyGroupList.Add(s);
            }

            EnemyGroupIdDict = new Dictionary <uint, EnemyGroup>(EnemyGroupList.Count);
            foreach (EnemyGroup e in EnemyGroupList)
            {
                EnemyGroupIdDict.Add(e.InGameID, e);
            }

            return(true);
        }
コード例 #17
0
        public NpcFileReference(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            ulong refStringLocation1 = stream.ReadUInt(bits, endian);
            ulong refStringLocation2 = stream.ReadUInt(bits, endian);

            Filesize = stream.ReadUInt32().FromEndian(endian);
            stream.ReadUInt32();

            Map      = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringLocation1));
            Filename = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringLocation2));
        }
コード例 #18
0
 public static SCFOMBIN.SCFOMBIN LoadBattleTextFile(string gameDataPath, string filename, GameLocale locale, GameVersion version, Util.Endianness endian, Util.GameTextEncoding encoding, Util.Bitness bits)
 {
     if (!version.Is360())
     {
         uint ptrDiff = 0x1888;
         if (filename.StartsWith("BTL_XTM"))
         {
             ptrDiff = 0x1B4C;
         }
         var bin = new SCFOMBIN.SCFOMBIN(GenerateWebsite.TryGetBattleScenarioFile(gameDataPath, filename, locale, version), endian, encoding, ptrDiff);
         return(bin);
     }
     else
     {
         var bin = new ScenarioFile.ScenarioFile(GenerateWebsite.TryGetBattleScenarioFile(gameDataPath, filename, locale, version), encoding, endian, bits);
         var btl = new SCFOMBIN.SCFOMBIN();
         btl.EntryList = bin.EntryList;
         return(btl);
     }
 }
コード例 #19
0
        public StrategySet(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            uint entrySize = stream.ReadUInt32().FromEndian(endian);

            ID = stream.ReadUInt32().FromEndian(endian);
            ulong refStringLocation = stream.ReadUInt(bits, endian);

            NameStringDicID = stream.ReadUInt32().FromEndian(endian);
            DescStringDicID = stream.ReadUInt32().FromEndian(endian);

            StrategyDefaults = new uint[8, 9];
            for (uint x = 0; x < 8; ++x)
            {
                for (uint y = 0; y < 9; ++y)
                {
                    StrategyDefaults[x, y] = stream.ReadUInt32().FromEndian(endian);
                }
            }

            ID2 = stream.ReadUInt32().FromEndian(endian);

            UnknownFloats1 = new float[9];
            for (int i = 0; i < UnknownFloats1.Length; ++i)
            {
                UnknownFloats1[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }
            UnknownFloats2 = new float[9];
            for (int i = 0; i < UnknownFloats2.Length; ++i)
            {
                UnknownFloats2[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringLocation));
        }
コード例 #20
0
        public GradeShopEntry(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            uint entrySize = stream.ReadUInt32().FromEndian(endian);

            if (entrySize != (0x18 + bits.NumberOfBytes()))
            {
                throw new Exception("Unexpected GradeShopEntry size.");
            }

            ID       = stream.ReadUInt32().FromEndian(endian);
            InGameID = stream.ReadUInt32().FromEndian(endian);
            ulong refStringLocation = stream.ReadUInt(bits, endian);

            NameStringDicID = stream.ReadUInt32().FromEndian(endian);
            DescStringDicID = stream.ReadUInt32().FromEndian(endian);
            GradeCost       = stream.ReadUInt32().FromEndian(endian);

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringLocation));
        }
コード例 #21
0
        private bool LoadFile(Stream stream, uint shopStart, uint shopCount, uint itemStart, uint itemCount, Util.Endianness endian, Util.Bitness bits)
        {
            ShopDefinitions = new List <ShopDefinition>((int)shopCount);
            ShopItems       = new List <ShopItem>((int)itemCount);

            for (int i = 0; i < shopCount; ++i)
            {
                stream.Position = shopStart + i * (28 + bits.NumberOfBytes());
                var shop = new ShopDefinition(stream, endian, bits);
                ShopDefinitions.Add(shop);
            }

            for (int i = 0; i < itemCount; ++i)
            {
                stream.Position = itemStart + i * 56;
                var item = new ShopItem(stream, endian);
                ShopItems.Add(item);
            }

            foreach (var shop in ShopDefinitions)
            {
                shop.ShopItems = ShopItems.Where(x => x.ShopID == shop.InGameID).ToArray();
            }

            ShopDictionary = new Dictionary <uint, ShopDefinition>();
            foreach (var shop in ShopDefinitions)
            {
                ShopDictionary.Add(shop.InGameID, shop);
            }

            return(true);
        }
コード例 #22
0
        public StrategyOption(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            uint entrySize = stream.ReadUInt32().FromEndian(endian);

            Category = stream.ReadUInt32().FromEndian(endian);
            InGameID = stream.ReadUInt32().FromEndian(endian);
            ulong refStringLocation = stream.ReadUInt(bits, endian);

            NameStringDicID = stream.ReadUInt32().FromEndian(endian);
            DescStringDicID = stream.ReadUInt32().FromEndian(endian);
            Characters      = stream.ReadUInt32().FromEndian(endian);
            ID        = stream.ReadUInt32().FromEndian(endian);
            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringLocation));
        }
コード例 #23
0
        public EnemyGroup(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            uint entryLength = stream.ReadUInt32().FromEndian(endian);

            ID          = stream.ReadUInt32().FromEndian(endian);
            StringDicID = stream.ReadUInt32().FromEndian(endian);
            InGameID    = stream.ReadUInt32().FromEndian(endian);
            ulong refLoc = stream.ReadUInt(bits, endian);

            EnemyIDs = new int[8];
            for (int i = 0; i < EnemyIDs.Length; ++i)
            {
                EnemyIDs[i] = (int)stream.ReadUInt32().FromEndian(endian);
            }

            UnknownFloats = new float[8];
            for (int i = 0; i < UnknownFloats.Length; ++i)
            {
                UnknownFloats[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }
            PosX = new float[8];
            for (int i = 0; i < PosX.Length; ++i)
            {
                PosX[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }
            PosY = new float[8];
            for (int i = 0; i < PosY.Length; ++i)
            {
                PosY[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }
            Scale = new float[8];
            for (int i = 0; i < Scale.Length; ++i)
            {
                Scale[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }

            SomeFlag    = stream.ReadUInt32().FromEndian(endian);
            UnknownInts = new uint[8];
            for (int i = 0; i < UnknownInts.Length; ++i)
            {
                UnknownInts[i] = stream.ReadUInt32().FromEndian(endian);
            }

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refLoc));
        }
コード例 #24
0
 public ShopData(Stream stream, uint shopStart, uint shopCount, uint itemStart, uint itemCount, Util.Endianness endian, Util.Bitness bits)
 {
     if (!LoadFile(stream, shopStart, shopCount, itemStart, itemCount, endian, bits))
     {
         throw new Exception("Loading ShopData failed!");
     }
 }
コード例 #25
0
 public SkitConditionForwarder(System.IO.Stream stream, Util.Endianness endian, Util.Bitness bits)
 {
     SkitConditionReference = stream.ReadUInt(bits, endian);
     SkitConditionCount     = stream.ReadUInt32().FromEndian(endian);
 }
コード例 #26
0
        public static Dictionary <string, SCFOMBIN.SCFOMBIN> LoadBattleText(string gameDataPath, GameLocale locale, GameVersion version, Util.Endianness endian, Util.GameTextEncoding encoding, Util.Bitness bits)
        {
            var BattleTextFiles = new Dictionary <string, SCFOMBIN.SCFOMBIN>();

            foreach (var filename in GenerateWebsite.GetBattleScenarioFileNames(gameDataPath, locale, version))
            {
                if (filename.StartsWith("BTL_"))
                {
                    var bin = LoadBattleTextFile(gameDataPath, filename, locale, version, endian, encoding, bits);
                    BattleTextFiles.Add(filename, bin);
                }
            }

            return(BattleTextFiles);
        }
コード例 #27
0
        public MapName(System.IO.Stream stream, uint textstart, Util.Endianness endian, Util.Bitness bits)
        {
            ulong p1       = stream.ReadUInt(bits, endian);
            ulong p2       = stream.ReadUInt(bits, endian);
            ulong p3       = stream.ReadUInt(bits, endian);
            ulong unknown4 = stream.ReadUInt(bits, endian);               // either this or unknown5 is bitness affected, probably?

            Util.Assert(unknown4 == 0);

            uint unknown5 = stream.ReadUInt32().FromEndian(endian);

            Util.Assert(unknown5 == 0);
            Unknown6a = stream.ReadUInt16().FromEndian(endian).AsSigned();
            uint unknown6b = stream.ReadUInt16().FromEndian(endian);

            Util.Assert(unknown6b == 0);
            uint unknown7 = stream.ReadUInt32().FromEndian(endian);

            Util.Assert(unknown7 == 0);
            uint unknown8 = stream.ReadUInt32().FromEndian(endian);

            Util.Assert(unknown8 == 0);

            Name1 = stream.ReadAsciiNulltermFromLocationAndReset((long)(textstart + p1));
            Name2 = stream.ReadAsciiNulltermFromLocationAndReset((long)(textstart + p2));
            Name3 = stream.ReadAsciiNulltermFromLocationAndReset((long)(textstart + p3));
        }
コード例 #28
0
 public ShopData(String filename, uint shopStart, uint shopCount, uint itemStart, uint itemCount, Util.Endianness endian, Util.Bitness bits)
 {
     using (Stream stream = new System.IO.FileStream(filename, FileMode.Open, System.IO.FileAccess.Read)) {
         if (!LoadFile(stream, shopStart, shopCount, itemStart, itemCount, endian, bits))
         {
             throw new Exception("Loading ShopData failed!");
         }
     }
 }
コード例 #29
0
        public FloorInfo(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            uint atLeastBytes = (0x10 + 2 * (bits.NumberOfBytes()));

            EntrySize = stream.ReadUInt32().FromEndian(endian);
            if (EntrySize < atLeastBytes)
            {
                throw new Exception("This file confuses me.");
            }

            uint  unknown2 = stream.ReadUInt32().FromEndian(endian);
            uint  unknown3 = stream.ReadUInt32().FromEndian(endian);
            ulong unknown4 = stream.ReadUInt(bits, endian);
            uint  unknown5 = stream.ReadUInt32().FromEndian(endian);
            ulong unknown6 = stream.ReadUInt(bits, endian);

            if (EntrySize > atLeastBytes)
            {
                stream.DiscardBytes(EntrySize - atLeastBytes);
            }

            RefString1 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + unknown4));
            RefString2 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + unknown6));
        }
コード例 #30
0
        public TreasureInfo(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            EntrySize         = stream.ReadUInt32().FromEndian(endian);
            ID                = stream.ReadUInt32().FromEndian(endian);
            IDAgain           = stream.ReadUInt32().FromEndian(endian);
            RefStringLocation = stream.ReadUInt(bits, endian);

            ChestTypes = new uint[4];
            for (int i = 0; i < ChestTypes.Length; ++i)
            {
                ChestTypes[i] = stream.ReadUInt32().FromEndian(endian);
            }

            ChestPositions = new float[8];
            for (int i = 0; i < ChestPositions.Length; ++i)
            {
                ChestPositions[i] = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            }

            Items = new uint[12];
            for (int i = 0; i < Items.Length; ++i)
            {
                Items[i] = stream.ReadUInt32().FromEndian(endian);
            }
            Chances = new uint[12];
            for (int i = 0; i < Chances.Length; ++i)
            {
                Chances[i] = stream.ReadUInt32().FromEndian(endian);
            }

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + RefStringLocation));
        }