chore: update dump data

res/items.json

@@ -1,6 +1,5 @@
 {
   "Campers": [
-    "Father_Key_Card",
     "FireflyLantern",
     "Item_Camper_AlexsToolbox",
     "Item_Camper_AnniversaryToolbox",
@@ -25,7 +24,6 @@
     "Item_Camper_JerryCan_Spring2025",
     "Item_Camper_K29InfectionRemover",
     "Item_Camper_K32Emp",
-    "Item_Camper_K33Turret",
     "Item_Camper_K36MagicItem_Boots",
     "Item_Camper_K36MagicItem_Bracers",
     "Item_Camper_K36MagicItem_VecnaEye",
@@ -44,7 +42,6 @@
     "Item_Camper_MedKit03",
     "Item_Camper_MedKit04",
     "Item_Camper_Medkit05",
-    "Item_Camper_OnryoTape",
     "Item_Camper_RainbowMap",
     "Item_Camper_Toolbox",
     "Item_Camper_Toolbox_Anniversary2022",
@@ -52,56 +49,10 @@
     "Item_Camper_VoidBomb_Halloween2024",
     "Item_Camper_WornoutToolbox",
     "Item_FragileObject",
-    "Item_LamentConfiguration",
     "Item_Survivor_CalamariContaminationAntidote",
     "Item_Survivor_K41Mushroom",
     "Item_Survivor_MakeshiftFogVial",
     "Item_Survivor_PrototypeFogVial",
     "Item_Survivor_VigosFogVial"
-  ],
-  "Slashers": [
-    "Item_Blighted_Serum",
-    "Item_Slasher_Beartrap",
-    "Item_Slasher_Blinker",
-    "Item_Slasher_Chainsaw",
-    "Item_Slasher_CloakBell",
-    "Item_Slasher_DreamInducer",
-    "Item_Slasher_Frenzy",
-    "Item_Slasher_GasBomb",
-    "Item_Slasher_GhostPower",
-    "Item_Slasher_HarpoonRifle",
-    "Item_Slasher_Hatchet",
-    "Item_Slasher_K21Power",
-    "Item_Slasher_K22Power",
-    "Item_Slasher_K24Power",
-    "Item_Slasher_K25Power",
-    "Item_Slasher_K26Power",
-    "Item_Slasher_K27Power",
-    "Item_Slasher_K28Power",
-    "Item_Slasher_K29Power",
-    "Item_Slasher_K30Power",
-    "Item_Slasher_K31Power",
-    "Item_Slasher_K32Power",
-    "Item_Slasher_K33Power",
-    "Item_Slasher_K34Power",
-    "Item_Slasher_K35Power",
-    "Item_Slasher_K36Power",
-    "Item_Slasher_K37Power",
-    "Item_Slasher_K38Power",
-    "Item_Slasher_K39Power",
-    "Item_Slasher_K40Power",
-    "Item_Slasher_K41Power",
-    "Item_Slasher_K42Power",
-    "Item_Slasher_Kanobo",
-    "Item_Slasher_Killer07Item",
-    "Item_Slasher_LFChainsaw",
-    "Item_Slasher_PhantomTrap",
-    "Item_Slasher_PhaseWalker",
-    "Item_Slasher_PlaguePower",
-    "Item_Slasher_QatarKillerPower",
-    "Item_Slasher_ReverseBearTrap",
-    "Item_Slasher_Stalker",
-    "Item_Slasher_ThrowingKnives",
-    "Item_Slasher_TormentMode"
   ]
 }

res/offerings.json

@@ -32,6 +32,36 @@
     "TanagerWreath"
   ],
   "Campers": [
+    "BlackSaltStatuette",
+    "BogLaurelSachet",
+    "BoundEnvelope",
+    "ChalkPouch",
+    "CreamChalkPouch",
+    "CrispleafAmaranthSachet",
+    "EscapeCake",
+    "FragrantBogLaurel",
+    "FragrantCrispleafAmaranth",
+    "FragrantPrimroseBlossom",
+    "FragrantSweetWilliam",
+    "FreshBogLaurel",
+    "FreshCrispleafAmaranth",
+    "FreshPrimroseBlossom",
+    "FreshSweetWilliam",
+    "IvoryChalkPouch",
+    "PetrifiedOak",
+    "PrimroseBlossomSachet",
+    "SaltPouch",
+    "SealedEnvelope",
+    "ShinyCoin",
+    "ShroudofBinding",
+    "ShroudofUnion",
+    "SweetWilliamSachet",
+    "TarnishedCoin",
+    "VigosJarOfSaltyLips",
+    "VigosShroud",
+    "WhiteWard"
+  ],
+  "All": [
     "Anniversary2019Offering",
     "Anniversary2020Offering",
     "Anniversary2021Offering",
@@ -41,33 +71,18 @@
     "Anniversary2025Offering",
     "AnnotatedBlueprint",
     "AzarovKey",
-    "BlackSaltStatuette",
     "BloodiedBlueprint",
     "BloodyPartyStreamers",
-    "BogLaurelSachet",
-    "BoundEnvelope",
     "CattleTag28",
-    "ChalkPouch",
     "CharredWeddingPhotograph",
     "ChildrensBook",
     "ClearReagent",
     "ColdwindCattleTag81",
-    "CreamChalkPouch",
     "CrescentMoonBouquet",
-    "CrispleafAmaranthSachet",
     "DecrepitClapboard",
     "EclipseThemeOffering",
     "EmergencyCertificate",
-    "EscapeCake",
     "FaintReagent",
-    "FragrantBogLaurel",
-    "FragrantCrispleafAmaranth",
-    "FragrantPrimroseBlossom",
-    "FragrantSweetWilliam",
-    "FreshBogLaurel",
-    "FreshCrispleafAmaranth",
-    "FreshPrimroseBlossom",
-    "FreshSweetWilliam",
     "FullMoonBouquet",
     "FumingCordage",
     "FumingWelcomeSign",
@@ -79,7 +94,6 @@
     "HazyReagent",
     "HeartLocket",
     "IonThemeOffering",
-    "IvoryChalkPouch",
     "JapaneseCountrySide",
     "Jigsawpiece",
     "KenyaThemeOffering",
@@ -91,8 +105,6 @@
     "NewMoonBouquet",
     "PaintedRiverRock",
     "PElliotLunacyTicket",
-    "PetrifiedOak",
-    "PrimroseBlossomSachet",
     "PsychiatricAssessmentReport",
     "QatarThemeOffering",
     "QuantumThemeOffering",
@@ -100,30 +112,20 @@
     "QuicheThemeOffering",
     "RedMoney",
     "SacrificalWard",
-    "SaltPouch",
-    "SealedEnvelope",
     "ShatteredGlasses",
-    "ShinyCoin",
     "ShreddedPlate",
-    "ShroudofBinding",
-    "ShroudofUnion",
     "SignedLedgerPage",
     "Spring2024Offering",
     "StrodeRealtyKey",
     "SummerOffering",
-    "SweetWilliamSachet",
-    "TarnishedCoin",
     "TheLastMask",
     "ThePiedPiper",
     "TornBlueprint",
     "UkraineThemeOffering",
     "UmbraThemeOffering",
     "VigosBlueprint",
-    "VigosJarOfSaltyLips",
-    "VigosShroud",
     "VirginiaPlate",
     "WalesThemeOffering",
-    "WhiteWard",
     "Winter2024Offering",
     "WormholeThemeOffering"
   ]

