public MapName(System.IO.Stream stream, uint textstart, EndianUtils.Endianness endian, BitUtils.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));
        }
        public NpcDialogueDefinition(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.Bitness bits)
        {
            Unknown1    = stream.ReadUInt32().FromEndian(endian);
            Unknown2    = stream.ReadUInt32().FromEndian(endian);
            StringDicId = stream.ReadUInt32().FromEndian(endian);
            Unknown4    = stream.ReadUInt32().FromEndian(endian);

            Unknown5a1 = (byte)stream.ReadByte();
            Unknown5a2 = (byte)stream.ReadByte();
            Unknown5b1 = (byte)stream.ReadByte();
            Unknown5b2 = (byte)stream.ReadByte();
            Unknown6a  = (short)stream.ReadUInt16().FromEndian(endian);
            Unknown6b  = (short)stream.ReadUInt16().FromEndian(endian);
            Unknown7a1 = (byte)stream.ReadByte();
            Unknown7a2 = (byte)stream.ReadByte();
            Unknown7b  = stream.ReadUInt16().FromEndian(endian);
            Unknown8   = stream.ReadUInt32().FromEndian(endian);

            RefStringLocation1 = stream.ReadUInt(bits, endian);
            RefStringLocation2 = stream.ReadUInt(bits, endian);
            Unknown11          = stream.ReadUInt32().FromEndian(endian);
            Unknown12          = stream.ReadUInt32().FromEndian(endian);

            Unknown13 = stream.ReadUInt32().FromEndian(endian);
            Unknown14 = stream.ReadUInt32().FromEndian(endian);
            Unknown15 = stream.ReadUInt32().FromEndian(endian);
            Unknown16 = stream.ReadUInt32().FromEndian(endian);

            RefString1 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + RefStringLocation1));
            RefString2 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + RefStringLocation2));
        }
Beispiel #3
0
        public NpcFileReference(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.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));
        }
Beispiel #4
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));
        }
Beispiel #5
0
        public SkitInfo(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.Bitness bits)
        {
            // first 16 bytes are always null in the existing files
            stream.DiscardBytes(0x10);

            SkitFlagUnique = stream.ReadUInt16().FromEndian(endian);
            Unknown2       = stream.ReadUInt16().FromEndian(endian);

            FlagTrigger      = stream.ReadUInt32().FromEndian(endian);
            FlagCancel       = stream.ReadUInt32().FromEndian(endian);
            Category         = stream.ReadUInt32().FromEndian(endian);
            CharacterBitmask = stream.ReadUInt32().FromEndian(endian);
            Unknown4         = stream.ReadUInt32().FromEndian(endian);
            SkitConditionForwarderReference = stream.ReadUInt(bits, endian);
            SkitConditionRelated            = stream.ReadUInt32().FromEndian(endian);
            SkitFlag = stream.ReadUInt32().FromEndian(endian);
            ulong refStringPos = stream.ReadUInt(bits, endian);

            StringDicIdName      = stream.ReadUInt32().FromEndian(endian);
            StringDicIdCondition = stream.ReadUInt32().FromEndian(endian);

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringPos));

            return;
        }
Beispiel #6
0
        public CharacterModelDefinition(System.IO.Stream stream, uint refStringStart)
        {
            Strings = new string[100];

            for (uint i = 0; i < 100; ++i)
            {
                Strings[i] = stream.ReadAsciiNulltermFromLocationAndReset(stream.ReadUInt32().SwapEndian() + refStringStart);
            }

            CustomIndex          = stream.ReadUInt32().SwapEndian();
            CustomCount          = (byte)stream.ReadByte();
            OtherCount           = (byte)stream.ReadByte();
            Unknown0x20AreaCount = (byte)stream.ReadByte();
            Unknown1d            = (byte)stream.ReadByte();
            OtherIndex           = stream.ReadUInt32().SwapEndian();
            Unknown0x20AreaIndex = stream.ReadUInt32().SwapEndian();
            Unknown4a            = (byte)stream.ReadByte();
            Unknown4b            = (byte)stream.ReadByte();
            Unknown4c            = (byte)stream.ReadByte();
            Unknown4d            = (byte)stream.ReadByte();
            stream.DiscardBytes(4);
            Unknown0x80AreaIndex = stream.ReadUInt32().SwapEndian();
            Unknown0x80AreaCount = (byte)stream.ReadByte();
            Unknown7b            = (byte)stream.ReadByte();
            stream.DiscardBytes(2);

            stream.DiscardBytes(80);
        }
