Example #1
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 8 offset: 0000
            Gesture    = new uint[8];
            Gesture[0] = parser.ReadOffset <uint>(0x0);
            Gesture[1] = parser.ReadOffset <uint>(0x14);
            Gesture[2] = parser.ReadOffset <uint>(0x28);
            Gesture[3] = parser.ReadOffset <uint>(0x3c);
            Gesture[4] = parser.ReadOffset <uint>(0x50);
            Gesture[5] = parser.ReadOffset <uint>(0x64);
            Gesture[6] = parser.ReadOffset <uint>(0x78);
            Gesture[7] = parser.ReadOffset <uint>(0x8c);

            // col: 16 offset: 0004
            LipSync    = new int[8];
            LipSync[0] = parser.ReadOffset <int>(0x4);
            LipSync[1] = parser.ReadOffset <int>(0x18);
            LipSync[2] = parser.ReadOffset <int>(0x2c);
            LipSync[3] = parser.ReadOffset <int>(0x40);
            LipSync[4] = parser.ReadOffset <int>(0x54);
            LipSync[5] = parser.ReadOffset <int>(0x68);
            LipSync[6] = parser.ReadOffset <int>(0x7c);
            LipSync[7] = parser.ReadOffset <int>(0x90);

            // col: 24 offset: 0008
            Facial    = new int[8];
            Facial[0] = parser.ReadOffset <int>(0x8);
            Facial[1] = parser.ReadOffset <int>(0x1c);
            Facial[2] = parser.ReadOffset <int>(0x30);
            Facial[3] = parser.ReadOffset <int>(0x44);
            Facial[4] = parser.ReadOffset <int>(0x58);
            Facial[5] = parser.ReadOffset <int>(0x6c);
            Facial[6] = parser.ReadOffset <int>(0x80);
            Facial[7] = parser.ReadOffset <int>(0x94);

            // col: 32 offset: 000c
            Shape    = new int[8];
            Shape[0] = parser.ReadOffset <int>(0xc);
            Shape[1] = parser.ReadOffset <int>(0x20);
            Shape[2] = parser.ReadOffset <int>(0x34);
            Shape[3] = parser.ReadOffset <int>(0x48);
            Shape[4] = parser.ReadOffset <int>(0x5c);
            Shape[5] = parser.ReadOffset <int>(0x70);
            Shape[6] = parser.ReadOffset <int>(0x84);
            Shape[7] = parser.ReadOffset <int>(0x98);

            // col: 0 offset: 0010
            Turn    = new byte[8];
            Turn[0] = parser.ReadOffset <byte>(0x10);
            Turn[1] = parser.ReadOffset <byte>(0x24);
            Turn[2] = parser.ReadOffset <byte>(0x38);
            Turn[3] = parser.ReadOffset <byte>(0x4c);
            Turn[4] = parser.ReadOffset <byte>(0x60);
            Turn[5] = parser.ReadOffset <byte>(0x74);
            Turn[6] = parser.ReadOffset <byte>(0x88);
            Turn[7] = parser.ReadOffset <byte>(0x9c);

            // col: 48 offset: 0011
            WidgetType    = new byte[8];
            WidgetType[0] = parser.ReadOffset <byte>(0x11);
            WidgetType[1] = parser.ReadOffset <byte>(0x25);
            WidgetType[2] = parser.ReadOffset <byte>(0x39);
            WidgetType[3] = parser.ReadOffset <byte>(0x4d);
            WidgetType[4] = parser.ReadOffset <byte>(0x61);
            WidgetType[5] = parser.ReadOffset <byte>(0x75);
            WidgetType[6] = parser.ReadOffset <byte>(0x89);
            WidgetType[7] = parser.ReadOffset <byte>(0x9d);

            // col: 40 offset: 0012
            packed12 = parser.ReadOffset <byte>(0x12, ExcelColumnDataType.UInt8);

            // col: 56 offset: 00a0
            Text    = new string[8];
            Text[0] = parser.ReadOffset <string>(0xa0);
            Text[1] = parser.ReadOffset <string>(0xa4);
            Text[2] = parser.ReadOffset <string>(0xa8);
            Text[3] = parser.ReadOffset <string>(0xac);
            Text[4] = parser.ReadOffset <string>(0xb0);
            Text[5] = parser.ReadOffset <string>(0xb4);
            Text[6] = parser.ReadOffset <string>(0xb8);
            Text[7] = parser.ReadOffset <string>(0xbc);
        }
Example #2
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            XpMultiplier    = new ushort[2];
            XpMultiplier[0] = parser.ReadOffset <ushort>(0x0);
            XpMultiplier[1] = parser.ReadOffset <ushort>(0x2);

            // col: 2 offset: 0004
            unknown4 = parser.ReadOffset <ushort>(0x4);

            // col: 3 offset: 0006
            unknown6 = parser.ReadOffset <ushort>(0x6);

            // col: 4 offset: 0008
            CurrencyMultiplier    = new ushort[2];
            CurrencyMultiplier[0] = parser.ReadOffset <ushort>(0x8);
            CurrencyMultiplier[1] = parser.ReadOffset <ushort>(0xa);

            // col: 6 offset: 000c
            unknownc = parser.ReadOffset <ushort>(0xc);

            // col: 7 offset: 000e
            unknowne = parser.ReadOffset <ushort>(0xe);

            // col: 8 offset: 0010
            unknown10 = parser.ReadOffset <ushort>(0x10);

            // col: 9 offset: 0012
            unknown12 = parser.ReadOffset <ushort>(0x12);

            // col: 10 offset: 0014
            unknown14 = parser.ReadOffset <ushort>(0x14);

            // col: 11 offset: 0016
            unknown16 = parser.ReadOffset <ushort>(0x16);
        }
Example #3
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Strength = parser.ReadOffset <ushort>(0x0);

            // col: 1 offset: 0002
            Dexterity = parser.ReadOffset <ushort>(0x2);

            // col: 2 offset: 0004
            Vitality = parser.ReadOffset <ushort>(0x4);

            // col: 3 offset: 0006
            Intelligence = parser.ReadOffset <ushort>(0x6);

            // col: 4 offset: 0008
            Mind = parser.ReadOffset <ushort>(0x8);

            // col: 5 offset: 000a
            Piety = parser.ReadOffset <ushort>(0xa);

            // col: 6 offset: 000c
            HP = parser.ReadOffset <ushort>(0xc);

            // col: 7 offset: 000e
            MP = parser.ReadOffset <ushort>(0xe);

            // col: 8 offset: 0010
            TP = parser.ReadOffset <ushort>(0x10);

            // col: 9 offset: 0012
            GP = parser.ReadOffset <ushort>(0x12);

            // col: 10 offset: 0014
            CP = parser.ReadOffset <ushort>(0x14);

            // col: 11 offset: 0016
            PhysicalDamage = parser.ReadOffset <ushort>(0x16);

            // col: 12 offset: 0018
            MagicalDamage = parser.ReadOffset <ushort>(0x18);

            // col: 13 offset: 001a
            Delay = parser.ReadOffset <ushort>(0x1a);

            // col: 14 offset: 001c
            AdditionalEffect = parser.ReadOffset <ushort>(0x1c);

            // col: 15 offset: 001e
            AttackSpeed = parser.ReadOffset <ushort>(0x1e);

            // col: 16 offset: 0020
            BlockRate = parser.ReadOffset <ushort>(0x20);

            // col: 17 offset: 0022
            BlockStrength = parser.ReadOffset <ushort>(0x22);

            // col: 18 offset: 0024
            Tenacity = parser.ReadOffset <ushort>(0x24);

            // col: 19 offset: 0026
            AttackPower = parser.ReadOffset <ushort>(0x26);

            // col: 20 offset: 0028
            Defense = parser.ReadOffset <ushort>(0x28);

            // col: 21 offset: 002a
            DirectHitRate = parser.ReadOffset <ushort>(0x2a);

            // col: 22 offset: 002c
            Evasion = parser.ReadOffset <ushort>(0x2c);

            // col: 23 offset: 002e
            MagicDefense = parser.ReadOffset <ushort>(0x2e);

            // col: 24 offset: 0030
            CriticalHitPower = parser.ReadOffset <ushort>(0x30);

            // col: 25 offset: 0032
            CriticalHitResilience = parser.ReadOffset <ushort>(0x32);

            // col: 26 offset: 0034
            CriticalHit = parser.ReadOffset <ushort>(0x34);

            // col: 27 offset: 0036
            CriticalHitEvasion = parser.ReadOffset <ushort>(0x36);

            // col: 28 offset: 0038
            SlashingResistance = parser.ReadOffset <ushort>(0x38);

            // col: 29 offset: 003a
            PiercingResistance = parser.ReadOffset <ushort>(0x3a);

            // col: 30 offset: 003c
            BluntResistance = parser.ReadOffset <ushort>(0x3c);

            // col: 31 offset: 003e
            ProjectileResistance = parser.ReadOffset <ushort>(0x3e);

            // col: 32 offset: 0040
            AttackMagicPotency = parser.ReadOffset <ushort>(0x40);

            // col: 33 offset: 0042
            HealingMagicPotency = parser.ReadOffset <ushort>(0x42);

            // col: 34 offset: 0044
            EnhancementMagicPotency = parser.ReadOffset <ushort>(0x44);

            // col: 35 offset: 0046
            EnfeeblingMagicPotency = parser.ReadOffset <ushort>(0x46);

            // col: 36 offset: 0048
            FireResistance = parser.ReadOffset <ushort>(0x48);

            // col: 37 offset: 004a
            IceResistance = parser.ReadOffset <ushort>(0x4a);

            // col: 38 offset: 004c
            WindResistance = parser.ReadOffset <ushort>(0x4c);

            // col: 39 offset: 004e
            EarthResistance = parser.ReadOffset <ushort>(0x4e);

            // col: 40 offset: 0050
            LightningResistance = parser.ReadOffset <ushort>(0x50);

            // col: 41 offset: 0052
            WaterResistance = parser.ReadOffset <ushort>(0x52);

            // col: 42 offset: 0054
            MagicResistance = parser.ReadOffset <ushort>(0x54);

            // col: 43 offset: 0056
            Determination = parser.ReadOffset <ushort>(0x56);

            // col: 44 offset: 0058
            SkillSpeed = parser.ReadOffset <ushort>(0x58);

            // col: 45 offset: 005a
            SpellSpeed = parser.ReadOffset <ushort>(0x5a);

            // col: 46 offset: 005c
            Haste = parser.ReadOffset <ushort>(0x5c);

            // col: 47 offset: 005e
            Morale = parser.ReadOffset <ushort>(0x5e);

            // col: 48 offset: 0060
            Enmity = parser.ReadOffset <ushort>(0x60);

            // col: 49 offset: 0062
            EnmityReduction = parser.ReadOffset <ushort>(0x62);

            // col: 50 offset: 0064
            CarefulDesynthesis = parser.ReadOffset <ushort>(0x64);

            // col: 51 offset: 0066
            EXPBonus = parser.ReadOffset <ushort>(0x66);

            // col: 52 offset: 0068
            Regen = parser.ReadOffset <ushort>(0x68);

            // col: 53 offset: 006a
            Refresh = parser.ReadOffset <ushort>(0x6a);

            // col: 54 offset: 006c
            MovementSpeed = parser.ReadOffset <ushort>(0x6c);

            // col: 55 offset: 006e
            Spikes = parser.ReadOffset <ushort>(0x6e);

            // col: 56 offset: 0070
            SlowResistance = parser.ReadOffset <ushort>(0x70);

            // col: 57 offset: 0072
            PetrificationResistance = parser.ReadOffset <ushort>(0x72);

            // col: 58 offset: 0074
            ParalysisResistance = parser.ReadOffset <ushort>(0x74);

            // col: 59 offset: 0076
            SilenceResistance = parser.ReadOffset <ushort>(0x76);

            // col: 60 offset: 0078
            BlindResistance = parser.ReadOffset <ushort>(0x78);

            // col: 61 offset: 007a
            PoisonResistance = parser.ReadOffset <ushort>(0x7a);

            // col: 62 offset: 007c
            StunResistance = parser.ReadOffset <ushort>(0x7c);

            // col: 63 offset: 007e
            SleepResistance = parser.ReadOffset <ushort>(0x7e);

            // col: 64 offset: 0080
            BindResistance = parser.ReadOffset <ushort>(0x80);

            // col: 65 offset: 0082
            HeavyResistance = parser.ReadOffset <ushort>(0x82);

            // col: 66 offset: 0084
            DoomResistance = parser.ReadOffset <ushort>(0x84);

            // col: 67 offset: 0086
            ReducedDurabilityLoss = parser.ReadOffset <ushort>(0x86);

            // col: 68 offset: 0088
            IncreasedSpiritbondGain = parser.ReadOffset <ushort>(0x88);

            // col: 69 offset: 008a
            Craftsmanship = parser.ReadOffset <ushort>(0x8a);

            // col: 70 offset: 008c
            Control = parser.ReadOffset <ushort>(0x8c);

            // col: 71 offset: 008e
            Gathering = parser.ReadOffset <ushort>(0x8e);

            // col: 72 offset: 0090
            Perception = parser.ReadOffset <ushort>(0x90);

            // col: 73 offset: 0092
            unknown92 = parser.ReadOffset <ushort>(0x92);
        }