src/dumper/constants.cs

@@ -0,0 +1,10 @@
+public static class Constants
+{
+    public static readonly string MappingURL = "https://git.neru.rip/neru/UnlockedByDaylight/raw/branch/main/res/mappings/latest-xbox.usmap";
+
+    public static readonly string PackageName = "BehaviourInteractive.DeadbyDaylightWindows";
+
+    public static readonly string AESKey = "0x22B1639B548124925CF7B9CBAA09F9AC295FCF0324586D6B37EE1D42670B39B3";
+
+    public static readonly string[] BlacklistedCustomizationItems = ["NK_Torso01_Crew01Kraken"];
+}

src/dumper/dbd.cs

@@ -0,0 +1,40 @@
+public enum EItemAvailability : byte
+{
+    Available,
+    Disabled,
+    Retired
+}
+
+public enum ECustomizationCategory : byte
+{
+    None,
+    SurvivorHead,
+    SurvivorTorso,
+    SurvivorLegs,
+    KillerHead,
+    KillerBody,
+    KillerWeapon,
+    Outfits,
+    Charm,
+    Badge,
+    Banner,
+    PortraitBackground
+}
+
+public enum EPlayerRole : byte
+{
+    VE_None,
+    VE_Slasher,
+    VE_Camper,
+    VE_Observer
+}
+
+public struct AvailabilityStruct
+{
+    public EItemAvailability itemAvailability;
+    public string DLCId;
+    public string[] AdditionalDlcIds;
+    public Int32 CloudInventoryId;
+    public string CommunityId;
+    public bool _isLicensed;
+}

src/dumper/dumper.cs