Beispiel #7
0
 public OtherModelAddition(System.IO.Stream stream, uint refStringStart, Util.Endianness endian)
 {
     Str      = stream.ReadAsciiNulltermFromLocationAndReset(stream.ReadUInt32().FromEndian(endian) + refStringStart);
     Unknown1 = (byte)stream.ReadByte();
     Unknown2 = (byte)stream.ReadByte();
     stream.DiscardBytes(0x1A);
 }
Beispiel #8
0
        public TreasureInfo(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.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));
        }
Beispiel #9
0
        public Skill(System.IO.Stream stream, uint refStringStart, Util.Endianness endian, Util.Bitness bits)
        {
            uint entrySize = stream.ReadUInt32().FromEndian(endian);

            if (entrySize != (0x3C + bits.NumberOfBytes()))
            {
                throw new Exception("Unknown Skill 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);
            Unknown7           = stream.ReadUInt32().FromEndian(endian);
            LearnableByBitmask = stream.ReadUInt32().FromEndian(endian);

            EquipCost = stream.ReadUInt32().FromEndian(endian);
            LearnCost = stream.ReadUInt32().FromEndian(endian);
            Category  = stream.ReadUInt32().FromEndian(endian);
            // Game sums up this value per category, then figures out the OVL-symbol from the totals
            SymbolValue = stream.ReadUInt32().FromEndian(endian);

            Unknown13 = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            Unknown14 = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            Unknown15 = stream.ReadUInt32().FromEndian(endian).UIntToFloat();
            Inactive  = stream.ReadUInt32().FromEndian(endian);

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refStringLocation));
        }
Beispiel #10
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));
        }
Beispiel #11
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));
        }
Beispiel #12
0
        public EncounterGroup(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);

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

            RefString = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + refLoc));
        }
Beispiel #13
0
        public EnemyGroup(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.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));
        }
Beispiel #14
0
        public GradeShopEntry(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.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));
        }
Beispiel #15
0
 public CustomModelAddition(System.IO.Stream stream, uint refStringStart)
 {
     Str = stream.ReadAsciiNulltermFromLocationAndReset(stream.ReadUInt32().SwapEndian() + refStringStart);
 }
