示例#1
0
        private void LoadItems(StatsDat sDat, TagsDat tagsDat)
        {
            foreach (var address in RecordAddresses())
            {
                var r = new ModRecord(M, sDat, tagsDat, address);

                if (records.ContainsKey(r.Key))
                {
                    continue;
                }

                DictionaryRecords.Add(address, r);
                records.Add(r.Key, r);

                if (r.Domain == ModDomain.Monster)
                {
                    continue;
                }

                var byTierKey = Tuple.Create(r.Group, r.AffixType);

                if (!recordsByTier.TryGetValue(byTierKey, out var groupMembers))
                {
                    groupMembers             = new List <ModRecord>();
                    recordsByTier[byTierKey] = groupMembers;
                }

                groupMembers.Add(r);
            }

            foreach (var list in recordsByTier.Values)
            {
                list.Sort(ModRecord.ByLevelComparer);
            }
        }
示例#2
0
            public ModRecord(IMemory m, StatsDat sDat, TagsDat tagsDat, long address)
            {
                Address = address;
                var modRecord = m.Read <ModsRecordOffsets>(address);

                Key = ReadCache($"{modRecord.Key.buf}", () => modRecord.Key.ToString(m));

                Unknown8 = modRecord.Unknown8;
                MinLevel = modRecord.MinLevel;

                var read = m.Read <long>(modRecord.TypeName);

                TypeName = ReadCache($"{read}", () => m.ReadStringU(read, 255));

                var statAddresses = new long[NumberOfStats]
                {
                    modRecord.StatNames1,
                    modRecord.StatNames2,
                    modRecord.StatNames3,
                    modRecord.StatName4
                };

                StatNames = new StatsDat.StatRecord[NumberOfStats];

                for (var i = 0; i < NumberOfStats; ++i)
                {
                    if (statAddresses[i] == 0)
                    {
                        StatNames[i] = null;
                        continue;
                    }

                    var statId = m.Read <long>(statAddresses[i]);

                    if (statId == 0)
                    {
                        StatNames[i] = null;
                        continue;
                    }

                    var key = RemoteMemoryObject.Cache.StringCache.Read($"{nameof(StatsDat)}{statAddresses[i]}",
                                                                        () => m.ReadStringU(statId, 512));

                    if (!sDat.records.TryGetValue(key, out StatNames[i]))
                    {
                        DebugWindow.LogError($"ModsDat => Stat '{key}' not found. (@{statId})");
                    }
                }

                Domain           = (ModDomain)modRecord.Domain;
                UserFriendlyName = ReadCache($"{modRecord.UserFriendlyName}",
                                             () => m.ReadStringU(modRecord.UserFriendlyName));
                AffixType = (ModType)modRecord.AffixType;
                Group     = ReadCache($"{modRecord.Group}", () => m.ReadStringU(modRecord.Group));

                StatRange = new[]
                {
                    new IntRange(modRecord.StatRange1, modRecord.StatRange2),
                    new IntRange(modRecord.StatRange3, modRecord.StatRange4),
                    new IntRange(modRecord.StatRange5, modRecord.StatRange6),
                    new IntRange(modRecord.StatRange7, modRecord.StatRange8)
                };

                Tags = new TagsDat.TagRecord[modRecord.Tags];
                var ta = modRecord.ta;

                for (var i = 0; i < Tags.Length; i++)
                {
                    var ii = ta + 0x10 * i;
                    var l  = m.Read <long>(ii, 0);

                    Tags[i] = tagsDat.Records[ReadCache($"{l}", () => m.ReadStringU(l, 255))];
                }

                TagChances = new Dictionary <string, int>(modRecord.TagChances);
                var tc = modRecord.tc;

                for (var i = 0; i < Tags.Length; i++)
                {
                    TagChances[Tags[i].Key] = m.Read <int>(tc + 4 * i);
                }

                IsEssence = modRecord.IsEssence == 0x01;
                Tier      = ReadCache($"{modRecord.Tier}", () => m.ReadStringU(modRecord.Tier));
            }
示例#3
0
 public ModsDat(IMemory m, Func <long> address, StatsDat sDat, TagsDat tagsDat) : base(m, address)
 {
     LoadItems(sDat, tagsDat);
 }