@@ -0,0 +1,404 @@
+using CUE4Parse.Compression;
+using CUE4Parse.Encryption.Aes;
+using CUE4Parse.FileProvider;
+using CUE4Parse.MappingsProvider;
+using CUE4Parse.UE4.Assets.Exports;
+using CUE4Parse.UE4.Assets.Exports.Actor;
+using CUE4Parse.UE4.Assets.Exports.Engine;
+using CUE4Parse.UE4.Assets.Exports.Texture;
+using CUE4Parse.UE4.Assets.Objects;
+using CUE4Parse.UE4.Assets.Objects.Properties;
+using CUE4Parse.UE4.Objects.Core.Misc;
+using CUE4Parse.UE4.Versions;
+using CUE4Parse.UE4.VirtualFileSystem;
+using CUE4Parse.UE4.Wwise.Plugins.MasteringSuite;
+using Microsoft.Win32;
+using Newtonsoft.Json;
+using System.Reflection;
+
+class Dumper
+{
+    private DefaultFileProvider? _provider = null;
+    private IAesVfsReader? _dataPak = null;
+
+    public async Task<bool> InitAsync()
+    {
+        /*
+         *  ensure mapping
+         */
+        string mappingPath = Path.Combine(Path.GetTempPath(), "DeadByDaylight.usmap");
+        bool hasDownloadedMapping = await DownloadMappingFileAsync(Constants.MappingURL, mappingPath);
+        if (!hasDownloadedMapping)
+            return false;
+
+        /*
+         * compression setup
+         */
+        ZlibHelper.Initialize();
+
+        var oodlePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, OodleHelper.OodleFileName);
+        OodleHelper.Initialize(oodlePath);
+
+        /*
+         * game localization
+         */
+        var gamePath = getGamePath();
+        if (gamePath == null) return false;
+
+        var pakDir = gamePath + "\\DeadByDaylight\\Content\\Paks";
+        if (!Directory.Exists(pakDir))
+        {
+            Console.WriteLine("PAK dir does not exist. (Invalid install?)");
+            return false;
+        }
+
+        /*
+         * provider setup
+         */
+        var version = new VersionContainer(EGame.GAME_DeadByDaylight, ETexturePlatform.DesktopMobile);
+        _provider = new DefaultFileProvider(pakDir, SearchOption.TopDirectoryOnly, version);
+        _provider.MappingsContainer = new FileUsmapTypeMappingsProvider(mappingPath);
+
+        _provider.Initialize();
+        _provider.SubmitKey(new FGuid(), new FAesKey(Constants.AESKey));
+        _provider.Mount();
+
+        /*
+         * load db pak
+         */
+        bool hasDataPak = _provider.TryGetArchive("pakchunk4-WinGDK.utoc", out _dataPak);
+        if (!hasDataPak)
+        {
+            Console.WriteLine("Failed to load pakchunk4-WinGDK.utoc");
+            return false;
+        }
+
+        return true;
+    }
+
+    public string? DumpCustomizationItems()
+    {
+        if (_dataPak == null || _provider == null) return null;
+
+        var searchPaths = _dataPak.Files.Keys.Where(x => x.Contains($"/CustomizationItemDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
+
+        var characterItems = new List<string>();
+        var outfits = new List<string>();
+
+        foreach (var path in searchPaths)
+        {
+            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
+            if (_provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
+            {
+                foreach (var row in dataTable.RowMap)
+                {
+                    /*
+                     * props
+                     */
+                    var props = row.Value.Properties;
+
+                    FPropertyTag? categoryProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Category");
+                    if (categoryProp == null || categoryProp.Tag == null) continue;
+
+                    FPropertyTag? availabilityProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Availability");
+                    if (availabilityProp == null || availabilityProp.Tag == null) continue;
+
+                    FStructFallback? availabilityFallback = availabilityProp.Tag.GetValue<FStructFallback>();
+                    if (availabilityFallback == null) continue;
+
+                    /*
+                     * real data
+                     */
+                    string itemName = row.Key.Text;
+                    AvailabilityStruct availability = availabilityFallback.MapToStruct<AvailabilityStruct>();
+                    ECustomizationCategory category = categoryProp.Tag.GetValue<ECustomizationCategory>();
+
+                    /*
+                     * sketchy item filtering
+                     */
+                    if (availability.DLCId == "development") continue;
+                    if (category < ECustomizationCategory.SurvivorHead || category > ECustomizationCategory.KillerWeapon) continue;
+                    if (Constants.BlacklistedCustomizationItems.Contains(itemName)) continue;
+
+                    /*
+                     * storing
+                     */
+                    characterItems.Add(itemName);
+                }
+            }
+        }
+
+        searchPaths = _dataPak.Files.Keys.Where(x => x.Contains($"/OutfitDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
+
+        foreach (var path in searchPaths)
+        {
+            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
+            if (_provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
+            {
+                foreach (var row in dataTable.RowMap)
+                {
+                    /*
+                     * props
+                     */
+                    var props = row.Value.Properties;
+
+                    FPropertyTag? availabilityProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Availability");
+                    if (availabilityProp == null || availabilityProp.Tag == null) continue;
+
+                    FStructFallback? availabilityFallback = availabilityProp.Tag.GetValue<FStructFallback>();
+                    if (availabilityFallback == null) continue;
+
+                    /*
+                     * real data
+                     */
+                    string outfitName = row.Key.Text;
+                    AvailabilityStruct availability = availabilityFallback.MapToStruct<AvailabilityStruct>();
+
+                    if (availability.DLCId == "development")
+                        continue;
+
+                    outfits.Add(outfitName);
+                }
+            }
+        }
+
+        var customizationsSerialized = new
+        {
+            Items = characterItems.OrderBy(x => x).ToList(),
+            Outfits = outfits.OrderBy(x => x).ToList()
+        };
+
+        return JsonConvert.SerializeObject(customizationsSerialized, Formatting.Indented);
+    }
+
+    public string? DumpItems()
+    {
+        if (_dataPak == null || _provider == null) return null;
+
+        var searchPaths = _dataPak.Files.Keys.Where(x => x.Contains($"/ItemDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
+
+        var camperItems = new List<string>();
+        //var slasherPowers = new List<string>();
+
+        foreach (var path in searchPaths)
+        {
+            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
+            if (_provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
+            {
+                foreach (var row in dataTable.RowMap)
+                {
+                    /*
+                     * props
+                     */
+                    var props = row.Value.Properties;
+
+                    FPropertyTag? roleProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
+                    if (roleProp == null || roleProp.Tag == null) continue;
+
+                    //FPropertyTag? typeProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Type");
+                    //if (typeProp == null || typeProp.Tag == null) continue;
+
+                    /*
+                     * real data
+                     */
+                    string itemName = row.Key.Text;
+                    EPlayerRole role = roleProp.Tag.GetValue<EPlayerRole>();
+
+                    if (role == EPlayerRole.VE_Camper)
+                        camperItems.Add(itemName);
+                    //else
+                    //    slasherPowers.Add(itemName);
+                }
+            }
+        }
+
+        var itemsSerialized = new
+        {
+            Campers = camperItems.OrderBy(x => x).ToList()
+        };
+
+        return JsonConvert.SerializeObject(itemsSerialized, Formatting.Indented);
+    }
+
+    public string? DumpAddons()
+    {
+        if (_dataPak == null || _provider == null) return null;
+
+        var searchPaths = _dataPak.Files.Keys.Where(x => x.Contains($"/ItemAddonDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
+
+        var camperAddons = new List<string>();
+        var slasherAddons = new List<string>();
+
+        foreach (var path in searchPaths)
+        {
+            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
+            if (_provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
+            {
+                foreach (var row in dataTable.RowMap)
+                {
+                    /*
+                     * props
+                     */
+                    var props = row.Value.Properties;
+
+                    FPropertyTag? roleProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
+                    if (roleProp == null || roleProp.Tag == null) continue;
+
+                    /*
+                     * real data
+                     */
+                    string itemName = row.Key.Text;
+                    EPlayerRole role = roleProp.Tag.GetValue<EPlayerRole>();
+
+                    if (role == EPlayerRole.VE_Camper)
+                        camperAddons.Add(itemName);
+                    else
+                        slasherAddons.Add(itemName);
+
+                }
+            }
+        }
+
+        var addonsSerialized = new
+        {
+            Slashers = slasherAddons.OrderBy(x => x).ToList(),
+            Campers = camperAddons.OrderBy(x => x).ToList()
+        };
+
+        return JsonConvert.SerializeObject(addonsSerialized, Formatting.Indented);
+    }
+
+    public string? DumpOfferings()
+    {
+        if (_dataPak == null || _provider == null) return null;
+
+        var searchPaths = _dataPak.Files.Keys.Where(x => x.Contains($"/OfferingDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
+
+        var globalOfferings = new List<string>();
+        var camperOfferings = new List<string>();
+        var slasherOfferings = new List<string>();
+
+        foreach (var path in searchPaths)
+        {
+            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
+            if (_provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
+            {
+                foreach (var row in dataTable.RowMap)
+                {
+                    /*
+                     * props
+                     */
+                    var props = row.Value.Properties;
+
+                    FPropertyTag? roleProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
+                    if (roleProp == null || roleProp.Tag == null) continue;
+
+                    /*
+                     * real data
+                     */
+                    string itemName = row.Key.Text;
+                    EPlayerRole role = roleProp.Tag.GetValue<EPlayerRole>();
+
+                    if (role == EPlayerRole.VE_Camper)
+                        camperOfferings.Add(itemName);
+                    else if (role == EPlayerRole.VE_Slasher)
+                        slasherOfferings.Add(itemName);
+                    else
+                        globalOfferings.Add(itemName);
+                }
+            }
+        }
+        var offeringsSerialized = new
+        {
+            Slashers = slasherOfferings.OrderBy(x => x).ToList(),
+            Campers = camperOfferings.OrderBy(x => x).ToList(),
+            All = globalOfferings.OrderBy(x => x).ToList()
+        };
+
+        return JsonConvert.SerializeObject(offeringsSerialized, Formatting.Indented);
+    }
+
+    public string? DumpPerks()
+    {
+        if (_dataPak == null || _provider == null) return null;
+
+        var searchPaths = _dataPak.Files.Keys.Where(x => x.Contains($"/PerkDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
+
+        var camperPerks = new List<string>();
+        var slasherPerks = new List<string>();
+
+        foreach (var path in searchPaths)
+        {
+            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
+            if (_provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
+            {
+                foreach (var row in dataTable.RowMap)
+                {
+                    /*
+                     * props
+                     */
+                    var props = row.Value.Properties;
+
+                    FPropertyTag? roleProp = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
+                    if (roleProp == null || roleProp.Tag == null) continue;
+
+                    /*
+                     * real data
+                     */
+                    string itemName = row.Key.Text;
+                    EPlayerRole role = roleProp.Tag.GetValue<EPlayerRole>();
+
+                    if (role == EPlayerRole.VE_Camper)
+                        camperPerks.Add(itemName);
+                    else
+                        slasherPerks.Add(itemName);
+                }
+            }
+        }
+        var perksSerialized = new
+        {
+            Slashers = slasherPerks.OrderBy(x => x).ToList(),
+            Campers = camperPerks.OrderBy(x => x).ToList()
+        };
+
+        return JsonConvert.SerializeObject(perksSerialized, Formatting.Indented);
+    }
+    private string? getGamePath()
+    {
+        const string packagesPath = @"Software\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository\Packages";
+
+        using var key = Registry.CurrentUser.OpenSubKey(packagesPath);
+
+        if (key == null) return null;
+        string? matchingKeyName = key.GetSubKeyNames()
+                .FirstOrDefault(name => name.StartsWith(Constants.PackageName, StringComparison.OrdinalIgnoreCase));
+
+        if (matchingKeyName != null)
+        {
+            using (RegistryKey? subKey = key.OpenSubKey(matchingKeyName))
+                return subKey?.GetValue("PackageRootFolder")?.ToString();
+        }
+
+        Console.WriteLine("Failed to find game install dir");
+        return null;
+    }
+    private async Task<bool> DownloadMappingFileAsync(string url, string outPath)
+    {
+        try
+        {
+            using (var httpClient = new HttpClient())
+            {
+                var bytes = await httpClient.GetByteArrayAsync(url);
+                Console.WriteLine("Downloading mapping file...");
+                await File.WriteAllBytesAsync(outPath, bytes);
+                Console.WriteLine($"Mapping file downloaded to: {outPath}");
+                return true;
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Error occured while downloading mapping: {ex.Message}");
+        }
+        return false;
+    }
+}

src/dumper/main.cs

@@ -1,228 +1,72 @@
-using CUE4Parse.Compression;
+using CUE4Parse.UE4.Assets.Exports.CustomizableObject;
-using CUE4Parse.Encryption.Aes;
-using CUE4Parse.FileProvider;
-using CUE4Parse.MappingsProvider;
-using CUE4Parse.UE4.Assets.Exports.Actor;
-using CUE4Parse.UE4.Assets.Exports.Engine;
-using CUE4Parse.UE4.Assets.Exports.Texture;
-using CUE4Parse.UE4.Assets.Objects.Properties;
-using CUE4Parse.UE4.Objects.Core.Misc;
-using CUE4Parse.UE4.Objects.UObject;
-using CUE4Parse.UE4.Versions;
-using Newtonsoft.Json;
 
-class DumpByDaylight
+int displayError(string err)
 {
-    private const string _pakDir = "D:\\XboxGames\\Dead By Daylight\\Content\\DeadByDaylight\\Content\\Paks";
+    Console.WriteLine($"Dumper error: {err}");
-    private const string _aesKey = "0x22B1639B548124925CF7B9CBAA09F9AC295FCF0324586D6B37EE1D42670B39B3";
+    Console.WriteLine("Press any key to exit");
-    private const string _mappingURL = "https://git.neru.rip/neru/UnlockedByDaylight/raw/branch/main/res/mappings/latest-xbox.usmap";
+    Console.ReadKey();
-
+    return 1;
-    public static async Task<string?> DownloadMappingFileAsync(string url, string savePath)
-    {
-        try
-        {
-            using (var httpClient = new HttpClient())
-            {
-                Console.WriteLine("downloading mapping file...");
-                var bytes = await httpClient.GetByteArrayAsync(url);
-                await File.WriteAllBytesAsync(savePath, bytes);
-                Console.WriteLine($"mapping file downloaded to: {savePath}");
-                return savePath;
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"failed to download mapping: {ex.Message}");
-            return null;
-        }
-    }
-
-    static async Task Main(string[] args)
-    {
-        // mapping
-        string mappingPath = Path.Combine(Path.GetTempPath(), "DeadByDaylight.usmap");
-        string? downloadedMapping = await DownloadMappingFileAsync(_mappingURL, mappingPath);
-
-        if (string.IsNullOrEmpty(downloadedMapping))
-        {
-            Console.WriteLine("failed to download mapping file, press any key to exit");
-            Console.ReadKey();
-            return;
-        }
-
-        ZlibHelper.Initialize();
-
-        var oodlePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, OodleHelper.OodleFileName);
-        OodleHelper.Initialize(oodlePath);
-
-
-        // parsing setup
-        var version = new VersionContainer(EGame.GAME_DeadByDaylight, ETexturePlatform.DesktopMobile);
-        var provider = new DefaultFileProvider(_pakDir, SearchOption.TopDirectoryOnly, version);
-        provider.MappingsContainer = new FileUsmapTypeMappingsProvider(downloadedMapping);
-
-        provider.Initialize();
-        provider.SubmitKey(new FGuid(), new FAesKey(_aesKey));
-        provider.Mount();
-
-        Console.WriteLine("\nProvider Initialized. Extracting Databases...");
-
-        var dataPak = provider.GetArchive("pakchunk4-WinGDK.utoc");
-
-        /*
-         *  itemdb dump
-         */
-        var searchPaths = dataPak.Files.Keys.Where(x => x.Contains($"/ItemDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
-        var camperItems = new List<string>();
-
-        var slasherPowers = new List<string>();
-
-        foreach (var path in searchPaths)
-        {
-            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
-            if (provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
-            {
-                Console.WriteLine($"getting items / powers from {Path.GetFullPath(path)}");
-
-                foreach (var row in dataTable.RowMap)
-                {
-                    var roleProperty = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
-                    var typeProperty = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Type");
-                    if (typeProperty?.Tag is EnumProperty typeProp && roleProperty?.Tag is EnumProperty roleProp)
-                    {
-                        string typeName = typeProp.Value.ToString() ?? "null";
-                        string roleName = roleProp.Value.ToString() ?? "null";
-
-                        if (roleName == "EPlayerRole::VE_Slasher")
-                            slasherPowers.Add(row.Key.Text);
-                        else
-                            camperItems.Add(row.Key.Text);
-                    }
-                }
-            }
-        }
-
-        var itemsSerialized = new
-        {
-            Campers = camperItems.OrderBy(x => x).ToList(),
-            Slashers = slasherPowers.OrderBy(x => x).ToList()
-        };
-        File.WriteAllText("items.json", JsonConvert.SerializeObject(itemsSerialized, Formatting.Indented));
-
-        /*
-         *  addon dump
-         */
-        searchPaths = dataPak.Files.Keys.Where(x => x.Contains($"/ItemAddonDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
-        var camperAddons = new List<string>();
-        var slasherAddons = new List<string>();
-
-        foreach (var path in searchPaths)
-        {
-            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
-            if (provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
-            {
-                Console.WriteLine($"getting item / power addons from {Path.GetFullPath(path)}");
-
-                foreach (var row in dataTable.RowMap)
-                {
-                    bool isSlasherAddon = false;
-                    var roleProperty = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
-                    if (roleProperty?.Tag is EnumProperty roleEnumProp)
-                    {
-                        string roleName = roleEnumProp.Value.ToString() ?? "null";
-                        if (roleName == "EPlayerRole::VE_Slasher")
-                            isSlasherAddon = true;
-                    }
-
-                    if (isSlasherAddon)
-                        slasherAddons.Add(row.Key.Text);
-                    else
-                        camperAddons.Add(row.Key.Text);
-                }
-            }
-        }
-
-        var addonsSerialized = new
-        {
-            Slashers = slasherAddons.OrderBy(x => x).ToList(),
-            Campers = camperAddons.OrderBy(x => x).ToList()
-        };
-        File.WriteAllText("addons.json", JsonConvert.SerializeObject(addonsSerialized, Formatting.Indented));
-
-        /*
-         *  offerings
-         */
-        searchPaths = dataPak.Files.Keys.Where(x => x.Contains($"/OfferingDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
-
-        var camperOfferings = new List<string>();
-        var slasherOfferings = new List<string>();
-
-        foreach (var path in searchPaths)
-        {
-            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
-            if (provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
-            {
-                Console.WriteLine($"getting offerings from {Path.GetFullPath(path)}");
-
-                foreach (var row in dataTable.RowMap)
-                {
-                    var roleProperty = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
-                    if (roleProperty?.Tag is EnumProperty roleEnumProp)
-                    {
-                        string roleName = roleEnumProp.Value.ToString() ?? "null";
-                        if (roleName == "EPlayerRole::VE_Slasher")
-                            slasherOfferings.Add(row.Key.Text);
-                        else
-                            camperOfferings.Add(row.Key.Text);
-                    }
-                }
-            }
-        }
-        var offeringsSerialized = new
-        {
-            Slashers = slasherOfferings.OrderBy(x => x).ToList(),
-            Campers = camperOfferings.OrderBy(x => x).ToList()
-        };
-        File.WriteAllText("offerings.json", JsonConvert.SerializeObject(offeringsSerialized, Formatting.Indented));
-
-        /*
-         * perks
-         */
-        searchPaths = dataPak.Files.Keys.Where(x => x.Contains($"/PerkDB.uasset", StringComparison.OrdinalIgnoreCase)).ToList();
-
-        var slasherPerks = new List<string>();
-        var camperPerks = new List<string>();
-
-        foreach (var path in searchPaths)
-        {
-            var cleanPath = path.Contains('.') ? path.Substring(0, path.LastIndexOf('.')) : path;
-            if (provider.TryLoadPackageObject<UDataTable>(cleanPath, out var dataTable))
-            {
-                Console.WriteLine($"getting perks from {Path.GetFullPath(path)}");
-
-                foreach (var row in dataTable.RowMap)
-                {
-                    var roleProperty = row.Value.Properties.FirstOrDefault(p => p.Name.Text == "Role");
-                    if (roleProperty?.Tag is EnumProperty roleEnumProp)
-                    {
-                        string roleName = roleEnumProp.Value.ToString() ?? "null";
-                        if (roleName == "EPlayerRole::VE_Slasher")
-                            slasherPerks.Add(row.Key.Text);
-                        else
-                            camperPerks.Add(row.Key.Text);
-                    }
-                }
-            }
-        }
-
-        var perksSerialized = new
-        {
-            Slashers = slasherPerks.OrderBy(x => x).ToList(),
-            Campers = camperPerks.OrderBy(x => x).ToList()
-        };
-        File.WriteAllText("perks.json", JsonConvert.SerializeObject(perksSerialized, Formatting.Indented));
-
-        Console.WriteLine("\nAll dumper operations finished. Press any key to Close.");
-        Console.ReadKey();
-    }
 }
+
+Console.WriteLine("Dumper start");
+var dumper = new Dumper();
+
+bool hasInitialized = await dumper.InitAsync();
+if (!hasInitialized) return displayError("Dumper.InitAsync failed");
+
+Console.WriteLine("Dumper initialized");
+
+string? customizationItemsJSON = dumper.DumpCustomizationItems();
+if (customizationItemsJSON != null)
+{
+    File.WriteAllText("customizations.json", customizationItemsJSON);
+}
+else
+{
+    Console.WriteLine("Failed to dump customizations");
+}
+
+string? itemsJSON = dumper.DumpItems();
+if (itemsJSON != null)
+{
+    File.WriteAllText("items.json", itemsJSON);
+}
+else
+{
+    Console.WriteLine("Failed to dump items");
+}
+
+string? addonsJSON = dumper.DumpAddons();
+if (addonsJSON != null)
+{
+    File.WriteAllText("addons.json", addonsJSON);
+}
+else
+{
+    Console.WriteLine("Failed to dump addons");
+}
+
+
+string? offeringsJSON = dumper.DumpOfferings();
+if (offeringsJSON != null)
+{
+    File.WriteAllText("offerings.json", offeringsJSON);
+}
+else
+{
+    Console.WriteLine("Failed to dump offerings");
+}
+
+string? perksJSON = dumper.DumpPerks();
+if (perksJSON != null)
+{
+    File.WriteAllText("perks.json", perksJSON);
+}
+else
+{
+    Console.WriteLine("Failed to dump perks");
+}
+
+Console.WriteLine("Dumper finished");
+
+return 0;

src/dumper/structmapper.cs

@@ -0,0 +1,39 @@
+using CUE4Parse.UE4.Assets.Objects;
+using System.Reflection;
+
+public static class StructMapper
+{
+    public static T MapToStruct<T>(this FStructFallback fallback) where T : struct
+    {
+        object result = new T();
+        var fields = typeof(T).GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+        foreach (var field in fields)
+        {
+            try
+            {
+                var method = typeof(CUE4Parse.UE4.Assets.Exports.AbstractPropertyHolder)
+                    .GetMethods()
+                    .FirstOrDefault(m => m.Name == "GetOrDefault" && m.GetGenericArguments().Length == 1);
+
+                if (method != null)
+                {
+                    var genericMethod = method.MakeGenericMethod(field.FieldType);
+
+                    var value = genericMethod.Invoke(fallback, new object[] { field.Name, null!, StringComparison.Ordinal });
+
+                    if (value != null)
+                    {
+                        field.SetValue(result, value);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Mapping failed for {field.Name}: {ex.Message}");
+            }
+        }
+
+        return (T)result;
+    }
+}

src/unlocker/spoofing.cpp

@@ -56,41 +56,60 @@ void Spoofer::registerListeners(Proxy* proxy)
     });
 }
 
-#define LOADDATA(fileName, type, camperSet, slasherSet, errorMsg)                                                      \
-    std::string path##type = utils::getExePath() + fileName;                                                           \
-    std::ifstream file##type(path##type);                                                                              \
-    if (file##type.is_open())                                                                                          \
-    {                                                                                                                  \
-        std::stringstream buff;                                                                                        \
-        buff << file##type.rdbuf();                                                                                    \
-        if (!parseStackable(buff.str(), camperSet, slasherSet))                                                        \
-            Log::error("Failed to parse {} - {}", fileName, errorMsg);                                                 \
-        else                                                                                                           \
-            Log::verbose("Loaded {} camper ids and {} slasher ids from {}", camperSet.size(), slasherSet.size(),       \
-                         fileName);                                                                                    \
-    }                                                                                                                  \
-    else                                                                                                               \
-        Log::warning("Missing {} - {}", fileName, errorMsg);
-
 void Spoofer::loadData()
 {
     Log::info("Loading data");
 
-    std::string catalogPath = utils::getExePath() + "catalog.json";
+    /*
-    std::ifstream catalogFile(catalogPath);
+        stackables
-    if (catalogFile.is_open())
+    */
+    static auto loadData = [this](const char* fileName, std::unordered_set<std::string>* camperSet,
+                                  std::unordered_set<std::string>* slasherSet,
+                                  std::unordered_set<std::string>* globalSet, const char* errorMsg) {
+        std::ifstream file(utils::getExePath() + fileName);
+
+        if (file.is_open())
+        {
+            std::stringstream buff;
+            buff << file.rdbuf();
+            if (!parseStackable(buff.str(), camperSet, slasherSet, globalSet))
+                return Log::error("Failed to parse {} - {}", fileName, errorMsg);
+            else
+                Log::verbose("Loaded {}", fileName);
+        }
+        else
+            Log::warning("Missing file: {} - {}", fileName, errorMsg);
+    };
+
+    loadData("items.json", &_camperItemIds, 0, 0, "Items wont be added");
+    loadData("offerings.json", &_camperOfferingIds, &_slasherOfferingIds, &_globalOfferingIds,
+             "Offerings won't be added");
+    loadData("addons.json", &_camperAddonIds, &_slasherAddonIds, 0, "Offerings won't be added");
+    loadData("perks.json", &_camperPerkIds, &_slasherPerkIds, 0, "Offerings won't be added");
+
+    /*
+        catalog items
+    */
+    std::ifstream customizationsFile(utils::getExePath() + "customizations.json");
+    if (customizationsFile.is_open())
     {
         std::stringstream buff;
-        buff << catalogFile.rdbuf();
+        buff << customizationsFile.rdbuf();
-        if (!parseCatalog(buff.str())) Log::warning("Failed to parse catalog.json - Customizations won't be unlocked");
+        if (!parseCustomizations(buff.str()))
+            Log::warning("Failed to parse customizations.json - Outfits and character items won't be added");
+        else
+            Log::verbose("Loaded customizations.json");
     }
-    else
-        Log::warning("Missing catalog.json - Customizations won't be unlocked");
 
-    LOADDATA("items.json", Items, _camperItemIds, _slasherPowerIds, "Items won't be added");
+    Log::verbose("Finished loading data");
-    LOADDATA("offerings.json", Offerings, _camperOfferingIds, _slasherOfferingIds, "Offerings won't be added");
+
-    LOADDATA("addons.json", Addons, _camperAddonIds, _slasherAddonIds, "Addons won't be added");
+    Log::verbose("Items - {} camper", _camperItemIds.size());
-    LOADDATA("perks.json", Perks, _camperPerkIds, _slasherPerkIds, "Perks won't be added");
+    Log::verbose("Offerings - {} camper | {} slasher | {} global", _camperOfferingIds.size(),
+                 _slasherOfferingIds.size(), _globalOfferingIds.size());
+    Log::verbose("Addons - {} camper | {} slasher ", _camperAddonIds.size(), _slasherAddonIds.size());
+    Log::verbose("Perks - {} camper | {} slasher ", _camperPerkIds.size(), _slasherPerkIds.size());
+
+    Log::verbose("Catalog - {} outfits | {} items", _catalogOutfitIds.size(), _catalogItemIds.size());
 }
 
 void Spoofer::loadConfig()
@@ -130,46 +149,8 @@ void Spoofer::loadConfig()
 /*
     data parsing
 */
-bool Spoofer::parseCatalog(std::string data)
+bool Spoofer::parseStackable(std::string data, std::unordered_set<std::string>* camperSet,
-{
+                             std::unordered_set<std::string>* slasherSet, std::unordered_set<std::string>* globalSet)
-    json doc = json::parse(data, nullptr, false);
-
-    if (doc.is_discarded())
-    {
-        Log::error("Failed to parse catalog");
-        return false;
-    }
-
-    try
-    {
-        const auto& catalogData = doc.at("data");
-
-        auto extractIds = [&](const std::string& key, std::unordered_set<std::string>& targetSet) {
-            if (catalogData.contains(key) && catalogData[key].contains("items"))
-                for (const auto& id : catalogData[key]["items"])
-                {
-                    if (id.is_string()) targetSet.insert(id.get<std::string>());
-                }
-            else
-                Log::warning("Catalog missing or invalid category: {}", key);
-        };
-
-        extractIds("item", _catalogItemIds);
-        extractIds("outfit", _catalogOutfitIds);
-    }
-    catch (const json::exception& e)
-    {
-        Log::error("Invalid catalog format: {}", e.what());
-        return false;
-    }
-
-    Log::info("Parsed {} items and {} outfits from catalog", _catalogItemIds.size(), _catalogOutfitIds.size());
-
-    return true;
-}
-
-bool Spoofer::parseStackable(std::string data, std::unordered_set<std::string>& camperSet,
-                             std::unordered_set<std::string>& slasherSet)
 {
     json doc = json::parse(data, nullptr, false);
     if (doc.is_discarded())
@@ -178,18 +159,47 @@ bool Spoofer::parseStackable(std::string data, std::unordered_set<std::string>&
         return false;
     }
 
-    auto populate = [&](const std::string& key, std::unordered_set<std::string>& targetSet) {
+    auto populate = [&](const std::string& key, std::unordered_set<std::string>* targetSet) {
         if (doc.contains(key) && doc[key].is_array())
             for (const auto& item : doc[key])
             {
-                if (item.is_string()) targetSet.insert(item.get<std::string>());
+                if (item.is_string()) targetSet->insert(item.get<std::string>());
             }
         else
             Log::warning("Missing stackables array ({})", key);
     };
 
-    populate("Slashers", slasherSet);
+    if (camperSet) populate("Campers", camperSet);
-    populate("Campers", camperSet);
+    if (slasherSet) populate("Slashers", slasherSet);
+    if (globalSet) populate("All", globalSet);
+
+    return true;
+}
+
+bool Spoofer::parseCustomizations(std::string data)
+{
+    json doc = json::parse(data, nullptr, false);
+    if (doc.is_discarded())
+    {
+        Log::error("JSON parse error @ parseCustomizations");
+        return false;
+    }
+
+    if (doc.contains("Items"))
+    {
+        for (const auto& item : doc["Items"])
+        {
+            if (item.is_string()) _catalogItemIds.insert(item.get<std::string>());
+        }
+    }
+
+    if (doc.contains("Outfits"))
+    {
+        for (const auto& outfit : doc["Outfits"])
+        {
+            if (outfit.is_string()) _catalogOutfitIds.insert(outfit.get<std::string>());
+        }
+    }
 
     return true;
 }
@@ -200,8 +210,8 @@ bool Spoofer::parseStackable(std::string data, std::unordered_set<std::string>&
 std::string Spoofer::getRandomItem()
 {
     std::vector<const std::unordered_set<std::string>*> allSets = {
-        &_camperItemIds,  &_slasherPowerIds, &_camperOfferingIds, &_slasherOfferingIds,
+        &_camperItemIds,   &_camperOfferingIds, &_slasherOfferingIds, &_camperAddonIds,
-        &_camperAddonIds, &_slasherAddonIds, &_camperPerkIds,     &_slasherPerkIds};
+        &_slasherAddonIds, &_camperPerkIds,     &_slasherPerkIds};
 
     std::vector<const std::unordered_set<std::string>*> validSets;
     for (auto* s : allSets)
@@ -324,6 +334,7 @@ void Spoofer::modifyCharacterData(json& js)
             std::unordered_set<std::string> stackableIds;
             stackableIds.insert(_camperItemIds.begin(), _camperItemIds.end());
             stackableIds.insert(_camperOfferingIds.begin(), _camperOfferingIds.end());
+            stackableIds.insert(_globalOfferingIds.begin(), _globalOfferingIds.end());
             stackableIds.insert(_camperAddonIds.begin(), _camperAddonIds.end());
             stackableIds.insert(_slasherAddonIds.begin(), _slasherAddonIds.end());
             stackableIds.insert(_slasherOfferingIds.begin(), _slasherOfferingIds.end());
@@ -361,6 +372,8 @@ void Spoofer::modifyCharacterData(json& js)
                 appendItems(_slasherOfferingIds, false);
                 appendItems(_slasherPerkIds, true);
             }
+
+            appendItems(_globalOfferingIds, true);
         }
     }
 
@@ -372,26 +385,6 @@ void Spoofer::modifyCharacterData(json& js)
 /*
     endpoint handlers
 */
-
-void Spoofer::onGetCatalogItems(std::string& body)
-{
-    std::thread t([body]() {
-        std::string outPath = utils::getExePath() + "catalog.json";
-        std::ofstream file(outPath);
-        if (file.is_open())
-        {
-            file << body;
-            file.close();
-            Log::verbose("Raw catalog saved to {}", outPath);
-        }
-        else
-            Log::error("Unable to write to catalog.json");
-    });
-    t.detach();
-
-    parseCatalog(body);
-}
-
 void Spoofer::onGetAll(std::string& body)
 {
     json doc = json::parse(body, nullptr, false);
@@ -624,7 +617,6 @@ void Spoofer::serverResponseHandler(const std::string& url, std::string& body, s
     Log::verbose("BHVR api res @ {}", url);
 #endif
 
-    if (url.find("api/v1/extensions/store/getCatalogItems") != std::string::npos) return onGetCatalogItems(body);
     if (url.find("api/v1/dbd-character-data/get-all") != std::string::npos) return onGetAll(body);
     if (url.find("api/v1/dbd-character-data/get-all") != std::string::npos) return onGetAll(body);
     if (url.find("api/v1/dbd-inventories/all") != std::string::npos) return onInventoryAll(body);

src/unlocker/spoofing.h

@@ -26,9 +26,9 @@ class Spoofer
         void loadData();
         void loadConfig();
 
-        bool parseCatalog(std::string data);
+        bool parseStackable(std::string data, std::unordered_set<std::string>* camperSet,
-        bool parseStackable(std::string data, std::unordered_set<std::string>& camperSet,
+                            std::unordered_set<std::string>* slasherSet, std::unordered_set<std::string>* globalSet);
-                            std::unordered_set<std::string>& slasherSet);
+        bool parseCustomizations(std::string data);
 
         std::string getRandomItem();
         int getRandomQuantity();
@@ -36,7 +36,6 @@ class Spoofer
         void generateBloodweb(nlohmann::json& data);
         void modifyCharacterData(nlohmann::json& js);
 
-        void onGetCatalogItems(std::string& body);
         void onGetAll(std::string& body);
         void onInventoryAll(std::string& body);
         void onMessageList(std::string& body);
@@ -48,10 +47,10 @@ class Spoofer
         SpooferConfig _config;
 
         std::unordered_set<std::string> _camperItemIds;
-        std::unordered_set<std::string> _slasherPowerIds;
 
         std::unordered_set<std::string> _camperOfferingIds;
         std::unordered_set<std::string> _slasherOfferingIds;
+        std::unordered_set<std::string> _globalOfferingIds;
 
         std::unordered_set<std::string> _camperAddonIds;
         std::unordered_set<std::string> _slasherAddonIds;