Beispiel #16
0
        // 14 is always zero
        // 16 is zero except on the new giganto monsters and spiral draco
        // 76 is on PS3 only, StringDicID for the dummy description

        public Enemy(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.Bitness bits)
        {
            long pos = stream.Position;

            uint entryLength = stream.ReadUInt32().FromEndian(endian);                // 0

            ID = stream.ReadUInt32().FromEndian(endian);                              // 1
            NameStringDicID = stream.ReadUInt32().FromEndian(endian);                 // 2
            ulong ref3 = stream.ReadUInt(bits, endian);                               // 3
            ulong ref4 = stream.ReadUInt(bits, endian);                               // 4

            InGameID = stream.ReadUInt32().FromEndian(endian);                        // 5
            ulong ref6 = stream.ReadUInt(bits, endian);                               // 6

            Level = stream.ReadUInt32().FromEndian(endian);                           // 7
            HP    = stream.ReadUInt32().FromEndian(endian);                           // 8
            TP    = stream.ReadUInt32().FromEndian(endian);                           // 9
            PATK  = stream.ReadUInt32().FromEndian(endian);                           // 10
            PDEF  = stream.ReadUInt32().FromEndian(endian);                           // 11
            MATK  = stream.ReadUInt32().FromEndian(endian);                           // 12
            MDEF  = stream.ReadUInt32().FromEndian(endian);                           // 13
            stream.ReadUInt32().FromEndian(endian);                                   // 14
            AGL = stream.ReadUInt32().FromEndian(endian);                             // 15
            stream.ReadUInt32().FromEndian(endian);                                   // 16

            FatalBlue         = stream.ReadUInt32().FromEndian(endian).UIntToFloat(); // 17
            FatalRed          = stream.ReadUInt32().FromEndian(endian).UIntToFloat(); // 18
            FatalGreen        = stream.ReadUInt32().FromEndian(endian).UIntToFloat(); // 19
            FatalBlueRelated  = stream.ReadUInt32().FromEndian(endian).UIntToFloat(); // 20
            FatalRedRelated   = stream.ReadUInt32().FromEndian(endian).UIntToFloat(); // 21
            FatalGreenRelated = stream.ReadUInt32().FromEndian(endian).UIntToFloat(); // 22

            stream.ReadUInt32().FromEndian(endian);                                   // 23

            Category = stream.ReadUInt32().FromEndian(endian);                        // 24

            stream.ReadUInt32().FromEndian(endian);                                   // 25

            // > 100 weak, < 100 resist, 0 nullify, negative absorb
            // effectively a damage multiplier in percent
            Attributes    = new int[7];
            Attributes[0] = (int)stream.ReadUInt32().FromEndian(endian); // 26
            Attributes[1] = (int)stream.ReadUInt32().FromEndian(endian); // 27
            Attributes[2] = (int)stream.ReadUInt32().FromEndian(endian); // 28
            Attributes[3] = (int)stream.ReadUInt32().FromEndian(endian); // 29
            Attributes[4] = (int)stream.ReadUInt32().FromEndian(endian); // 30
            Attributes[5] = (int)stream.ReadUInt32().FromEndian(endian); // 31
            Attributes[6] = (int)stream.ReadUInt32().FromEndian(endian); // 32

            EXP  = stream.ReadUInt32().FromEndian(endian);               // 33
            Gald = stream.ReadUInt32().FromEndian(endian);               // 34
            LP   = stream.ReadUInt32().FromEndian(endian);               // 35

            DropItems      = new uint[4];
            DropItems[0]   = stream.ReadUInt32().FromEndian(endian);          // 36
            DropItems[1]   = stream.ReadUInt32().FromEndian(endian);          // 37
            DropItems[2]   = stream.ReadUInt32().FromEndian(endian);          // 38
            DropItems[3]   = stream.ReadUInt32().FromEndian(endian);          // 39
            DropChances    = new uint[4];
            DropChances[0] = stream.ReadUInt32().FromEndian(endian);          // 40
            DropChances[1] = stream.ReadUInt32().FromEndian(endian);          // 41
            DropChances[2] = stream.ReadUInt32().FromEndian(endian);          // 42
            DropChances[3] = stream.ReadUInt32().FromEndian(endian);          // 43
            StealItem      = stream.ReadUInt32().FromEndian(endian);          // 44
            StealChance    = stream.ReadUInt32().FromEndian(endian);          // 45

            FatalTypeExp    = stream.ReadUInt32().FromEndian(endian);         // 46
            EXPModifier     = stream.ReadUInt32().FromEndian(endian);         // 47
            FatalTypeLP     = stream.ReadUInt32().FromEndian(endian);         // 48
            LPModifier      = stream.ReadUInt32().FromEndian(endian);         // 49
            FatalTypeDrop   = stream.ReadUInt32().FromEndian(endian);         // 50
            DropModifier    = new uint[4];
            DropModifier[0] = stream.ReadUInt32().FromEndian(endian);         // 51
            DropModifier[1] = stream.ReadUInt32().FromEndian(endian);         // 52
            DropModifier[2] = stream.ReadUInt32().FromEndian(endian);         // 53
            DropModifier[3] = stream.ReadUInt32().FromEndian(endian);         // 54

            ulong ref55 = stream.ReadUInt(bits, endian);                      // 55

            KillableWithFS = stream.ReadUInt32().FromEndian(endian);          // 56

            IconID = stream.ReadUInt32().FromEndian(endian);                  // 57

            ulong ref58 = stream.ReadUInt(bits, endian);                      // 58

            InMonsterBook = stream.ReadUInt32().FromEndian(endian);           // 59
            Location      = stream.ReadUInt32().FromEndian(endian);           // 60
            // -1: None shown, 0: Sun, 1: Rain, 2: Snow, 3: Windy, 4: Night, 5: Cloudy
            LocationWeather = (int)stream.ReadUInt32().FromEndian(endian);    // 61

            stream.ReadUInt32().FromEndian(endian);                           // 62
            stream.ReadUInt32().FromEndian(endian);                           // 63
            stream.ReadUInt32().FromEndian(endian);                           // 64
            stream.ReadUInt32().FromEndian(endian);                           // 65
            stream.ReadUInt32().FromEndian(endian);                           // 66
            stream.ReadUInt32().FromEndian(endian);                           // 67

            SecretMissionDrop       = stream.ReadUInt32().FromEndian(endian); // 68
            SecretMissionDropChance = stream.ReadUInt32().FromEndian(endian); // 69

            long bytesleft = (pos + entryLength) - stream.Position;

            if (bytesleft > 0)
            {
                stream.DiscardBytes((uint)bytesleft);
            }

            RefString  = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + ref6));
            RefString2 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + ref3));
            RefString3 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + ref4));
            RefString4 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + ref55));
            RefString5 = stream.ReadAsciiNulltermFromLocationAndReset((long)(refStringStart + ref58));
        }