Example #4
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 26 offset: 0000
            ItemPossibleReward    = new uint[4];
            ItemPossibleReward[0] = parser.ReadOffset <uint>(0x0);
            ItemPossibleReward[1] = parser.ReadOffset <uint>(0x4);
            ItemPossibleReward[2] = parser.ReadOffset <uint>(0x8);
            ItemPossibleReward[3] = parser.ReadOffset <uint>(0xc);

            // col: 15 offset: 0010
            PreviousQuest    = new uint[3];
            PreviousQuest[0] = parser.ReadOffset <uint>(0x10);
            PreviousQuest[1] = parser.ReadOffset <uint>(0x14);
            PreviousQuest[2] = parser.ReadOffset <uint>(0x18);

            // col: 20 offset: 001c
            DefaultTalkChallenge = parser.ReadOffset <uint>(0x1c);

            // col: 21 offset: 0020
            DefaultTalkUnavailable = parser.ReadOffset <uint>(0x20);

            // col: 22 offset: 0024
            DefaultTalkNPCWin = parser.ReadOffset <uint>(0x24);

            // col: 23 offset: 0028
            DefaultTalkDraw = parser.ReadOffset <uint>(0x28);

            // col: 24 offset: 002c
            DefaultTalkPCWin = parser.ReadOffset <uint>(0x2c);

            // col: 0 offset: 0030
            TripleTriadCardFixed    = new ushort[5];
            TripleTriadCardFixed[0] = parser.ReadOffset <ushort>(0x30);
            TripleTriadCardFixed[1] = parser.ReadOffset <ushort>(0x32);
            TripleTriadCardFixed[2] = parser.ReadOffset <ushort>(0x34);
            TripleTriadCardFixed[3] = parser.ReadOffset <ushort>(0x36);
            TripleTriadCardFixed[4] = parser.ReadOffset <ushort>(0x38);

            // col: 5 offset: 003a
            TripleTriadCardVariable    = new ushort[5];
            TripleTriadCardVariable[0] = parser.ReadOffset <ushort>(0x3a);
            TripleTriadCardVariable[1] = parser.ReadOffset <ushort>(0x3c);
            TripleTriadCardVariable[2] = parser.ReadOffset <ushort>(0x3e);
            TripleTriadCardVariable[3] = parser.ReadOffset <ushort>(0x40);
            TripleTriadCardVariable[4] = parser.ReadOffset <ushort>(0x42);

            // col: 13 offset: 0044
            Fee = parser.ReadOffset <ushort>(0x44);

            // col: 18 offset: 0046
            StartTime = parser.ReadOffset <ushort>(0x46);

            // col: 19 offset: 0048
            EndTime = parser.ReadOffset <ushort>(0x48);

            // col: 10 offset: 004a
            TripleTriadRule    = new byte[2];
            TripleTriadRule[0] = parser.ReadOffset <byte>(0x4a);
            TripleTriadRule[1] = parser.ReadOffset <byte>(0x4b);

            // col: 14 offset: 004c
            PreviousQuestJoin = parser.ReadOffset <byte>(0x4c);

            // col: 12 offset: 004d
            packed4d = parser.ReadOffset <byte>(0x4d, ExcelColumnDataType.UInt8);
        }
Example #5
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 6 offset: 0000
            Id = parser.ReadOffset <string>(0x0);

            // col: 14 offset: 0004
            DiscoveryFlag = parser.ReadOffset <uint>(0x4);

            // col: 5 offset: 0008
            MapMarkerRange = parser.ReadOffset <ushort>(0x8);

            // col: 7 offset: 000a
            SizeFactor = parser.ReadOffset <ushort>(0xa);

            // col: 10 offset: 000c
            PlaceNameRegion = parser.ReadOffset <ushort>(0xc);

            // col: 11 offset: 000e
            PlaceName = parser.ReadOffset <ushort>(0xe);

            // col: 12 offset: 0010
            PlaceNameSub = parser.ReadOffset <ushort>(0x10);

            // col: 15 offset: 0012
            TerritoryType = parser.ReadOffset <ushort>(0x12);

            // col: 8 offset: 0014
            OffsetX = parser.ReadOffset <short>(0x14);

            // col: 9 offset: 0016
            OffsetY = parser.ReadOffset <short>(0x16);

            // col: 13 offset: 0018
            DiscoveryIndex = parser.ReadOffset <short>(0x18);

            // col: 0 offset: 001a
            MapCondition = parser.ReadOffset <byte>(0x1a);

            // col: 1 offset: 001b
            PriorityCategoryUI = parser.ReadOffset <byte>(0x1b);

            // col: 2 offset: 001c
            PriorityUI = parser.ReadOffset <byte>(0x1c);

            // col: 4 offset: 001d
            Hierarchy = parser.ReadOffset <byte>(0x1d);

            // col: 3 offset: 001e
            MapIndex = parser.ReadOffset <sbyte>(0x1e);

            // col: 16 offset: 001f
            packed1f = parser.ReadOffset <byte>(0x1f, ExcelColumnDataType.UInt8);
        }
Example #6
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Name = parser.ReadOffset <string>(0x0);

            // col: 1 offset: 0004
            unknown4 = parser.ReadOffset <ushort>(0x4);

            // col: 2 offset: 0006
            unknown6 = parser.ReadOffset <ushort>(0x6);

            // col: 3 offset: 0008
            unknown8 = parser.ReadOffset <ushort>(0x8);

            // col: 4 offset: 000a
            unknowna = parser.ReadOffset <ushort>(0xa);

            // col: 5 offset: 000c
            unknownc = parser.ReadOffset <ushort>(0xc);

            // col: 10 offset: 000e
            unknowne = parser.ReadOffset <byte>(0xe);

            // col: 11 offset: 000f
            unknownf = parser.ReadOffset <byte>(0xf);

            // col: 12 offset: 0010
            unknown10 = parser.ReadOffset <byte>(0x10);

            // col: 9 offset: 0011
            unknown11 = parser.ReadOffset <sbyte>(0x11);

            // col: 6 offset: 0012
            packed12 = parser.ReadOffset <byte>(0x12, ExcelColumnDataType.UInt8);
        }
Example #7
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 35 offset: 0000
            Name = parser.ReadOffset <string>(0x0);

            // col: 43 offset: 0004
            LevelingRoulette = parser.ReadOffset <bool>(0x4);

            // col: 44 offset: 0005
            Level5060Roulette = parser.ReadOffset <bool>(0x5);

            // col: 45 offset: 0006
            MSQRoulette = parser.ReadOffset <bool>(0x6);

            // col: 46 offset: 0007
            GuildHestRoulette = parser.ReadOffset <bool>(0x7);

            // col: 47 offset: 0008
            ExpertRoulette = parser.ReadOffset <bool>(0x8);

            // col: 48 offset: 0009
            TrialRoulette = parser.ReadOffset <bool>(0x9);

            // col: 49 offset: 000a
            DailyFrontlineChallenge = parser.ReadOffset <bool>(0xa);

            // col: 50 offset: 000b
            Level70Roulette = parser.ReadOffset <bool>(0xb);

            // col: 51 offset: 000c
            MentorRoulette = parser.ReadOffset <bool>(0xc);

            // col: 52 offset: 000d
            unknownd = parser.ReadOffset <bool>(0xd);

            // col: 53 offset: 000e
            unknowne = parser.ReadOffset <bool>(0xe);

            // col: 54 offset: 000f
            unknownf = parser.ReadOffset <bool>(0xf);

            // col: 55 offset: 0010
            unknown10 = parser.ReadOffset <bool>(0x10);

            // col: 56 offset: 0011
            unknown11 = parser.ReadOffset <bool>(0x11);

            // col: 57 offset: 0012
            AllianceRoulette = parser.ReadOffset <bool>(0x12);

            // col: 58 offset: 0013
            unknown13 = parser.ReadOffset <bool>(0x13);

            // col: 59 offset: 0014
            NormalRaidRoulette = parser.ReadOffset <bool>(0x14);

            // col: 60 offset: 0015
            unknown15 = parser.ReadOffset <bool>(0x15);

            // col: 61 offset: 0016
            unknown16 = parser.ReadOffset <bool>(0x16);

            // col: 62 offset: 0017
            unknown17 = parser.ReadOffset <bool>(0x17);

            // col: 63 offset: 0018
            unknown18 = parser.ReadOffset <bool>(0x18);

            // col: 64 offset: 0019
            unknown19 = parser.ReadOffset <bool>(0x19);

            // col: 65 offset: 001a
            unknown1a = parser.ReadOffset <bool>(0x1a);

            // col: 66 offset: 001b
            unknown1b = parser.ReadOffset <bool>(0x1b);

            // col: 67 offset: 001c
            unknown1c = parser.ReadOffset <bool>(0x1c);

            // col: 68 offset: 001d
            unknown1d = parser.ReadOffset <bool>(0x1d);

            // col: 69 offset: 001e
            unknown1e = parser.ReadOffset <bool>(0x1e);

            // col: 70 offset: 001f
            unknown1f = parser.ReadOffset <bool>(0x1f);

            // col: 71 offset: 0020
            unknown20 = parser.ReadOffset <bool>(0x20);

            // col: 72 offset: 0021
            unknown21 = parser.ReadOffset <bool>(0x21);

            // col: 73 offset: 0022
            unknown22 = parser.ReadOffset <bool>(0x22);

            // col: 74 offset: 0023
            unknown23 = parser.ReadOffset <bool>(0x23);

            // col: 75 offset: 0024
            unknown24 = parser.ReadOffset <bool>(0x24);

            // col: 76 offset: 0025
            unknown25 = parser.ReadOffset <bool>(0x25);

            // col: 77 offset: 0026
            unknown26 = parser.ReadOffset <bool>(0x26);

            // col: 78 offset: 0027
            unknown27 = parser.ReadOffset <bool>(0x27);

            // col: 79 offset: 0028
            unknown28 = parser.ReadOffset <bool>(0x28);

            // col: 80 offset: 0029
            unknown29 = parser.ReadOffset <bool>(0x29);

            // col: 81 offset: 002a
            unknown2a = parser.ReadOffset <bool>(0x2a);

            // col: 0 offset: 002c
            ShortCode = parser.ReadOffset <string>(0x2c);

            // col: 6 offset: 0030
            unknown30 = parser.ReadOffset <uint>(0x30);

            // col: 7 offset: 0034
            unknown34 = parser.ReadOffset <uint>(0x34);

            // col: 13 offset: 0038
            UnlockQuest = parser.ReadOffset <uint>(0x38);

            // col: 38 offset: 003c
            Transient = parser.ReadOffset <uint>(0x3c);

            // col: 40 offset: 0040
            Image = parser.ReadOffset <uint>(0x40);

            // col: 41 offset: 0044
            Icon = parser.ReadOffset <uint>(0x44);

            // col: 1 offset: 0048
            TerritoryType = parser.ReadOffset <ushort>(0x48);

            // col: 3 offset: 004a
            Content = parser.ReadOffset <ushort>(0x4a);

            // col: 14 offset: 004c
            unknown4c = parser.ReadOffset <ushort>(0x4c);

            // col: 17 offset: 004e
            ItemLevelRequired = parser.ReadOffset <ushort>(0x4e);

            // col: 18 offset: 0050
            ItemLevelSync = parser.ReadOffset <ushort>(0x50);

            // col: 39 offset: 0052
            SortKey = parser.ReadOffset <ushort>(0x52);

            // col: 2 offset: 0054
            ContentLinkType = parser.ReadOffset <byte>(0x54);

            // col: 5 offset: 0055
            unknown55 = parser.ReadOffset <byte>(0x55);

            // col: 8 offset: 0056
            AcceptClassJobCategory = parser.ReadOffset <byte>(0x56);

            // col: 9 offset: 0057
            ContentMemberType = parser.ReadOffset <byte>(0x57);

            // col: 10 offset: 0058
            unknown58 = parser.ReadOffset <byte>(0x58);

            // col: 11 offset: 0059
            unknown59 = parser.ReadOffset <byte>(0x59);

            // col: 12 offset: 005a
            unknown5a = parser.ReadOffset <byte>(0x5a);

            // col: 15 offset: 005b
            ClassJobLevelRequired = parser.ReadOffset <byte>(0x5b);

            // col: 16 offset: 005c
            ClassJobLevelSync = parser.ReadOffset <byte>(0x5c);

            // col: 24 offset: 005d
            unknown5d = parser.ReadOffset <byte>(0x5d);

            // col: 36 offset: 005e
            ContentType = parser.ReadOffset <byte>(0x5e);

            // col: 37 offset: 005f
            TransientKey = parser.ReadOffset <byte>(0x5f);

            // col: 42 offset: 0060
            unknown60 = parser.ReadOffset <sbyte>(0x60);

            // col: 4 offset: 0061
            packed61 = parser.ReadOffset <byte>(0x61, ExcelColumnDataType.UInt8);

            // col: 27 offset: 0062
            packed62 = parser.ReadOffset <byte>(0x62, ExcelColumnDataType.UInt8);
        }