示例#4
0
            // more fields can be added (see in visualGGPK)

            public ModRecord(IMemory m, StatsDat sDat, TagsDat tagsDat, long addr)
            {
                Address = addr;
                var ModsRecord = m.Read <ModsRecordOffsets>(addr);

                Key = RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{ModsRecord.Key.buf}",
                                                                () => ModsRecord
                                                                .Key.ToString(
                                                                    m)); // ModsRecord.Key.ToString(m);// m.ReadStringU(m.Read<long>(addr + 0));

                Unknown8 = ModsRecord.Unknown8;                          // m.Read<long>(addr + 0x8);
                MinLevel = ModsRecord.MinLevel;                          // m.Read<int>(addr + 0x1C);

                // TypeName = m.ReadStringU(m.Read<long>(ModsRecord.TypeName /*m.Read<long>(addr + 0x14*/, 0),255);
                var read = m.Read <long>(ModsRecord.TypeName);

                TypeName = RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{read}", () => m.ReadStringU(read, 255));

                var s1 = ModsRecord.StatNames1 == 0 ? 0 : m.Read <long>(ModsRecord.StatNames1);
                var s2 = ModsRecord.StatNames2 == 0 ? 0 : m.Read <long>(ModsRecord.StatNames2);
                var s3 = ModsRecord.StatNames3 == 0 ? 0 : m.Read <long>(ModsRecord.StatNames3);
                var s4 = ModsRecord.StatName4 == 0 ? 0 : m.Read <long>(ModsRecord.StatName4);

                StatNames = new[]
                {
                    ModsRecord.StatNames1 == 0
                        ? null
                        : sDat.records[RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{s1}", () => m.ReadStringU(s1))],
                    ModsRecord.StatNames2 == 0
                        ? null
                        : sDat.records[RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{s2}", () => m.ReadStringU(s2))],
                    ModsRecord.StatNames3 == 0
                        ? null
                        : sDat.records[RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{s3}", () => m.ReadStringU(s3))],
                    ModsRecord.StatName4 == 0
                        ? null
                        : sDat.records[RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{s4}", () => m.ReadStringU(s4))]
                };

                Domain = (ModDomain)ModsRecord.Domain;  //m.Read<int>(addr + 0x60);

                UserFriendlyName = RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{ModsRecord.UserFriendlyName}",
                                                                             () => m.ReadStringU(
                                                                                 ModsRecord
                                                                                 .UserFriendlyName)); //m.ReadStringU(ModsRecord.UserFriendlyName/*m.Read<long>(addr + 0x64)*/);

                AffixType = (ModType)ModsRecord.AffixType;                                            //m.Read<int>(addr + 0x6C);

                Group = RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{ModsRecord.Group}",
                                                                  () => m.ReadStringU(ModsRecord.Group /*m.Read<long>(addr + 0x70)*/));

                StatRange = new[]
                {
                    /*new IntRange(m.Read<int>(addr + 0x78), m.Read<int>(addr + 0x7C)),
                     * new IntRange(m.Read<int>(addr + 0x80), m.Read<int>(addr + 0x84)),
                     * new IntRange(m.Read<int>(addr + 0x88), m.Read<int>(addr + 0x8C)),
                     * new IntRange(m.Read<int>(addr + 0x90), m.Read<int>(addr + 0x94))*/
                    new IntRange(ModsRecord.StatRange1, ModsRecord.StatRange2), new IntRange(ModsRecord.StatRange3, ModsRecord.StatRange4),
                    new IntRange(ModsRecord.StatRange5, ModsRecord.StatRange6), new IntRange(ModsRecord.StatRange7, ModsRecord.StatRange8)
                };

                //Tags = new TagsDat.TagRecord[m.Read<long>(addr + 0x98)];
                Tags = new TagsDat.TagRecord[ModsRecord.Tags];
                var ta = ModsRecord.ta; // m.Read<long>(addr + 0xA0);

                for (var i = 0; i < Tags.Length; i++)
                {
                    var ii = ta + 0x8 + 0x10 * i;
                    var l  = m.Read <long>(ii, 0);

                    Tags[i] = tagsDat.Records[
                        RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{l}", () => m.ReadStringU(l, 255))];
                }

                //  TagChances = new Dictionary<string,int>(m.Read<int>(addr + 0xA8));
                TagChances = new Dictionary <string, int>(ModsRecord.TagChances);
                var tc = ModsRecord.tc; //m.Read<long>(addr + 0xB0);

                for (var i = 0; i < Tags.Length; i++)
                {
                    TagChances[Tags[i].Key] = m.Read <int>(tc + 4 * i);
                }

                IsEssence = ModsRecord.IsEssence == 0x01; // m.Read<byte>(addr + 0x1AC) == 0x01;

                // Tier = m.ReadStringU(m.Read<long>(addr + 0x1C5));
                Tier = RemoteMemoryObject.Cache.StringCache.Read($"{nameof(ModsDat)}{ModsRecord.Tier}",
                                                                 () => m.ReadStringU(ModsRecord.Tier)); // m.ReadStringU(ModsRecord.Tier);
            }