Beispiel #17
0
 public CustomModelAddition(System.IO.Stream stream, uint refStringStart, Util.Endianness endian)
 {
     Str = stream.ReadAsciiNulltermFromLocationAndReset(stream.ReadUInt32().FromEndian(endian) + refStringStart);
 }
Beispiel #18
0
        public Arte(System.IO.Stream stream, uint refStringStart, EndianUtils.Endianness endian, BitUtils.Bitness bits)
        {
            uint Size = stream.PeekUInt32().FromEndian(endian);

            if ((Size % 4) != 0)
            {
                throw new Exception("Arte data size not divisble by 4.");
            }

            Size -= (bits.NumberOfBytes() - 4) * 2;               // just hack this so i don't have to rewrite this mess...
            Data  = new uint[Size / 4];
            for (int i = 0; i < Data.Length; ++i)
            {
                if (i == 3 || i == 4)
                {
                    Data[i] = (uint)stream.ReadUInt(bits, endian);                       // just hack this so i don't have to rewrite this mess...
                }
                else
                {
                    Data[i] = stream.ReadUInt32().FromEndian(endian);
                }
            }

            ID       = Data[1];
            InGameID = Data[2];

            uint refStringLocaton = Data[3];             // seems to be identical with Data[4]

            RefString = stream.ReadAsciiNulltermFromLocationAndReset(refStringStart + refStringLocaton);

            NameStringDicId = Data[5];
            DescStringDicId = Data[6];
            Type            = (ArteType)Data[7];

            TPUsage         = Data[8];
            ElementFire     = Data[10];
            ElementEarth    = Data[11];
            ElementWind     = Data[12];
            ElementWater    = Data[13];
            ElementLight    = Data[14];
            ElementDarkness = Data[15];


            // for some reason the data order different between versions?
            if (Size == 876)
            {
                LearnRequirementsOtherArtesType = new uint[6];
                for (int i = 0; i < LearnRequirementsOtherArtesType.Length; ++i)
                {
                    LearnRequirementsOtherArtesType[i] = Data[128 + 22 + i];
                }
                LearnRequirementsOtherArtesId = new uint[6];
                for (int i = 0; i < LearnRequirementsOtherArtesId.Length; ++i)
                {
                    LearnRequirementsOtherArtesId[i] = Data[128 + 28 + i];
                }
                LearnRequirementsOtherArtesUsageCount = new uint[6];
                for (int i = 0; i < LearnRequirementsOtherArtesUsageCount.Length; ++i)
                {
                    LearnRequirementsOtherArtesUsageCount[i] = Data[128 + 34 + i];
                }

                AlteredArteRequirementType = new uint[5];
                for (int i = 0; i < AlteredArteRequirementType.Length; ++i)
                {
                    AlteredArteRequirementType[i] = Data[127 + 69 + i];
                }
                AlteredArteRequirementId = new uint[5];
                for (int i = 0; i < AlteredArteRequirementId.Length; ++i)
                {
                    AlteredArteRequirementId[i] = Data[127 + 74 + i];
                }
                //CharacterRelatedField = Data[?];
                Character = Data[21];

                FatalStrikeType = Data[210];

                UsableInMenu = Data[128 + 44];
            }
            else
            {
                LearnRequirementsOtherArtesType = new uint[6];
                for (int i = 0; i < LearnRequirementsOtherArtesType.Length; ++i)
                {
                    LearnRequirementsOtherArtesType[i] = Data[22 + i];
                }
                LearnRequirementsOtherArtesId = new uint[6];
                for (int i = 0; i < LearnRequirementsOtherArtesId.Length; ++i)
                {
                    LearnRequirementsOtherArtesId[i] = Data[28 + i];
                }
                LearnRequirementsOtherArtesUsageCount = new uint[6];
                for (int i = 0; i < LearnRequirementsOtherArtesUsageCount.Length; ++i)
                {
                    LearnRequirementsOtherArtesUsageCount[i] = Data[34 + i];
                }

                AlteredArteRequirementType = new uint[5];
                for (int i = 0; i < AlteredArteRequirementType.Length; ++i)
                {
                    AlteredArteRequirementType[i] = Data[69 + i];
                }
                AlteredArteRequirementId = new uint[5];
                for (int i = 0; i < AlteredArteRequirementId.Length; ++i)
                {
                    AlteredArteRequirementId[i] = Data[74 + i];
                }
                CharacterRelatedField = Data[95];
                Character             = Data[96];

                FatalStrikeType = Data[83];

                UsableInMenu = Data[44];
            }

            // always identical: 16, 17
            // 59 is some sort of status effect field
        }