Example #8
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 1 offset: 0000
            Recipe      = new int[160];
            Recipe[0]   = parser.ReadOffset <int>(0x0);
            Recipe[1]   = parser.ReadOffset <int>(0x4);
            Recipe[2]   = parser.ReadOffset <int>(0x8);
            Recipe[3]   = parser.ReadOffset <int>(0xc);
            Recipe[4]   = parser.ReadOffset <int>(0x10);
            Recipe[5]   = parser.ReadOffset <int>(0x14);
            Recipe[6]   = parser.ReadOffset <int>(0x18);
            Recipe[7]   = parser.ReadOffset <int>(0x1c);
            Recipe[8]   = parser.ReadOffset <int>(0x20);
            Recipe[9]   = parser.ReadOffset <int>(0x24);
            Recipe[10]  = parser.ReadOffset <int>(0x28);
            Recipe[11]  = parser.ReadOffset <int>(0x2c);
            Recipe[12]  = parser.ReadOffset <int>(0x30);
            Recipe[13]  = parser.ReadOffset <int>(0x34);
            Recipe[14]  = parser.ReadOffset <int>(0x38);
            Recipe[15]  = parser.ReadOffset <int>(0x3c);
            Recipe[16]  = parser.ReadOffset <int>(0x40);
            Recipe[17]  = parser.ReadOffset <int>(0x44);
            Recipe[18]  = parser.ReadOffset <int>(0x48);
            Recipe[19]  = parser.ReadOffset <int>(0x4c);
            Recipe[20]  = parser.ReadOffset <int>(0x50);
            Recipe[21]  = parser.ReadOffset <int>(0x54);
            Recipe[22]  = parser.ReadOffset <int>(0x58);
            Recipe[23]  = parser.ReadOffset <int>(0x5c);
            Recipe[24]  = parser.ReadOffset <int>(0x60);
            Recipe[25]  = parser.ReadOffset <int>(0x64);
            Recipe[26]  = parser.ReadOffset <int>(0x68);
            Recipe[27]  = parser.ReadOffset <int>(0x6c);
            Recipe[28]  = parser.ReadOffset <int>(0x70);
            Recipe[29]  = parser.ReadOffset <int>(0x74);
            Recipe[30]  = parser.ReadOffset <int>(0x78);
            Recipe[31]  = parser.ReadOffset <int>(0x7c);
            Recipe[32]  = parser.ReadOffset <int>(0x80);
            Recipe[33]  = parser.ReadOffset <int>(0x84);
            Recipe[34]  = parser.ReadOffset <int>(0x88);
            Recipe[35]  = parser.ReadOffset <int>(0x8c);
            Recipe[36]  = parser.ReadOffset <int>(0x90);
            Recipe[37]  = parser.ReadOffset <int>(0x94);
            Recipe[38]  = parser.ReadOffset <int>(0x98);
            Recipe[39]  = parser.ReadOffset <int>(0x9c);
            Recipe[40]  = parser.ReadOffset <int>(0xa0);
            Recipe[41]  = parser.ReadOffset <int>(0xa4);
            Recipe[42]  = parser.ReadOffset <int>(0xa8);
            Recipe[43]  = parser.ReadOffset <int>(0xac);
            Recipe[44]  = parser.ReadOffset <int>(0xb0);
            Recipe[45]  = parser.ReadOffset <int>(0xb4);
            Recipe[46]  = parser.ReadOffset <int>(0xb8);
            Recipe[47]  = parser.ReadOffset <int>(0xbc);
            Recipe[48]  = parser.ReadOffset <int>(0xc0);
            Recipe[49]  = parser.ReadOffset <int>(0xc4);
            Recipe[50]  = parser.ReadOffset <int>(0xc8);
            Recipe[51]  = parser.ReadOffset <int>(0xcc);
            Recipe[52]  = parser.ReadOffset <int>(0xd0);
            Recipe[53]  = parser.ReadOffset <int>(0xd4);
            Recipe[54]  = parser.ReadOffset <int>(0xd8);
            Recipe[55]  = parser.ReadOffset <int>(0xdc);
            Recipe[56]  = parser.ReadOffset <int>(0xe0);
            Recipe[57]  = parser.ReadOffset <int>(0xe4);
            Recipe[58]  = parser.ReadOffset <int>(0xe8);
            Recipe[59]  = parser.ReadOffset <int>(0xec);
            Recipe[60]  = parser.ReadOffset <int>(0xf0);
            Recipe[61]  = parser.ReadOffset <int>(0xf4);
            Recipe[62]  = parser.ReadOffset <int>(0xf8);
            Recipe[63]  = parser.ReadOffset <int>(0xfc);
            Recipe[64]  = parser.ReadOffset <int>(0x100);
            Recipe[65]  = parser.ReadOffset <int>(0x104);
            Recipe[66]  = parser.ReadOffset <int>(0x108);
            Recipe[67]  = parser.ReadOffset <int>(0x10c);
            Recipe[68]  = parser.ReadOffset <int>(0x110);
            Recipe[69]  = parser.ReadOffset <int>(0x114);
            Recipe[70]  = parser.ReadOffset <int>(0x118);
            Recipe[71]  = parser.ReadOffset <int>(0x11c);
            Recipe[72]  = parser.ReadOffset <int>(0x120);
            Recipe[73]  = parser.ReadOffset <int>(0x124);
            Recipe[74]  = parser.ReadOffset <int>(0x128);
            Recipe[75]  = parser.ReadOffset <int>(0x12c);
            Recipe[76]  = parser.ReadOffset <int>(0x130);
            Recipe[77]  = parser.ReadOffset <int>(0x134);
            Recipe[78]  = parser.ReadOffset <int>(0x138);
            Recipe[79]  = parser.ReadOffset <int>(0x13c);
            Recipe[80]  = parser.ReadOffset <int>(0x140);
            Recipe[81]  = parser.ReadOffset <int>(0x144);
            Recipe[82]  = parser.ReadOffset <int>(0x148);
            Recipe[83]  = parser.ReadOffset <int>(0x14c);
            Recipe[84]  = parser.ReadOffset <int>(0x150);
            Recipe[85]  = parser.ReadOffset <int>(0x154);
            Recipe[86]  = parser.ReadOffset <int>(0x158);
            Recipe[87]  = parser.ReadOffset <int>(0x15c);
            Recipe[88]  = parser.ReadOffset <int>(0x160);
            Recipe[89]  = parser.ReadOffset <int>(0x164);
            Recipe[90]  = parser.ReadOffset <int>(0x168);
            Recipe[91]  = parser.ReadOffset <int>(0x16c);
            Recipe[92]  = parser.ReadOffset <int>(0x170);
            Recipe[93]  = parser.ReadOffset <int>(0x174);
            Recipe[94]  = parser.ReadOffset <int>(0x178);
            Recipe[95]  = parser.ReadOffset <int>(0x17c);
            Recipe[96]  = parser.ReadOffset <int>(0x180);
            Recipe[97]  = parser.ReadOffset <int>(0x184);
            Recipe[98]  = parser.ReadOffset <int>(0x188);
            Recipe[99]  = parser.ReadOffset <int>(0x18c);
            Recipe[100] = parser.ReadOffset <int>(0x190);
            Recipe[101] = parser.ReadOffset <int>(0x194);
            Recipe[102] = parser.ReadOffset <int>(0x198);
            Recipe[103] = parser.ReadOffset <int>(0x19c);
            Recipe[104] = parser.ReadOffset <int>(0x1a0);
            Recipe[105] = parser.ReadOffset <int>(0x1a4);
            Recipe[106] = parser.ReadOffset <int>(0x1a8);
            Recipe[107] = parser.ReadOffset <int>(0x1ac);
            Recipe[108] = parser.ReadOffset <int>(0x1b0);
            Recipe[109] = parser.ReadOffset <int>(0x1b4);
            Recipe[110] = parser.ReadOffset <int>(0x1b8);
            Recipe[111] = parser.ReadOffset <int>(0x1bc);
            Recipe[112] = parser.ReadOffset <int>(0x1c0);
            Recipe[113] = parser.ReadOffset <int>(0x1c4);
            Recipe[114] = parser.ReadOffset <int>(0x1c8);
            Recipe[115] = parser.ReadOffset <int>(0x1cc);
            Recipe[116] = parser.ReadOffset <int>(0x1d0);
            Recipe[117] = parser.ReadOffset <int>(0x1d4);
            Recipe[118] = parser.ReadOffset <int>(0x1d8);
            Recipe[119] = parser.ReadOffset <int>(0x1dc);
            Recipe[120] = parser.ReadOffset <int>(0x1e0);
            Recipe[121] = parser.ReadOffset <int>(0x1e4);
            Recipe[122] = parser.ReadOffset <int>(0x1e8);
            Recipe[123] = parser.ReadOffset <int>(0x1ec);
            Recipe[124] = parser.ReadOffset <int>(0x1f0);
            Recipe[125] = parser.ReadOffset <int>(0x1f4);
            Recipe[126] = parser.ReadOffset <int>(0x1f8);
            Recipe[127] = parser.ReadOffset <int>(0x1fc);
            Recipe[128] = parser.ReadOffset <int>(0x200);
            Recipe[129] = parser.ReadOffset <int>(0x204);
            Recipe[130] = parser.ReadOffset <int>(0x208);
            Recipe[131] = parser.ReadOffset <int>(0x20c);
            Recipe[132] = parser.ReadOffset <int>(0x210);
            Recipe[133] = parser.ReadOffset <int>(0x214);
            Recipe[134] = parser.ReadOffset <int>(0x218);
            Recipe[135] = parser.ReadOffset <int>(0x21c);
            Recipe[136] = parser.ReadOffset <int>(0x220);
            Recipe[137] = parser.ReadOffset <int>(0x224);
            Recipe[138] = parser.ReadOffset <int>(0x228);
            Recipe[139] = parser.ReadOffset <int>(0x22c);
            Recipe[140] = parser.ReadOffset <int>(0x230);
            Recipe[141] = parser.ReadOffset <int>(0x234);
            Recipe[142] = parser.ReadOffset <int>(0x238);
            Recipe[143] = parser.ReadOffset <int>(0x23c);
            Recipe[144] = parser.ReadOffset <int>(0x240);
            Recipe[145] = parser.ReadOffset <int>(0x244);
            Recipe[146] = parser.ReadOffset <int>(0x248);
            Recipe[147] = parser.ReadOffset <int>(0x24c);
            Recipe[148] = parser.ReadOffset <int>(0x250);
            Recipe[149] = parser.ReadOffset <int>(0x254);
            Recipe[150] = parser.ReadOffset <int>(0x258);
            Recipe[151] = parser.ReadOffset <int>(0x25c);
            Recipe[152] = parser.ReadOffset <int>(0x260);
            Recipe[153] = parser.ReadOffset <int>(0x264);
            Recipe[154] = parser.ReadOffset <int>(0x268);
            Recipe[155] = parser.ReadOffset <int>(0x26c);
            Recipe[156] = parser.ReadOffset <int>(0x270);
            Recipe[157] = parser.ReadOffset <int>(0x274);
            Recipe[158] = parser.ReadOffset <int>(0x278);
            Recipe[159] = parser.ReadOffset <int>(0x27c);

            // col: 0 offset: 0280
            unknown280 = parser.ReadOffset <byte>(0x280);
        }
Example #9
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Leve = parser.ReadOffset <int>(0x0);

            // col: 1 offset: 0004
            CraftLeveTalk = parser.ReadOffset <int>(0x4);

            // col: 3 offset: 0008
            unknown8    = new int[4];
            unknown8[0] = parser.ReadOffset <int>(0x8);
            unknown8[1] = parser.ReadOffset <int>(0x18);
            unknown8[2] = parser.ReadOffset <int>(0xc);
            unknown8[3] = parser.ReadOffset <int>(0x1a);

            // col: 7 offset: 0010
            unknown10 = parser.ReadOffset <int>(0x10);

            // col: 9 offset: 0014
            unknown14 = parser.ReadOffset <int>(0x14);

            // col: 8 offset: 001c
            unknown1c = parser.ReadOffset <ushort>(0x1c);

            // col: 10 offset: 001e
            unknown1e = parser.ReadOffset <ushort>(0x1e);

            // col: 2 offset: 0020
            Repeats = parser.ReadOffset <byte>(0x20);
        }
Example #10
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 1 offset: 0000
            Singular = parser.ReadOffset <string>(0x0);

            // col: 3 offset: 0004
            Plural = parser.ReadOffset <string>(0x4);

            // col: 9 offset: 0008
            Name = parser.ReadOffset <string>(0x8);

            // col: 10 offset: 000c
            Tooltip = parser.ReadOffset <string>(0xc);

            // col: 2 offset: 0010
            Adjective = parser.ReadOffset <sbyte>(0x10);

            // col: 4 offset: 0011
            PossessivePronoun = parser.ReadOffset <sbyte>(0x11);

            // col: 5 offset: 0012
            StartsWithVowel = parser.ReadOffset <sbyte>(0x12);

            // col: 6 offset: 0013
            unknown13 = parser.ReadOffset <sbyte>(0x13);

            // col: 7 offset: 0014
            Pronoun = parser.ReadOffset <sbyte>(0x14);

            // col: 8 offset: 0015
            Article = parser.ReadOffset <sbyte>(0x15);

            // col: 0 offset: 0018
            Icon = parser.ReadOffset <uint>(0x18);

            // col: 11 offset: 001c
            Action = parser.ReadOffset <uint>(0x1c);
        }
Example #11
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            BNPC = parser.ReadOffset <ushort>(0x0);

            // col: 3 offset: 0002
            Angle = parser.ReadOffset <ushort>(0x2);

            // col: 7 offset: 0004
            Action0 = parser.ReadOffset <ushort>(0x4);

            // col: 8 offset: 0006
            Action1 = parser.ReadOffset <ushort>(0x6);

            // col: 9 offset: 0008
            Action2 = parser.ReadOffset <ushort>(0x8);

            // col: 10 offset: 000a
            Action3 = parser.ReadOffset <ushort>(0xa);

            // col: 4 offset: 000c
            Bullet = parser.ReadOffset <byte>(0xc);

            // col: 5 offset: 000d
            unknownd = parser.ReadOffset <byte>(0xd);

            // col: 6 offset: 000e
            unknowne = parser.ReadOffset <byte>(0xe);

            // col: 1 offset: 000f
            Near = parser.ReadOffset <sbyte>(0xf);

            // col: 2 offset: 0010
            Far = parser.ReadOffset <sbyte>(0x10);
        }
Example #12
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            CameraDistance = parser.ReadOffset <float>(0x0);

            // col: 1 offset: 0004
            SampleInterval = parser.ReadOffset <float>(0x4);

            // col: 2 offset: 0008
            BoneLOD = parser.ReadOffset <sbyte>(0x8);

            // col: 3 offset: 0009
            AnimationEnable    = new bool[8];
            AnimationEnable[0] = parser.ReadOffset <bool>(0x9);
            AnimationEnable[1] = parser.ReadOffset <bool>(0xa);
            AnimationEnable[2] = parser.ReadOffset <bool>(0xb);
            AnimationEnable[3] = parser.ReadOffset <bool>(0xc);
            AnimationEnable[4] = parser.ReadOffset <bool>(0xd);
            AnimationEnable[5] = parser.ReadOffset <bool>(0xe);
            AnimationEnable[6] = parser.ReadOffset <bool>(0xf);
            AnimationEnable[7] = parser.ReadOffset <bool>(0x10);
        }
Example #13
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Time    = new ushort[8];
            Time[0] = parser.ReadOffset <ushort>(0x0);
            Time[1] = parser.ReadOffset <ushort>(0x2);
            Time[2] = parser.ReadOffset <ushort>(0x4);
            Time[3] = parser.ReadOffset <ushort>(0x6);
            Time[4] = parser.ReadOffset <ushort>(0x8);
            Time[5] = parser.ReadOffset <ushort>(0xa);
            Time[6] = parser.ReadOffset <ushort>(0xc);
            Time[7] = parser.ReadOffset <ushort>(0xe);

            // col: 24 offset: 0010
            BNpcName    = new uint[8];
            BNpcName[0] = parser.ReadOffset <uint>(0x10);
            BNpcName[1] = parser.ReadOffset <uint>(0x40);
            BNpcName[2] = parser.ReadOffset <uint>(0x70);
            BNpcName[3] = parser.ReadOffset <uint>(0xa0);
            BNpcName[4] = parser.ReadOffset <uint>(0xd0);
            BNpcName[5] = parser.ReadOffset <uint>(0x100);
            BNpcName[6] = parser.ReadOffset <uint>(0x130);
            BNpcName[7] = parser.ReadOffset <uint>(0x160);

            // col: 56 offset: 0014
            ToDoNumberInvolved    = new uint[8];
            ToDoNumberInvolved[0] = parser.ReadOffset <uint>(0x14);
            ToDoNumberInvolved[1] = parser.ReadOffset <uint>(0x44);
            ToDoNumberInvolved[2] = parser.ReadOffset <uint>(0x74);
            ToDoNumberInvolved[3] = parser.ReadOffset <uint>(0xa4);
            ToDoNumberInvolved[4] = parser.ReadOffset <uint>(0xd4);
            ToDoNumberInvolved[5] = parser.ReadOffset <uint>(0x104);
            ToDoNumberInvolved[6] = parser.ReadOffset <uint>(0x134);
            ToDoNumberInvolved[7] = parser.ReadOffset <uint>(0x164);

            // col: 64 offset: 0018
            ToDoParam    = new uint[8];
            ToDoParam[0] = parser.ReadOffset <uint>(0x18);
            ToDoParam[1] = parser.ReadOffset <uint>(0x48);
            ToDoParam[2] = parser.ReadOffset <uint>(0x78);
            ToDoParam[3] = parser.ReadOffset <uint>(0xa8);
            ToDoParam[4] = parser.ReadOffset <uint>(0xd8);
            ToDoParam[5] = parser.ReadOffset <uint>(0x108);
            ToDoParam[6] = parser.ReadOffset <uint>(0x138);
            ToDoParam[7] = parser.ReadOffset <uint>(0x168);

            // col: 72 offset: 001c
            unknown1c = parser.ReadOffset <uint>(0x1c);

            // col: 80 offset: 0020
            unknown20 = parser.ReadOffset <uint>(0x20);

            // col: 88 offset: 0024
            unknown24 = parser.ReadOffset <uint>(0x24);

            // col: 96 offset: 0028
            unknown28 = parser.ReadOffset <uint>(0x28);

            // col: 8 offset: 002c
            BaseID    = new int[8];
            BaseID[0] = parser.ReadOffset <int>(0x2c);
            BaseID[1] = parser.ReadOffset <int>(0x5c);
            BaseID[2] = parser.ReadOffset <int>(0x8c);
            BaseID[3] = parser.ReadOffset <int>(0xbc);
            BaseID[4] = parser.ReadOffset <int>(0xec);
            BaseID[5] = parser.ReadOffset <int>(0x11c);
            BaseID[6] = parser.ReadOffset <int>(0x14c);
            BaseID[7] = parser.ReadOffset <int>(0x17c);

            // col: 32 offset: 0030
            ItemsInvolved    = new int[8];
            ItemsInvolved[0] = parser.ReadOffset <int>(0x30);
            ItemsInvolved[1] = parser.ReadOffset <int>(0x60);
            ItemsInvolved[2] = parser.ReadOffset <int>(0x90);
            ItemsInvolved[3] = parser.ReadOffset <int>(0xc0);
            ItemsInvolved[4] = parser.ReadOffset <int>(0xf0);
            ItemsInvolved[5] = parser.ReadOffset <int>(0x120);
            ItemsInvolved[6] = parser.ReadOffset <int>(0x150);
            ItemsInvolved[7] = parser.ReadOffset <int>(0x180);

            // col: 16 offset: 0034
            EnemyLevel    = new ushort[8];
            EnemyLevel[0] = parser.ReadOffset <ushort>(0x34);
            EnemyLevel[1] = parser.ReadOffset <ushort>(0x64);
            EnemyLevel[2] = parser.ReadOffset <ushort>(0x94);
            EnemyLevel[3] = parser.ReadOffset <ushort>(0xc4);
            EnemyLevel[4] = parser.ReadOffset <ushort>(0xf4);
            EnemyLevel[5] = parser.ReadOffset <ushort>(0x124);
            EnemyLevel[6] = parser.ReadOffset <ushort>(0x154);
            EnemyLevel[7] = parser.ReadOffset <ushort>(0x184);

            // col: 40 offset: 0036
            ItemsInvolvedQty    = new byte[8];
            ItemsInvolvedQty[0] = parser.ReadOffset <byte>(0x36);
            ItemsInvolvedQty[1] = parser.ReadOffset <byte>(0x66);
            ItemsInvolvedQty[2] = parser.ReadOffset <byte>(0x96);
            ItemsInvolvedQty[3] = parser.ReadOffset <byte>(0xc6);
            ItemsInvolvedQty[4] = parser.ReadOffset <byte>(0xf6);
            ItemsInvolvedQty[5] = parser.ReadOffset <byte>(0x126);
            ItemsInvolvedQty[6] = parser.ReadOffset <byte>(0x156);
            ItemsInvolvedQty[7] = parser.ReadOffset <byte>(0x186);

            // col: 48 offset: 0037
            ItemDropRate    = new byte[8];
            ItemDropRate[0] = parser.ReadOffset <byte>(0x37);
            ItemDropRate[1] = parser.ReadOffset <byte>(0x67);
            ItemDropRate[2] = parser.ReadOffset <byte>(0x97);
            ItemDropRate[3] = parser.ReadOffset <byte>(0xc7);
            ItemDropRate[4] = parser.ReadOffset <byte>(0xf7);
            ItemDropRate[5] = parser.ReadOffset <byte>(0x127);
            ItemDropRate[6] = parser.ReadOffset <byte>(0x157);
            ItemDropRate[7] = parser.ReadOffset <byte>(0x187);

            // col: 104 offset: 0038
            unknown38 = parser.ReadOffset <byte>(0x38);

            // col: 112 offset: 0039
            unknown39 = parser.ReadOffset <byte>(0x39);

            // col: 120 offset: 003a
            unknown3a = parser.ReadOffset <byte>(0x3a);

            // col: 128 offset: 003b
            unknown3b = parser.ReadOffset <byte>(0x3b);

            // col: 136 offset: 003c
            unknown3c = parser.ReadOffset <byte>(0x3c);

            // col: 144 offset: 003d
            unknown3d = parser.ReadOffset <byte>(0x3d);

            // col: 152 offset: 003e
            unknown3e = parser.ReadOffset <byte>(0x3e);

            // col: 160 offset: 003f
            unknown3f = parser.ReadOffset <byte>(0x3f);

            // col: 73 offset: 004c
            unknown4c = parser.ReadOffset <uint>(0x4c);

            // col: 81 offset: 0050
            unknown50 = parser.ReadOffset <uint>(0x50);

            // col: 89 offset: 0054
            unknown54 = parser.ReadOffset <uint>(0x54);

            // col: 97 offset: 0058
            unknown58 = parser.ReadOffset <uint>(0x58);

            // col: 105 offset: 0068
            unknown68 = parser.ReadOffset <byte>(0x68);

            // col: 113 offset: 0069
            unknown69 = parser.ReadOffset <byte>(0x69);

            // col: 121 offset: 006a
            unknown6a = parser.ReadOffset <byte>(0x6a);

            // col: 129 offset: 006b
            unknown6b = parser.ReadOffset <byte>(0x6b);

            // col: 137 offset: 006c
            unknown6c = parser.ReadOffset <byte>(0x6c);

            // col: 145 offset: 006d
            unknown6d = parser.ReadOffset <byte>(0x6d);

            // col: 153 offset: 006e
            unknown6e = parser.ReadOffset <byte>(0x6e);

            // col: 161 offset: 006f
            unknown6f = parser.ReadOffset <byte>(0x6f);

            // col: 74 offset: 007c
            unknown7c = parser.ReadOffset <uint>(0x7c);

            // col: 82 offset: 0080
            unknown80 = parser.ReadOffset <uint>(0x80);

            // col: 90 offset: 0084
            unknown84 = parser.ReadOffset <uint>(0x84);

            // col: 98 offset: 0088
            unknown88 = parser.ReadOffset <uint>(0x88);

            // col: 106 offset: 0098
            unknown98 = parser.ReadOffset <byte>(0x98);

            // col: 114 offset: 0099
            unknown99 = parser.ReadOffset <byte>(0x99);

            // col: 122 offset: 009a
            unknown9a = parser.ReadOffset <byte>(0x9a);

            // col: 130 offset: 009b
            unknown9b = parser.ReadOffset <byte>(0x9b);

            // col: 138 offset: 009c
            unknown9c = parser.ReadOffset <byte>(0x9c);

            // col: 146 offset: 009d
            unknown9d = parser.ReadOffset <byte>(0x9d);

            // col: 154 offset: 009e
            unknown9e = parser.ReadOffset <byte>(0x9e);

            // col: 162 offset: 009f
            unknown9f = parser.ReadOffset <byte>(0x9f);

            // col: 75 offset: 00ac
            unknownac = parser.ReadOffset <uint>(0xac);

            // col: 83 offset: 00b0
            unknownb0 = parser.ReadOffset <uint>(0xb0);

            // col: 91 offset: 00b4
            unknownb4 = parser.ReadOffset <uint>(0xb4);

            // col: 99 offset: 00b8
            unknownb8 = parser.ReadOffset <uint>(0xb8);

            // col: 107 offset: 00c8
            unknownc8 = parser.ReadOffset <byte>(0xc8);

            // col: 115 offset: 00c9
            unknownc9 = parser.ReadOffset <byte>(0xc9);

            // col: 123 offset: 00ca
            unknownca = parser.ReadOffset <byte>(0xca);

            // col: 131 offset: 00cb
            unknowncb = parser.ReadOffset <byte>(0xcb);

            // col: 139 offset: 00cc
            unknowncc = parser.ReadOffset <byte>(0xcc);

            // col: 147 offset: 00cd
            unknowncd = parser.ReadOffset <byte>(0xcd);

            // col: 155 offset: 00ce
            unknownce = parser.ReadOffset <byte>(0xce);

            // col: 163 offset: 00cf
            unknowncf = parser.ReadOffset <byte>(0xcf);

            // col: 76 offset: 00dc
            unknowndc = parser.ReadOffset <uint>(0xdc);

            // col: 84 offset: 00e0
            unknowne0 = parser.ReadOffset <uint>(0xe0);

            // col: 92 offset: 00e4
            unknowne4 = parser.ReadOffset <uint>(0xe4);

            // col: 100 offset: 00e8
            unknowne8 = parser.ReadOffset <uint>(0xe8);

            // col: 108 offset: 00f8
            unknownf8 = parser.ReadOffset <byte>(0xf8);

            // col: 116 offset: 00f9
            unknownf9 = parser.ReadOffset <byte>(0xf9);

            // col: 124 offset: 00fa
            unknownfa = parser.ReadOffset <byte>(0xfa);

            // col: 132 offset: 00fb
            unknownfb = parser.ReadOffset <byte>(0xfb);

            // col: 140 offset: 00fc
            unknownfc = parser.ReadOffset <byte>(0xfc);

            // col: 148 offset: 00fd
            unknownfd = parser.ReadOffset <byte>(0xfd);

            // col: 156 offset: 00fe
            unknownfe = parser.ReadOffset <byte>(0xfe);

            // col: 164 offset: 00ff
            unknownff = parser.ReadOffset <byte>(0xff);

            // col: 77 offset: 010c
            unknown10c = parser.ReadOffset <uint>(0x10c);

            // col: 85 offset: 0110
            unknown110 = parser.ReadOffset <uint>(0x110);

            // col: 93 offset: 0114
            unknown114 = parser.ReadOffset <uint>(0x114);

            // col: 101 offset: 0118
            unknown118 = parser.ReadOffset <uint>(0x118);

            // col: 109 offset: 0128
            unknown128 = parser.ReadOffset <byte>(0x128);

            // col: 117 offset: 0129
            unknown129 = parser.ReadOffset <byte>(0x129);

            // col: 125 offset: 012a
            unknown12a = parser.ReadOffset <byte>(0x12a);

            // col: 133 offset: 012b
            unknown12b = parser.ReadOffset <byte>(0x12b);

            // col: 141 offset: 012c
            unknown12c = parser.ReadOffset <byte>(0x12c);

            // col: 149 offset: 012d
            unknown12d = parser.ReadOffset <byte>(0x12d);

            // col: 157 offset: 012e
            unknown12e = parser.ReadOffset <byte>(0x12e);

            // col: 165 offset: 012f
            unknown12f = parser.ReadOffset <byte>(0x12f);

            // col: 78 offset: 013c
            unknown13c = parser.ReadOffset <uint>(0x13c);

            // col: 86 offset: 0140
            unknown140 = parser.ReadOffset <uint>(0x140);

            // col: 94 offset: 0144
            unknown144 = parser.ReadOffset <uint>(0x144);

            // col: 102 offset: 0148
            unknown148 = parser.ReadOffset <uint>(0x148);

            // col: 110 offset: 0158
            unknown158 = parser.ReadOffset <byte>(0x158);

            // col: 118 offset: 0159
            unknown159 = parser.ReadOffset <byte>(0x159);

            // col: 126 offset: 015a
            unknown15a = parser.ReadOffset <byte>(0x15a);

            // col: 134 offset: 015b
            unknown15b = parser.ReadOffset <byte>(0x15b);

            // col: 142 offset: 015c
            unknown15c = parser.ReadOffset <byte>(0x15c);

            // col: 150 offset: 015d
            unknown15d = parser.ReadOffset <byte>(0x15d);

            // col: 158 offset: 015e
            unknown15e = parser.ReadOffset <byte>(0x15e);

            // col: 166 offset: 015f
            unknown15f = parser.ReadOffset <byte>(0x15f);

            // col: 79 offset: 016c
            unknown16c = parser.ReadOffset <uint>(0x16c);

            // col: 87 offset: 0170
            unknown170 = parser.ReadOffset <uint>(0x170);

            // col: 95 offset: 0174
            unknown174 = parser.ReadOffset <uint>(0x174);

            // col: 103 offset: 0178
            unknown178 = parser.ReadOffset <uint>(0x178);

            // col: 111 offset: 0188
            unknown188 = parser.ReadOffset <byte>(0x188);

            // col: 119 offset: 0189
            unknown189 = parser.ReadOffset <byte>(0x189);

            // col: 127 offset: 018a
            unknown18a = parser.ReadOffset <byte>(0x18a);

            // col: 135 offset: 018b
            unknown18b = parser.ReadOffset <byte>(0x18b);

            // col: 143 offset: 018c
            unknown18c = parser.ReadOffset <byte>(0x18c);

            // col: 151 offset: 018d
            unknown18d = parser.ReadOffset <byte>(0x18d);

            // col: 159 offset: 018e
            unknown18e = parser.ReadOffset <byte>(0x18e);

            // col: 167 offset: 018f
            unknown18f = parser.ReadOffset <byte>(0x18f);

            // col: 168 offset: 0190
            unknown190 = parser.ReadOffset <byte>(0x190);

            // col: 169 offset: 0191
            unknown191 = parser.ReadOffset <byte>(0x191);

            // col: 170 offset: 0192
            unknown192 = parser.ReadOffset <byte>(0x192);

            // col: 171 offset: 0193
            unknown193 = parser.ReadOffset <byte>(0x193);

            // col: 172 offset: 0194
            unknown194 = parser.ReadOffset <byte>(0x194);

            // col: 173 offset: 0195
            unknown195 = parser.ReadOffset <byte>(0x195);

            // col: 174 offset: 0196
            unknown196 = parser.ReadOffset <byte>(0x196);

            // col: 175 offset: 0197
            unknown197 = parser.ReadOffset <byte>(0x197);

            // col: 176 offset: 0198
            Rule = parser.ReadOffset <int>(0x198);

            // col: 177 offset: 019c
            RuleParam = parser.ReadOffset <byte>(0x19c);
        }
Example #14
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 7 offset: 0000
            Experience = parser.ReadOffset <int>(0x0);

            // col: 3 offset: 0004
            unknown4 = parser.ReadOffset <ushort>(0x4);

            // col: 4 offset: 0006
            RetainerTaskParameter = parser.ReadOffset <ushort>(0x6);

            // col: 5 offset: 0008
            VentureCost = parser.ReadOffset <ushort>(0x8);

            // col: 6 offset: 000a
            MaxTimemin = parser.ReadOffset <ushort>(0xa);

            // col: 8 offset: 000c
            RequiredItemLevel = parser.ReadOffset <ushort>(0xc);

            // col: 11 offset: 000e
            RequiredGathering = parser.ReadOffset <ushort>(0xe);

            // col: 12 offset: 0010
            unknown10 = parser.ReadOffset <ushort>(0x10);

            // col: 13 offset: 0012
            Task = parser.ReadOffset <ushort>(0x12);

            // col: 1 offset: 0014
            ClassJobCategory = parser.ReadOffset <byte>(0x14);

            // col: 2 offset: 0015
            RetainerLevel = parser.ReadOffset <byte>(0x15);

            // col: 9 offset: 0016
            unknown16 = parser.ReadOffset <byte>(0x16);

            // col: 10 offset: 0017
            unknown17 = parser.ReadOffset <byte>(0x17);

            // col: 0 offset: 0018
            packed18 = parser.ReadOffset <byte>(0x18, ExcelColumnDataType.UInt8);
        }
Example #15
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Quest = parser.ReadOffset <uint>(0x0);

            // col: 2 offset: 0004
            Image1 = parser.ReadOffset <uint>(0x4);

            // col: 4 offset: 0008
            Image2 = parser.ReadOffset <uint>(0x8);

            // col: 6 offset: 000c
            Image3 = parser.ReadOffset <uint>(0xc);

            // col: 8 offset: 0010
            Image4 = parser.ReadOffset <uint>(0x10);

            // col: 10 offset: 0014
            Image5 = parser.ReadOffset <uint>(0x14);

            // col: 12 offset: 0018
            Image6 = parser.ReadOffset <uint>(0x18);

            // col: 14 offset: 001c
            Image7 = parser.ReadOffset <uint>(0x1c);

            // col: 16 offset: 0020
            Image8 = parser.ReadOffset <uint>(0x20);

            // col: 18 offset: 0024
            Image9 = parser.ReadOffset <uint>(0x24);

            // col: 20 offset: 0028
            unknown28 = parser.ReadOffset <uint>(0x28);

            // col: 22 offset: 002c
            unknown2c = parser.ReadOffset <uint>(0x2c);

            // col: 1 offset: 0030
            Text1 = parser.ReadOffset <ushort>(0x30);

            // col: 3 offset: 0032
            Text2 = parser.ReadOffset <ushort>(0x32);

            // col: 5 offset: 0034
            Text3 = parser.ReadOffset <ushort>(0x34);

            // col: 7 offset: 0036
            Text4 = parser.ReadOffset <ushort>(0x36);

            // col: 9 offset: 0038
            Text5 = parser.ReadOffset <ushort>(0x38);

            // col: 11 offset: 003a
            Text6 = parser.ReadOffset <ushort>(0x3a);

            // col: 13 offset: 003c
            Text7 = parser.ReadOffset <ushort>(0x3c);

            // col: 15 offset: 003e
            Text8 = parser.ReadOffset <ushort>(0x3e);

            // col: 17 offset: 0040
            Text9 = parser.ReadOffset <ushort>(0x40);

            // col: 19 offset: 0042
            unknown42 = parser.ReadOffset <ushort>(0x42);

            // col: 21 offset: 0044
            unknown44 = parser.ReadOffset <ushort>(0x44);

            // col: 23 offset: 0046
            unknown46 = parser.ReadOffset <ushort>(0x46);
        }
Example #16
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 32 offset: 0000
            unknown0 = parser.ReadOffset <ushort>(0x0);

            // col: 0 offset: 0002
            WeeklyLotBonusThreshold     = new byte[31];
            WeeklyLotBonusThreshold[0]  = parser.ReadOffset <byte>(0x2);
            WeeklyLotBonusThreshold[1]  = parser.ReadOffset <byte>(0x6);
            WeeklyLotBonusThreshold[2]  = parser.ReadOffset <byte>(0xa);
            WeeklyLotBonusThreshold[3]  = parser.ReadOffset <byte>(0xe);
            WeeklyLotBonusThreshold[4]  = parser.ReadOffset <byte>(0x12);
            WeeklyLotBonusThreshold[5]  = parser.ReadOffset <byte>(0x16);
            WeeklyLotBonusThreshold[6]  = parser.ReadOffset <byte>(0x1a);
            WeeklyLotBonusThreshold[7]  = parser.ReadOffset <byte>(0x1e);
            WeeklyLotBonusThreshold[8]  = parser.ReadOffset <byte>(0x22);
            WeeklyLotBonusThreshold[9]  = parser.ReadOffset <byte>(0x26);
            WeeklyLotBonusThreshold[10] = parser.ReadOffset <byte>(0x2a);
            WeeklyLotBonusThreshold[11] = parser.ReadOffset <byte>(0x2e);
            WeeklyLotBonusThreshold[12] = parser.ReadOffset <byte>(0x32);
            WeeklyLotBonusThreshold[13] = parser.ReadOffset <byte>(0x36);
            WeeklyLotBonusThreshold[14] = parser.ReadOffset <byte>(0x3a);
            WeeklyLotBonusThreshold[15] = parser.ReadOffset <byte>(0x3e);
            WeeklyLotBonusThreshold[16] = parser.ReadOffset <byte>(0x42);
            WeeklyLotBonusThreshold[17] = parser.ReadOffset <byte>(0x46);
            WeeklyLotBonusThreshold[18] = parser.ReadOffset <byte>(0x4a);
            WeeklyLotBonusThreshold[19] = parser.ReadOffset <byte>(0x4e);
            WeeklyLotBonusThreshold[20] = parser.ReadOffset <byte>(0x52);
            WeeklyLotBonusThreshold[21] = parser.ReadOffset <byte>(0x56);
            WeeklyLotBonusThreshold[22] = parser.ReadOffset <byte>(0x5a);
            WeeklyLotBonusThreshold[23] = parser.ReadOffset <byte>(0x5e);
            WeeklyLotBonusThreshold[24] = parser.ReadOffset <byte>(0x62);
            WeeklyLotBonusThreshold[25] = parser.ReadOffset <byte>(0x66);
            WeeklyLotBonusThreshold[26] = parser.ReadOffset <byte>(0x6a);
            WeeklyLotBonusThreshold[27] = parser.ReadOffset <byte>(0x6e);
            WeeklyLotBonusThreshold[28] = parser.ReadOffset <byte>(0x72);
            WeeklyLotBonusThreshold[29] = parser.ReadOffset <byte>(0x76);
            WeeklyLotBonusThreshold[30] = parser.ReadOffset <byte>(0x7a);

            // col: 64 offset: 0003
            unknown3 = parser.ReadOffset <byte>(0x3);

            // col: 33 offset: 0004
            unknown4 = parser.ReadOffset <ushort>(0x4);

            // col: 65 offset: 0007
            unknown7 = parser.ReadOffset <byte>(0x7);

            // col: 34 offset: 0008
            unknown8 = parser.ReadOffset <ushort>(0x8);

            // col: 66 offset: 000b
            unknownb = parser.ReadOffset <byte>(0xb);

            // col: 35 offset: 000c
            unknownc = parser.ReadOffset <ushort>(0xc);

            // col: 67 offset: 000f
            unknownf = parser.ReadOffset <byte>(0xf);

            // col: 36 offset: 0010
            unknown10 = parser.ReadOffset <ushort>(0x10);

            // col: 68 offset: 0013
            unknown13 = parser.ReadOffset <byte>(0x13);

            // col: 37 offset: 0014
            unknown14 = parser.ReadOffset <ushort>(0x14);

            // col: 69 offset: 0017
            unknown17 = parser.ReadOffset <byte>(0x17);

            // col: 38 offset: 0018
            unknown18 = parser.ReadOffset <ushort>(0x18);

            // col: 70 offset: 001b
            unknown1b = parser.ReadOffset <byte>(0x1b);

            // col: 39 offset: 001c
            unknown1c = parser.ReadOffset <ushort>(0x1c);

            // col: 71 offset: 001f
            unknown1f = parser.ReadOffset <byte>(0x1f);

            // col: 40 offset: 0020
            unknown20 = parser.ReadOffset <ushort>(0x20);

            // col: 72 offset: 0023
            unknown23 = parser.ReadOffset <byte>(0x23);

            // col: 41 offset: 0024
            unknown24 = parser.ReadOffset <ushort>(0x24);

            // col: 73 offset: 0027
            unknown27 = parser.ReadOffset <byte>(0x27);

            // col: 42 offset: 0028
            unknown28 = parser.ReadOffset <ushort>(0x28);

            // col: 74 offset: 002b
            unknown2b = parser.ReadOffset <byte>(0x2b);

            // col: 43 offset: 002c
            unknown2c = parser.ReadOffset <ushort>(0x2c);

            // col: 75 offset: 002f
            unknown2f = parser.ReadOffset <byte>(0x2f);

            // col: 44 offset: 0030
            unknown30 = parser.ReadOffset <ushort>(0x30);

            // col: 76 offset: 0033
            unknown33 = parser.ReadOffset <byte>(0x33);

            // col: 45 offset: 0034
            unknown34 = parser.ReadOffset <ushort>(0x34);

            // col: 77 offset: 0037
            unknown37 = parser.ReadOffset <byte>(0x37);

            // col: 46 offset: 0038
            unknown38 = parser.ReadOffset <ushort>(0x38);

            // col: 78 offset: 003b
            unknown3b = parser.ReadOffset <byte>(0x3b);

            // col: 47 offset: 003c
            unknown3c = parser.ReadOffset <ushort>(0x3c);

            // col: 79 offset: 003f
            unknown3f = parser.ReadOffset <byte>(0x3f);

            // col: 48 offset: 0040
            unknown40 = parser.ReadOffset <ushort>(0x40);

            // col: 80 offset: 0043
            unknown43 = parser.ReadOffset <byte>(0x43);

            // col: 49 offset: 0044
            unknown44 = parser.ReadOffset <ushort>(0x44);

            // col: 81 offset: 0047
            unknown47 = parser.ReadOffset <byte>(0x47);

            // col: 50 offset: 0048
            unknown48 = parser.ReadOffset <ushort>(0x48);

            // col: 82 offset: 004b
            unknown4b = parser.ReadOffset <byte>(0x4b);

            // col: 51 offset: 004c
            unknown4c = parser.ReadOffset <ushort>(0x4c);

            // col: 83 offset: 004f
            unknown4f = parser.ReadOffset <byte>(0x4f);

            // col: 52 offset: 0050
            unknown50 = parser.ReadOffset <ushort>(0x50);

            // col: 84 offset: 0053
            unknown53 = parser.ReadOffset <byte>(0x53);

            // col: 53 offset: 0054
            unknown54 = parser.ReadOffset <ushort>(0x54);

            // col: 85 offset: 0057
            unknown57 = parser.ReadOffset <byte>(0x57);

            // col: 54 offset: 0058
            unknown58 = parser.ReadOffset <ushort>(0x58);

            // col: 86 offset: 005b
            unknown5b = parser.ReadOffset <byte>(0x5b);

            // col: 55 offset: 005c
            unknown5c = parser.ReadOffset <ushort>(0x5c);

            // col: 87 offset: 005f
            unknown5f = parser.ReadOffset <byte>(0x5f);

            // col: 56 offset: 0060
            unknown60 = parser.ReadOffset <ushort>(0x60);

            // col: 88 offset: 0063
            unknown63 = parser.ReadOffset <byte>(0x63);

            // col: 57 offset: 0064
            unknown64 = parser.ReadOffset <ushort>(0x64);

            // col: 89 offset: 0067
            unknown67 = parser.ReadOffset <byte>(0x67);

            // col: 58 offset: 0068
            unknown68 = parser.ReadOffset <ushort>(0x68);

            // col: 90 offset: 006b
            unknown6b = parser.ReadOffset <byte>(0x6b);

            // col: 59 offset: 006c
            unknown6c = parser.ReadOffset <ushort>(0x6c);

            // col: 91 offset: 006f
            unknown6f = parser.ReadOffset <byte>(0x6f);

            // col: 60 offset: 0070
            unknown70 = parser.ReadOffset <ushort>(0x70);

            // col: 92 offset: 0073
            unknown73 = parser.ReadOffset <byte>(0x73);

            // col: 61 offset: 0074
            unknown74 = parser.ReadOffset <ushort>(0x74);

            // col: 93 offset: 0077
            unknown77 = parser.ReadOffset <byte>(0x77);

            // col: 62 offset: 0078
            unknown78 = parser.ReadOffset <ushort>(0x78);

            // col: 94 offset: 007b
            unknown7b = parser.ReadOffset <byte>(0x7b);

            // col: 63 offset: 007c
            unknown7c = parser.ReadOffset <ushort>(0x7c);

            // col: 31 offset: 007e
            unknown7e = parser.ReadOffset <byte>(0x7e);

            // col: 95 offset: 007f
            unknown7f = parser.ReadOffset <byte>(0x7f);
        }
Example #17
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 5 offset: 0000
            Name = parser.ReadOffset <string>(0x0);

            // col: 0 offset: 0004
            unknown4 = parser.ReadOffset <uint>(0x4);

            // col: 4 offset: 0008
            unknown8 = parser.ReadOffset <uint>(0x8);

            // col: 3 offset: 000c
            Icon = parser.ReadOffset <int>(0xc);

            // col: 6 offset: 0010
            Cutscene     = new int[24];
            Cutscene[0]  = parser.ReadOffset <int>(0x10);
            Cutscene[1]  = parser.ReadOffset <int>(0x14);
            Cutscene[2]  = parser.ReadOffset <int>(0x18);
            Cutscene[3]  = parser.ReadOffset <int>(0x1c);
            Cutscene[4]  = parser.ReadOffset <int>(0x20);
            Cutscene[5]  = parser.ReadOffset <int>(0x24);
            Cutscene[6]  = parser.ReadOffset <int>(0x28);
            Cutscene[7]  = parser.ReadOffset <int>(0x2c);
            Cutscene[8]  = parser.ReadOffset <int>(0x30);
            Cutscene[9]  = parser.ReadOffset <int>(0x34);
            Cutscene[10] = parser.ReadOffset <int>(0x38);
            Cutscene[11] = parser.ReadOffset <int>(0x3c);
            Cutscene[12] = parser.ReadOffset <int>(0x40);
            Cutscene[13] = parser.ReadOffset <int>(0x44);
            Cutscene[14] = parser.ReadOffset <int>(0x48);
            Cutscene[15] = parser.ReadOffset <int>(0x4c);
            Cutscene[16] = parser.ReadOffset <int>(0x50);
            Cutscene[17] = parser.ReadOffset <int>(0x54);
            Cutscene[18] = parser.ReadOffset <int>(0x58);
            Cutscene[19] = parser.ReadOffset <int>(0x5c);
            Cutscene[20] = parser.ReadOffset <int>(0x60);
            Cutscene[21] = parser.ReadOffset <int>(0x64);
            Cutscene[22] = parser.ReadOffset <int>(0x68);
            Cutscene[23] = parser.ReadOffset <int>(0x6c);

            // col: 1 offset: 0070
            RequiredLevel = parser.ReadOffset <ushort>(0x70);

            // col: 2 offset: 0072
            unknown72 = parser.ReadOffset <byte>(0x72);
        }
Example #18
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            unknown0 = parser.ReadOffset <string>(0x0);

            // col: 1 offset: 0004
            TileSize = parser.ReadOffset <float>(0x4);

            // col: 2 offset: 0008
            CellSize = parser.ReadOffset <float>(0x8);

            // col: 3 offset: 000c
            CellHeight = parser.ReadOffset <float>(0xc);

            // col: 4 offset: 0010
            AgentHeight = parser.ReadOffset <float>(0x10);

            // col: 5 offset: 0014
            AgentRadius = parser.ReadOffset <float>(0x14);

            // col: 6 offset: 0018
            AgentMaxClimb = parser.ReadOffset <float>(0x18);

            // col: 7 offset: 001c
            AgentMaxSlope = parser.ReadOffset <float>(0x1c);

            // col: 9 offset: 0020
            RegionMinSize = parser.ReadOffset <float>(0x20);

            // col: 10 offset: 0024
            RegionMergedSize = parser.ReadOffset <float>(0x24);

            // col: 12 offset: 0028
            MaxEdgeLength = parser.ReadOffset <float>(0x28);

            // col: 13 offset: 002c
            MaxEdgeError = parser.ReadOffset <float>(0x2c);

            // col: 14 offset: 0030
            VertsPerPoly = parser.ReadOffset <float>(0x30);

            // col: 15 offset: 0034
            DetailMeshSampleDistance = parser.ReadOffset <float>(0x34);

            // col: 16 offset: 0038
            DetailMeshMaxSampleError = parser.ReadOffset <float>(0x38);

            // col: 17 offset: 003c
            unknown3c = parser.ReadOffset <float>(0x3c);

            // col: 18 offset: 0040
            unknown40 = parser.ReadOffset <float>(0x40);

            // col: 19 offset: 0044
            unknown44 = parser.ReadOffset <float>(0x44);

            // col: 20 offset: 0048
            unknown48 = parser.ReadOffset <float>(0x48);

            // col: 21 offset: 004c
            unknown4c = parser.ReadOffset <float>(0x4c);

            // col: 22 offset: 0050
            unknown50 = parser.ReadOffset <float>(0x50);

            // col: 23 offset: 0054
            unknown54 = parser.ReadOffset <float>(0x54);

            // col: 24 offset: 0058
            unknown58 = parser.ReadOffset <float>(0x58);

            // col: 25 offset: 005c
            unknown5c = parser.ReadOffset <float>(0x5c);

            // col: 26 offset: 0060
            unknown60 = parser.ReadOffset <float>(0x60);

            // col: 27 offset: 0064
            unknown64 = parser.ReadOffset <float>(0x64);

            // col: 28 offset: 0068
            unknown68 = parser.ReadOffset <float>(0x68);

            // col: 29 offset: 006c
            unknown6c = parser.ReadOffset <float>(0x6c);

            // col: 31 offset: 0070
            unknown70 = parser.ReadOffset <float>(0x70);

            // col: 32 offset: 0074
            unknown74 = parser.ReadOffset <float>(0x74);

            // col: 33 offset: 0078
            unknown78 = parser.ReadOffset <float>(0x78);

            // col: 8 offset: 007c
            packed7c = parser.ReadOffset <byte>(0x7c, ExcelColumnDataType.UInt8);
        }
Example #19
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Name = parser.ReadOffset <string>(0x0);

            // col: 4 offset: 0004
            unknown4    = new uint[10];
            unknown4[0] = parser.ReadOffset <uint>(0x4);
            unknown4[1] = parser.ReadOffset <uint>(0x8);
            unknown4[2] = parser.ReadOffset <uint>(0xc);
            unknown4[3] = parser.ReadOffset <uint>(0x10);
            unknown4[4] = parser.ReadOffset <uint>(0x14);
            unknown4[5] = parser.ReadOffset <uint>(0x18);
            unknown4[6] = parser.ReadOffset <uint>(0x1c);
            unknown4[7] = parser.ReadOffset <uint>(0x20);
            unknown4[8] = parser.ReadOffset <uint>(0x24);
            unknown4[9] = parser.ReadOffset <uint>(0x28);

            // col: 3 offset: 002c
            unknown2c = parser.ReadOffset <ushort>(0x2c);

            // col: 2 offset: 002e
            unknown2e = parser.ReadOffset <byte>(0x2e);

            // col: 1 offset: 002f
            packed2f = parser.ReadOffset <byte>(0x2f, ExcelColumnDataType.UInt8);
        }
Example #20
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 3 offset: 0000
            Quest     = new uint[32];
            Quest[0]  = parser.ReadOffset <uint>(0x0);
            Quest[1]  = parser.ReadOffset <uint>(0x8);
            Quest[2]  = parser.ReadOffset <uint>(0x10);
            Quest[3]  = parser.ReadOffset <uint>(0x18);
            Quest[4]  = parser.ReadOffset <uint>(0x20);
            Quest[5]  = parser.ReadOffset <uint>(0x28);
            Quest[6]  = parser.ReadOffset <uint>(0x30);
            Quest[7]  = parser.ReadOffset <uint>(0x38);
            Quest[8]  = parser.ReadOffset <uint>(0x40);
            Quest[9]  = parser.ReadOffset <uint>(0x48);
            Quest[10] = parser.ReadOffset <uint>(0x50);
            Quest[11] = parser.ReadOffset <uint>(0x58);
            Quest[12] = parser.ReadOffset <uint>(0x60);
            Quest[13] = parser.ReadOffset <uint>(0x68);
            Quest[14] = parser.ReadOffset <uint>(0x70);
            Quest[15] = parser.ReadOffset <uint>(0x78);
            Quest[16] = parser.ReadOffset <uint>(0x80);
            Quest[17] = parser.ReadOffset <uint>(0x88);
            Quest[18] = parser.ReadOffset <uint>(0x90);
            Quest[19] = parser.ReadOffset <uint>(0x98);
            Quest[20] = parser.ReadOffset <uint>(0xa0);
            Quest[21] = parser.ReadOffset <uint>(0xa8);
            Quest[22] = parser.ReadOffset <uint>(0xb0);
            Quest[23] = parser.ReadOffset <uint>(0xb8);
            Quest[24] = parser.ReadOffset <uint>(0xc0);
            Quest[25] = parser.ReadOffset <uint>(0xc8);
            Quest[26] = parser.ReadOffset <uint>(0xd0);
            Quest[27] = parser.ReadOffset <uint>(0xd8);
            Quest[28] = parser.ReadOffset <uint>(0xe0);
            Quest[29] = parser.ReadOffset <uint>(0xe8);
            Quest[30] = parser.ReadOffset <uint>(0xf0);
            Quest[31] = parser.ReadOffset <uint>(0xf8);

            // col: 35 offset: 0004
            unknown4 = parser.ReadOffset <byte>(0x4);

            // col: 36 offset: 000c
            unknownc = parser.ReadOffset <byte>(0xc);

            // col: 37 offset: 0014
            unknown14 = parser.ReadOffset <byte>(0x14);

            // col: 38 offset: 001c
            unknown1c = parser.ReadOffset <byte>(0x1c);

            // col: 39 offset: 0024
            unknown24 = parser.ReadOffset <byte>(0x24);

            // col: 40 offset: 002c
            unknown2c = parser.ReadOffset <byte>(0x2c);

            // col: 41 offset: 0034
            unknown34 = parser.ReadOffset <byte>(0x34);

            // col: 42 offset: 003c
            unknown3c = parser.ReadOffset <byte>(0x3c);

            // col: 43 offset: 0044
            unknown44 = parser.ReadOffset <byte>(0x44);

            // col: 44 offset: 004c
            unknown4c = parser.ReadOffset <byte>(0x4c);

            // col: 45 offset: 0054
            unknown54 = parser.ReadOffset <byte>(0x54);

            // col: 46 offset: 005c
            unknown5c = parser.ReadOffset <byte>(0x5c);

            // col: 47 offset: 0064
            unknown64 = parser.ReadOffset <byte>(0x64);

            // col: 48 offset: 006c
            unknown6c = parser.ReadOffset <byte>(0x6c);

            // col: 49 offset: 0074
            unknown74 = parser.ReadOffset <byte>(0x74);

            // col: 50 offset: 007c
            unknown7c = parser.ReadOffset <byte>(0x7c);

            // col: 51 offset: 0084
            unknown84 = parser.ReadOffset <byte>(0x84);

            // col: 52 offset: 008c
            unknown8c = parser.ReadOffset <byte>(0x8c);

            // col: 53 offset: 0094
            unknown94 = parser.ReadOffset <byte>(0x94);

            // col: 54 offset: 009c
            unknown9c = parser.ReadOffset <byte>(0x9c);

            // col: 55 offset: 00a4
            unknowna4 = parser.ReadOffset <byte>(0xa4);

            // col: 56 offset: 00ac
            unknownac = parser.ReadOffset <byte>(0xac);

            // col: 57 offset: 00b4
            unknownb4 = parser.ReadOffset <byte>(0xb4);

            // col: 58 offset: 00bc
            unknownbc = parser.ReadOffset <byte>(0xbc);

            // col: 59 offset: 00c4
            unknownc4 = parser.ReadOffset <byte>(0xc4);

            // col: 60 offset: 00cc
            unknowncc = parser.ReadOffset <byte>(0xcc);

            // col: 61 offset: 00d4
            unknownd4 = parser.ReadOffset <byte>(0xd4);

            // col: 62 offset: 00dc
            unknowndc = parser.ReadOffset <byte>(0xdc);

            // col: 63 offset: 00e4
            unknowne4 = parser.ReadOffset <byte>(0xe4);

            // col: 64 offset: 00ec
            unknownec = parser.ReadOffset <byte>(0xec);

            // col: 65 offset: 00f4
            unknownf4 = parser.ReadOffset <byte>(0xf4);

            // col: 66 offset: 00fc
            unknownfc = parser.ReadOffset <byte>(0xfc);

            // col: 0 offset: 0100
            FinalQuest = parser.ReadOffset <uint>(0x100);

            // col: 2 offset: 0104
            Chapter = parser.ReadOffset <ushort>(0x104);

            // col: 1 offset: 0106
            unknown106 = parser.ReadOffset <byte>(0x106);
        }
Example #21
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 5 offset: 0000
            unknown0 = parser.ReadOffset <uint>(0x0);

            // col: 6 offset: 0004
            unknown4 = parser.ReadOffset <uint>(0x4);

            // col: 7 offset: 0008
            unknown8 = parser.ReadOffset <uint>(0x8);

            // col: 8 offset: 000c
            unknownc = parser.ReadOffset <uint>(0xc);

            // col: 9 offset: 0010
            unknown10 = parser.ReadOffset <uint>(0x10);

            // col: 10 offset: 0014
            unknown14 = parser.ReadOffset <uint>(0x14);

            // col: 11 offset: 0018
            unknown18 = parser.ReadOffset <uint>(0x18);

            // col: 12 offset: 001c
            unknown1c = parser.ReadOffset <uint>(0x1c);

            // col: 13 offset: 0020
            unknown20 = parser.ReadOffset <uint>(0x20);

            // col: 14 offset: 0024
            unknown24 = parser.ReadOffset <uint>(0x24);

            // col: 15 offset: 0028
            unknown28 = parser.ReadOffset <uint>(0x28);

            // col: 16 offset: 002c
            unknown2c = parser.ReadOffset <uint>(0x2c);

            // col: 17 offset: 0030
            unknown30 = parser.ReadOffset <uint>(0x30);

            // col: 18 offset: 0034
            unknown34 = parser.ReadOffset <uint>(0x34);

            // col: 19 offset: 0038
            unknown38 = parser.ReadOffset <uint>(0x38);

            // col: 20 offset: 003c
            unknown3c = parser.ReadOffset <uint>(0x3c);

            // col: 21 offset: 0040
            unknown40 = parser.ReadOffset <uint>(0x40);

            // col: 22 offset: 0044
            unknown44 = parser.ReadOffset <uint>(0x44);

            // col: 23 offset: 0048
            unknown48 = parser.ReadOffset <uint>(0x48);

            // col: 24 offset: 004c
            unknown4c = parser.ReadOffset <uint>(0x4c);

            // col: 25 offset: 0050
            unknown50 = parser.ReadOffset <uint>(0x50);

            // col: 26 offset: 0054
            unknown54 = parser.ReadOffset <uint>(0x54);

            // col: 27 offset: 0058
            unknown58 = parser.ReadOffset <uint>(0x58);

            // col: 28 offset: 005c
            unknown5c = parser.ReadOffset <uint>(0x5c);

            // col: 29 offset: 0060
            unknown60 = parser.ReadOffset <uint>(0x60);

            // col: 30 offset: 0064
            unknown64 = parser.ReadOffset <uint>(0x64);

            // col: 31 offset: 0068
            unknown68 = parser.ReadOffset <uint>(0x68);

            // col: 3 offset: 006c
            TextDataStart = parser.ReadOffset <uint>(0x6c);

            // col: 4 offset: 0070
            TextDataEnd = parser.ReadOffset <uint>(0x70);

            // col: 34 offset: 0074
            Image = parser.ReadOffset <uint>(0x74);

            // col: 1 offset: 0078
            TimeLimit = parser.ReadOffset <ushort>(0x78);

            // col: 32 offset: 007a
            unknown7a = parser.ReadOffset <ushort>(0x7a);

            // col: 33 offset: 007c
            ContentFinderCondition = parser.ReadOffset <ushort>(0x7c);

            // col: 0 offset: 007e
            Key = parser.ReadOffset <byte>(0x7e);

            // col: 35 offset: 007f
            unknown7f = parser.ReadOffset <byte>(0x7f);

            // col: 2 offset: 0080
            packed80 = parser.ReadOffset <byte>(0x80, ExcelColumnDataType.UInt8);
        }
Example #22
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Icon     = new uint[19];
            Icon[0]  = parser.ReadOffset <uint>(0x0);
            Icon[1]  = parser.ReadOffset <uint>(0x4);
            Icon[2]  = parser.ReadOffset <uint>(0x8);
            Icon[3]  = parser.ReadOffset <uint>(0xc);
            Icon[4]  = parser.ReadOffset <uint>(0x10);
            Icon[5]  = parser.ReadOffset <uint>(0x14);
            Icon[6]  = parser.ReadOffset <uint>(0x18);
            Icon[7]  = parser.ReadOffset <uint>(0x1c);
            Icon[8]  = parser.ReadOffset <uint>(0x20);
            Icon[9]  = parser.ReadOffset <uint>(0x24);
            Icon[10] = parser.ReadOffset <uint>(0x28);
            Icon[11] = parser.ReadOffset <uint>(0x2c);
            Icon[12] = parser.ReadOffset <uint>(0x30);
            Icon[13] = parser.ReadOffset <uint>(0x34);
            Icon[14] = parser.ReadOffset <uint>(0x38);
            Icon[15] = parser.ReadOffset <uint>(0x3c);
            Icon[16] = parser.ReadOffset <uint>(0x40);
            Icon[17] = parser.ReadOffset <uint>(0x44);
            Icon[18] = parser.ReadOffset <uint>(0x48);
        }
Example #23
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Name = parser.ReadOffset <string>(0x0);

            // col: 1 offset: 0004
            NameShort = parser.ReadOffset <string>(0x4);

            // col: 13 offset: 0008
            ExpReward = parser.ReadOffset <uint>(0x8);

            // col: 6 offset: 000c
            RequiredFuel = parser.ReadOffset <ushort>(0xc);

            // col: 7 offset: 000e
            Durationmin = parser.ReadOffset <ushort>(0xe);

            // col: 8 offset: 0010
            unknown10 = parser.ReadOffset <ushort>(0x10);

            // col: 3 offset: 0012
            unknown12 = parser.ReadOffset <short>(0x12);

            // col: 4 offset: 0014
            unknown14 = parser.ReadOffset <short>(0x14);

            // col: 5 offset: 0016
            RequiredLevel = parser.ReadOffset <byte>(0x16);

            // col: 9 offset: 0017
            unknown17 = parser.ReadOffset <byte>(0x17);

            // col: 11 offset: 0018
            unknown18 = parser.ReadOffset <byte>(0x18);

            // col: 10 offset: 0019
            RequiredSurveillance = parser.ReadOffset <byte>(0x19);

            // col: 12 offset: 001a
            unknown1a = parser.ReadOffset <byte>(0x1a);

            // col: 2 offset: 001b
            packed1b = parser.ReadOffset <byte>(0x1b, ExcelColumnDataType.UInt8);
        }
Example #24
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 1 offset: 0000
            Objective = parser.ReadOffset <string>(0x0);

            // col: 2 offset: 0004
            Description1 = parser.ReadOffset <string>(0x4);

            // col: 3 offset: 0008
            Description2 = parser.ReadOffset <string>(0x8);

            // col: 4 offset: 000c
            Description3 = parser.ReadOffset <string>(0xc);

            // col: 5 offset: 0010
            CompletionBonusExp = parser.ReadOffset <uint>(0x10);

            // col: 6 offset: 0014
            RewardExp = parser.ReadOffset <uint>(0x14);

            // col: 7 offset: 0018
            CompletionBonusGil = parser.ReadOffset <uint>(0x18);

            // col: 8 offset: 001c
            RewardGil = parser.ReadOffset <uint>(0x1c);

            // col: 9 offset: 0020
            unknown20 = parser.ReadOffset <uint>(0x20);

            // col: 10 offset: 0024
            unknown24 = parser.ReadOffset <uint>(0x24);

            // col: 11 offset: 0028
            unknown28 = parser.ReadOffset <uint>(0x28);

            // col: 12 offset: 002c
            unknown2c = parser.ReadOffset <uint>(0x2c);

            // col: 13 offset: 0030
            unknown30 = parser.ReadOffset <ushort>(0x30);

            // col: 14 offset: 0032
            unknown32 = parser.ReadOffset <ushort>(0x32);

            // col: 15 offset: 0034
            unknown34 = parser.ReadOffset <bool>(0x34);

            // col: 16 offset: 0035
            unknown35 = parser.ReadOffset <bool>(0x35);

            // col: 0 offset: 0038
            ENpcName = parser.ReadOffset <uint>(0x38);
        }
Example #25
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 7 offset: 0000
            Description = parser.ReadOffset <string>(0x0);

            // col: 8 offset: 0004
            Alias = parser.ReadOffset <string>(0x4);

            // col: 9 offset: 0008
            ShortAlias = parser.ReadOffset <string>(0x8);

            // col: 5 offset: 000c
            Command = parser.ReadOffset <string>(0xc);

            // col: 6 offset: 0010
            ShortCommand = parser.ReadOffset <string>(0x10);

            // col: 11 offset: 0014
            unknown14 = parser.ReadOffset <uint>(0x14);

            // col: 10 offset: 0018
            unknown18 = parser.ReadOffset <ushort>(0x18);

            // col: 0 offset: 001a
            unknown1a = parser.ReadOffset <byte>(0x1a);

            // col: 1 offset: 001b
            unknown1b = parser.ReadOffset <byte>(0x1b);

            // col: 2 offset: 001c
            unknown1c = parser.ReadOffset <sbyte>(0x1c);

            // col: 3 offset: 001d
            unknown1d = parser.ReadOffset <sbyte>(0x1d);

            // col: 4 offset: 001e
            unknown1e = parser.ReadOffset <sbyte>(0x1e);
        }
Example #26
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 7 offset: 0000
            unknown0 = parser.ReadOffset <uint>(0x0);

            // col: 39 offset: 0008
            packed8 = parser.ReadOffset <byte>(0x8, ExcelColumnDataType.UInt8);

            // col: 8 offset: 000c
            unknownc = parser.ReadOffset <uint>(0xc);

            // col: 40 offset: 0014
            packed14 = parser.ReadOffset <byte>(0x14, ExcelColumnDataType.UInt8);

            // col: 9 offset: 0018
            unknown18 = parser.ReadOffset <uint>(0x18);

            // col: 41 offset: 0020
            packed20 = parser.ReadOffset <byte>(0x20, ExcelColumnDataType.UInt8);

            // col: 10 offset: 0024
            unknown24 = parser.ReadOffset <uint>(0x24);

            // col: 42 offset: 002c
            packed2c = parser.ReadOffset <byte>(0x2c, ExcelColumnDataType.UInt8);

            // col: 11 offset: 0030
            unknown30 = parser.ReadOffset <uint>(0x30);

            // col: 43 offset: 0038
            packed38 = parser.ReadOffset <byte>(0x38, ExcelColumnDataType.UInt8);

            // col: 12 offset: 003c
            unknown3c = parser.ReadOffset <uint>(0x3c);

            // col: 44 offset: 0044
            packed44 = parser.ReadOffset <byte>(0x44, ExcelColumnDataType.UInt8);

            // col: 13 offset: 0048
            unknown48 = parser.ReadOffset <uint>(0x48);

            // col: 45 offset: 0050
            packed50 = parser.ReadOffset <byte>(0x50, ExcelColumnDataType.UInt8);

            // col: 14 offset: 0054
            unknown54 = parser.ReadOffset <uint>(0x54);

            // col: 46 offset: 005c
            packed5c = parser.ReadOffset <byte>(0x5c, ExcelColumnDataType.UInt8);

            // col: 15 offset: 0060
            unknown60 = parser.ReadOffset <uint>(0x60);

            // col: 47 offset: 0068
            packed68 = parser.ReadOffset <byte>(0x68, ExcelColumnDataType.UInt8);

            // col: 16 offset: 006c
            unknown6c = parser.ReadOffset <uint>(0x6c);

            // col: 48 offset: 0074
            packed74 = parser.ReadOffset <byte>(0x74, ExcelColumnDataType.UInt8);

            // col: 17 offset: 0078
            unknown78 = parser.ReadOffset <uint>(0x78);

            // col: 49 offset: 0080
            packed80 = parser.ReadOffset <byte>(0x80, ExcelColumnDataType.UInt8);

            // col: 18 offset: 0084
            unknown84 = parser.ReadOffset <uint>(0x84);

            // col: 50 offset: 008c
            packed8c = parser.ReadOffset <byte>(0x8c, ExcelColumnDataType.UInt8);

            // col: 19 offset: 0090
            unknown90 = parser.ReadOffset <uint>(0x90);

            // col: 51 offset: 0098
            packed98 = parser.ReadOffset <byte>(0x98, ExcelColumnDataType.UInt8);

            // col: 20 offset: 009c
            unknown9c = parser.ReadOffset <uint>(0x9c);

            // col: 52 offset: 00a4
            packeda4 = parser.ReadOffset <byte>(0xa4, ExcelColumnDataType.UInt8);

            // col: 21 offset: 00a8
            unknowna8 = parser.ReadOffset <uint>(0xa8);

            // col: 53 offset: 00b0
            packedb0 = parser.ReadOffset <byte>(0xb0, ExcelColumnDataType.UInt8);

            // col: 22 offset: 00b4
            Icon     = new uint[16];
            Icon[0]  = parser.ReadOffset <uint>(0xb4);
            Icon[1]  = parser.ReadOffset <uint>(0x4);
            Icon[2]  = parser.ReadOffset <uint>(0x10);
            Icon[3]  = parser.ReadOffset <uint>(0x1c);
            Icon[4]  = parser.ReadOffset <uint>(0x28);
            Icon[5]  = parser.ReadOffset <uint>(0x34);
            Icon[6]  = parser.ReadOffset <uint>(0x40);
            Icon[7]  = parser.ReadOffset <uint>(0x4c);
            Icon[8]  = parser.ReadOffset <uint>(0x58);
            Icon[9]  = parser.ReadOffset <uint>(0x64);
            Icon[10] = parser.ReadOffset <uint>(0x70);
            Icon[11] = parser.ReadOffset <uint>(0x7c);
            Icon[12] = parser.ReadOffset <uint>(0x88);
            Icon[13] = parser.ReadOffset <uint>(0x94);
            Icon[14] = parser.ReadOffset <uint>(0xa0);
            Icon[15] = parser.ReadOffset <uint>(0xac);

            // col: 38 offset: 00b8
            unknownb8 = parser.ReadOffset <uint>(0xb8);

            // col: 54 offset: 00bc
            packedbc = parser.ReadOffset <byte>(0xbc, ExcelColumnDataType.UInt8);

            // col: 2 offset: 00c0
            unknownc0 = parser.ReadOffset <uint>(0xc0);

            // col: 6 offset: 00c4
            unknownc4 = parser.ReadOffset <uint>(0xc4);

            // col: 3 offset: 00c8
            unknownc8 = parser.ReadOffset <ushort>(0xc8);

            // col: 4 offset: 00ca
            unknownca = parser.ReadOffset <ushort>(0xca);

            // col: 5 offset: 00cc
            unknowncc = parser.ReadOffset <ushort>(0xcc);

            // col: 0 offset: 00ce
            unknownce = parser.ReadOffset <byte>(0xce);

            // col: 1 offset: 00cf
            unknowncf = parser.ReadOffset <byte>(0xcf);
        }
Example #27
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 9 offset: 0000
            EmptyIcon    = new uint[3];
            EmptyIcon[0] = parser.ReadOffset <uint>(0x0);
            EmptyIcon[1] = parser.ReadOffset <uint>(0x14);
            EmptyIcon[2] = parser.ReadOffset <uint>(0x28);

            // col: 12 offset: 0004
            MaelstromIcon    = new uint[3];
            MaelstromIcon[0] = parser.ReadOffset <uint>(0x4);
            MaelstromIcon[1] = parser.ReadOffset <uint>(0x18);
            MaelstromIcon[2] = parser.ReadOffset <uint>(0x2c);

            // col: 15 offset: 0008
            TwinAdderIcon    = new uint[3];
            TwinAdderIcon[0] = parser.ReadOffset <uint>(0x8);
            TwinAdderIcon[1] = parser.ReadOffset <uint>(0x1c);
            TwinAdderIcon[2] = parser.ReadOffset <uint>(0x30);

            // col: 18 offset: 000c
            ImmortalFlamesIcon    = new uint[3];
            ImmortalFlamesIcon[0] = parser.ReadOffset <uint>(0xc);
            ImmortalFlamesIcon[1] = parser.ReadOffset <uint>(0x20);
            ImmortalFlamesIcon[2] = parser.ReadOffset <uint>(0x34);

            // col: 0 offset: 0010
            unknown10 = parser.ReadOffset <byte>(0x10);

            // col: 3 offset: 0011
            unknown11 = parser.ReadOffset <byte>(0x11);

            // col: 6 offset: 0012
            unknown12 = parser.ReadOffset <byte>(0x12);

            // col: 1 offset: 0024
            unknown24 = parser.ReadOffset <byte>(0x24);

            // col: 4 offset: 0025
            unknown25 = parser.ReadOffset <byte>(0x25);

            // col: 7 offset: 0026
            unknown26 = parser.ReadOffset <byte>(0x26);

            // col: 2 offset: 0038
            unknown38 = parser.ReadOffset <byte>(0x38);

            // col: 5 offset: 0039
            unknown39 = parser.ReadOffset <byte>(0x39);

            // col: 8 offset: 003a
            unknown3a = parser.ReadOffset <byte>(0x3a);
        }
Example #28
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Radius = parser.ReadOffset <float>(0x0);

            // col: 1 offset: 0004
            Height = parser.ReadOffset <float>(0x4);

            // col: 2 offset: 0008
            VFXScale = parser.ReadOffset <float>(0x8);

            // col: 11 offset: 000c
            FloatHeight = parser.ReadOffset <float>(0xc);

            // col: 12 offset: 0010
            FloatDown = parser.ReadOffset <float>(0x10);

            // col: 3 offset: 0014
            unknown14 = parser.ReadOffset <ushort>(0x14);

            // col: 4 offset: 0016
            unknown16 = parser.ReadOffset <ushort>(0x16);

            // col: 5 offset: 0018
            unknown18 = parser.ReadOffset <ushort>(0x18);

            // col: 6 offset: 001a
            unknown1a = parser.ReadOffset <ushort>(0x1a);

            // col: 7 offset: 001c
            unknown1c = parser.ReadOffset <ushort>(0x1c);

            // col: 8 offset: 001e
            unknown1e = parser.ReadOffset <ushort>(0x1e);

            // col: 9 offset: 0020
            unknown20 = parser.ReadOffset <ushort>(0x20);

            // col: 10 offset: 0022
            unknown22 = parser.ReadOffset <ushort>(0x22);

            // col: 13 offset: 0024
            FloatUp = parser.ReadOffset <ushort>(0x24);

            // col: 14 offset: 0026
            unknown26 = parser.ReadOffset <byte>(0x26);

            // col: 16 offset: 0027
            LoopFlySE = parser.ReadOffset <byte>(0x27);

            // col: 15 offset: 0028
            packed28 = parser.ReadOffset <byte>(0x28, ExcelColumnDataType.UInt8);
        }
Example #29
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Name = parser.ReadOffset <string>(0x0);

            // col: 1 offset: 0004
            Bg = parser.ReadOffset <string>(0x4);

            // col: 22 offset: 0008
            ArrayEventHandler = parser.ReadOffset <uint>(0x8);

            // col: 20 offset: 000c
            PlaceNameRegionIcon = parser.ReadOffset <int>(0xc);

            // col: 21 offset: 0010
            PlaceNameIcon = parser.ReadOffset <int>(0x10);

            // col: 24 offset: 0014
            Aetheryte = parser.ReadOffset <int>(0x14);

            // col: 25 offset: 0018
            FixedTime = parser.ReadOffset <int>(0x18);

            // col: 3 offset: 001c
            PlaceNameRegion = parser.ReadOffset <ushort>(0x1c);

            // col: 4 offset: 001e
            PlaceNameZone = parser.ReadOffset <ushort>(0x1e);

            // col: 5 offset: 0020
            PlaceName = parser.ReadOffset <ushort>(0x20);

            // col: 6 offset: 0022
            Map = parser.ReadOffset <ushort>(0x22);

            // col: 10 offset: 0024
            unknown24 = parser.ReadOffset <ushort>(0x24);

            // col: 19 offset: 0026
            BGM = parser.ReadOffset <ushort>(0x26);

            // col: 23 offset: 0028
            QuestBattle = parser.ReadOffset <ushort>(0x28);

            // col: 26 offset: 002a
            Resident = parser.ReadOffset <ushort>(0x2a);

            // col: 2 offset: 002c
            BattalionMode = parser.ReadOffset <byte>(0x2c);

            // col: 7 offset: 002d
            LoadingImage = parser.ReadOffset <byte>(0x2d);

            // col: 8 offset: 002e
            ExclusiveType = parser.ReadOffset <byte>(0x2e);

            // col: 9 offset: 002f
            TerritoryIntendedUse = parser.ReadOffset <byte>(0x2f);

            // col: 12 offset: 0030
            WeatherRate = parser.ReadOffset <byte>(0x30);

            // col: 14 offset: 0031
            unknown31 = parser.ReadOffset <byte>(0x31);

            // col: 29 offset: 0032
            unknown32 = parser.ReadOffset <byte>(0x32);

            // col: 30 offset: 0033
            unknown33 = parser.ReadOffset <byte>(0x33);

            // col: 31 offset: 0034
            unknown34 = parser.ReadOffset <byte>(0x34);

            // col: 32 offset: 0035
            unknown35 = parser.ReadOffset <byte>(0x35);

            // col: 35 offset: 0036
            unknown36 = parser.ReadOffset <byte>(0x36);

            // col: 27 offset: 0037
            AchievementIndex = parser.ReadOffset <sbyte>(0x37);

            // col: 11 offset: 0038
            packed38 = parser.ReadOffset <byte>(0x38, ExcelColumnDataType.UInt8);

            // col: 34 offset: 0039
            packed39 = parser.ReadOffset <byte>(0x39, ExcelColumnDataType.UInt8);
        }
Example #30
0
        public void PopulateData(RowParser parser, Lumina lumina)
        {
            RowId    = parser.Row;
            SubRowId = parser.SubRow;

            // col: 0 offset: 0000
            Item     = new uint[14];
            Item[0]  = parser.ReadOffset <uint>(0x0);
            Item[1]  = parser.ReadOffset <uint>(0x4);
            Item[2]  = parser.ReadOffset <uint>(0x8);
            Item[3]  = parser.ReadOffset <uint>(0xc);
            Item[4]  = parser.ReadOffset <uint>(0x10);
            Item[5]  = parser.ReadOffset <uint>(0x14);
            Item[6]  = parser.ReadOffset <uint>(0x18);
            Item[7]  = parser.ReadOffset <uint>(0x1c);
            Item[8]  = parser.ReadOffset <uint>(0x20);
            Item[9]  = parser.ReadOffset <uint>(0x24);
            Item[10] = parser.ReadOffset <uint>(0x28);
            Item[11] = parser.ReadOffset <uint>(0x2c);
            Item[12] = parser.ReadOffset <uint>(0x30);
            Item[13] = parser.ReadOffset <uint>(0x34);
        }