Module:GameData/doc: Difference between revisions

From Melvor Idle
(Add MAX_TRADER_STOCK_INCREASE to townKeys for next update)
(Support all remaining data modifications & dependent data)
 
(23 intermediate revisions by the same user not shown)
Line 1: Line 1:
The '''GameData''' module is the source of all game data which many other Lua modules rely upon. This module deals with the initial loading of the game data structure, and then enables other modules to access this both via a library of functions (preferred) and in its raw format.
The game data used by the wiki is currently at version <b>{{#invoke:GameData|getDataVersionText}}</b>.
To generate game data, do the following:
To generate game data, do the following:
# Navigate to https://melvoridle.com within your preferred web browser
# Navigate to https://melvoridle.com within your preferred web browser
Line 5: Line 9:
# Open the browser console/developer mode (usually by hitting the F12 key for most browsers)
# Open the browser console/developer mode (usually by hitting the F12 key for most browsers)
# Within the browser console, enter the following code then hit enter. If successful, the game data should appear within the console
# Within the browser console, enter the following code then hit enter. If successful, the game data should appear within the console
# Copy the game data & update [[Module:GameData/data]] accordingly
# Copy the game data & update [[Module:GameData/data]], [[Module:GameData/data2]], [[Module:GameData/data3]] accordingly


{{SpoilerBox|color=default|title=Code|text=<pre>// TODO:
{{SpoilerBox|color=default|title=Code|text=<syntaxhighlight lang="javascript" line>class Wiki {
// Handle modifications portion of data packages
constructor() {
// Use actual descriptions as per language data
this.debugMode = false;
class Wiki {
this.prettyPrint = false;
    constructor() {
this.customLocalizations = {
        this.namespaces = {
// Contains custom localization strings, to override any game provided localizations.
            melvorD: { displayName: "Demo", url: "https://" + location.hostname + "/assets/data/melvorDemo.json" },
// To be used sparingly, for instances where 2+ objects of the same type
            melvorF: { displayName: "Full Version", url: "https://" + location.hostname + "/assets/data/melvorFull.json" },
// (e.g. monsters) have the same name, as this isn't convenient to deal with in Lua
            melvorTotH: { displayName: "Throne of the Herald", url: "https://" + location.hostname + "/assets/data/melvorTotH.json" }
        };
        // Check all required namespaces are registered, as there are still some bits of data extracted from in-game rather than the data packages
        Object.keys(this.namespaces).forEach((nsID) => {
            const nsTest = game.registeredNamespaces.getNamespace(nsID);
            if (nsTest === undefined) {
                throw new Error(`Namespace ${ nsID } (${ this.namespaces[nsID].displayName }) is not registered - Ensure you are signed in and have the expansion.`);
            }
        });


        this.packData = {};
// TotH curse also named 'Madness'
        this.gameData = {};
MAGIC_ABYSSAL_NAME_Madness: 'Madness (ItA)',
        this.skillDataInit = {};
        this.dataPropFilters = {
            // Specifies rules for properties of entities (items, monsters, etc.) which
            // will be removed as they are unused in the wiki & would otherwise bloat
            // the data.
            // Format: property: ruleFunction(entityType, entity)
            //      where ruleFunction is a function returning true if the property is to
            //     be retained, false otherwise
            media: function(entityType, entity) { return false; },
            altMedia: function(entityType, entity) { return false; },
            markMedia: function(entityType, entity) { return false; },
            icon: function(entityType, entity) { return false; },
            barStyle: function(entityType, entity) { return false; }, // See: melvorD:Compost
            buttonStyle: function(entityType, entity) { return false; },
            descriptionGenerator: function(entityType, entity) { return false; },
            containerID: function(entityType, entity) { return false; },
            headerBgClass: function(entityType, entity) { return false; },
            textClass: function(entityType, entity) { return false; },
            btnClass: function(entityType, entity) { return false; },
            golbinRaidExclusive: function(entityType, entity) { return entity.golbinRaidExclusive; },
            ignoreCompletion: function(entityType, entity) { return entity.ignoreCompletion; },
            obtainFromItemLog: function(entityType, entity) { return entity.obtainFromItemLog; },
            validSlots: function(entityType, entity) { return entity.validSlots.length > 0; },
            occupiesSlots: function(entityType, entity) { return entity.occupiesSlots.length > 0; },
            equipRequirements: function(entityType, entity) { return entity.equipRequirements.length > 0; },
            equipmentStats: function(entityType, entity) { return entity.equipmentStats.length > 0; },
            tier: function(entityType, entity) {
                if (entityType === 'items') {
                    return entity.tier !== 'none';
                }
                else {
                    return true;
                }
            }
        };
        this.dataPropTransforms = {
            // Specifies rules for transforming values of entity properties
            // Format: property: ruleFunction(entityType, entity)
            //      where ruleFunction is a function returning the transformed value
            //      to be used in place of the original value
            langHint: function(ns, entityType, entity) {
                let localID = ''
                if (entity.id.indexOf(':') > 0) {
                    localID = entity.id.split(':').pop();
                }
                else {
                    localID = entity.id
                }
                return getLangString(entity.category, localID);
            },
            equipmentStats: function(ns, entityType, entity) {
                const newStats = {};
                entity.forEach((stat) => {
                    if (newStats[stat.key] === undefined) {
                        newStats[stat.key] = stat.value;
                    }
                    else {
                        newStats[stat.key] += stat.value;
                    }
                });
                return newStats;
            },
            altSpells: function(ns, entityType, entity) {
                if (entityType !== 'skillData') {
                    return entity;
                }
                else {
                    const newData = structuredClone(entity);
                    newData.forEach((i) => {
                        i.spellBook = 'altMagic';
                    });
                    return newData;
                }
            },
            attacks: function(ns, entityType, entity) {
                if (entityType !== 'attacks') {
                    return entity;
                }
                else {
                    entity.forEach((attDef) => {
                        const nsAttID = ns + ':' + attDef.id;
                        const att = game.specialAttacks.getObjectByID(nsAttID);
                        attDef.description = att.description;
                    });
                    return entity;
                }
            }
        };
        this.dataPropTransforms.langCustomDescription = this.dataPropTransforms.langHint;
    };
    async getWikiData() {
        if (!isLoaded) {
            throw new Error('Game must be loaded into a character first');
        }
        for (const nsIdx in Object.keys(this.namespaces)) {
            const ns = Object.keys(this.namespaces)[nsIdx];
            const dataURL = this.namespaces[ns].url;
            console.log(`URL: ${ dataURL }`);
            const dataPackage = await this.getDataPackage(dataURL);
            if (dataPackage.namespace === undefined) {
                throw new Error(`Data package has no namespace: ${ dataURL }`);
            }
            else if (dataPackage.data === undefined) {
                throw new Error(`Data package has no data: ${ dataURL }`);
            }
            console.log(`Obtained data for namespace ${ dataPackage.namespace }, ${ JSON.stringify(dataPackage.data).length.toLocaleString() } bytes`);
            this.processDataPackage(dataPackage);
            console.log(`After transformation: ${ JSON.stringify(dataPackage.data).length.toLocaleString() } bytes`);
        }
        // All data packages should now be within this.gameData
    }
    getGameVersion() {
        const fileDOM = document.querySelector('#sidebar ul.nav-main');
        let fileVer = "Unknown";
        if (fileDOM !== null && fileDOM.dataset !== undefined) {
            fileVer = fileDOM.dataset.fileVersion;
        }
        return gameVersion + ' (' + fileVer + ')';
    }
    async printWikiData() {
        if (!isLoaded) {
            throw new Error('Game must be loaded into a character first');
        }
        if (Object.keys(this.packData).length < Object.keys(this.namespaces).length) {
            // Need to retrieve game data first
            const result = await this.getWikiData();
        }
        let dataObjText = JSON.stringify(this.gameData);
        dataObjText = dataObjText.replace(/\'/g, "\\\'");
        dataObjText = dataObjText.replace(/\\\"/g, "\\\\\"");


        let dataText = '-- Version: ' + this.getGameVersion();
// Stronghold boss monsters, where names overlap with normal monster variants
        dataText += "\r\n\r\nlocal gameData = mw.text.jsonDecode('";
MONSTER_NAME_FierceDevilBoss: 'Fierce Devil (Stronghold)',
        dataText += dataObjText;
MONSTER_NAME_ElementalistBoss: 'Elementalist (Stronghold)',
        dataText += "')\r\n\r\nreturn gameData";
MONSTER_NAME_PratTheGuardianOfSecretsBoss: 'Prat, the Guardian of Secrets (Stronghold)',
        console.log(dataText);
MONSTER_NAME_MysteriousFigurePhase1Stronghold: 'Mysterious Figure - Phase 1 (Stronghold)',
    }
MONSTER_NAME_MysteriousFigurePhase2Stronghold: 'Mysterious Figure - Phase 2 (Stronghold)',
    async getDataPackage(url) {
MONSTER_NAME_AhreniaStronghold: 'Ahrenia (Stronghold)'
        // Based largely on Game.fetchAndRegisterDataPackage()
};
        const headers = new Headers();
this.namespaces = {
        headers.append('Content-Type', 'application/json');
melvorD: {
        return await fetch(url, {
displayName: 'Demo',
            method: 'GET',
packFile: 'melvorDemo.json',
            headers
},
        }).then(function(response) {
melvorF: {
            if (!response.ok) {
displayName: 'Full Version',
                throw new Error(`Couldn't fetch data package from URL: ${ url }`);
packFile: 'melvorFull.json',
            }
},
            return response.json();
melvorTotH: {
        });
displayName: 'Throne of the Herald',
    }
packFile: 'melvorTotH.json',
    processDataPackage(dataPackage) {
},
        // Transforms the raw data from data packages in various ways, then
melvorAoD: {
        // consolidates into this.packData & this.gameData
displayName: 'Atlas of Discovery',
        const ns = dataPackage.namespace;
packFile: 'melvorExpansion2.json',
        const packData = dataPackage.data;
},
melvorBirthday2023: {
displayName: 'Melvor Birthday 2023',
packFile: 'melvorBirthday2023.json',
},
melvorItA: {
displayName: 'Into the Abyss',
packFile: 'melvorItA.json',
},
};
this.registeredNamespaces = [];
// List of categories to be excluded from the generated game data.
// These serve no purpose for the wiki and so would otherwise bloat the data
this.excludedCategories = [
'pages',
'steamAchievements',
'tutorialStageOrder',
'tutorialStages'
];
// Check all required namespaces are registered, as there are still some bits of data extracted from in-game rather than the data packages
Object.keys(this.namespaces).forEach((nsID) => {
const nsTest = game.registeredNamespaces.getNamespace(nsID);
if (nsTest === undefined) {
throw new Error(
`Namespace ${nsID} (${this.namespaces[nsID].displayName}) is not registered - Ensure you are signed in and have the expansion.`
);
}
});
// The output data is now long enough that it exceeds the maximum allowed MediaWiki article
// length of 2,048KB. The below determines how the data should be separated over multiple
// pages (Module:GameData then combines the data into a single structure upon
// initialization).
this.maxPageBytes = 2 * 1024 ** 2; // 2048KB
this.printPages = [
{ includeCategories: '*', destination: 'Module:GameData/data' },
{
includeCategories: ['items'],
destination: 'Module:GameData/data2',
},
{
includeCategories: [
'itemUpgrades',
'itemSynergies',
'modifiers',
'shopPurchases',
'realms',
'damageTypes',
'combatTriangleSets',
'randomAbyssalGems',
'randomFragments',
'randomFiremakingOils',
'ancientRelics',
'attackSpells',
'attacks',
'combatPassives',
'monsters',
'bankSortOrder',
'combatEffects',
'combatEffectTemplates',
'combatEffectGroups'
],
destination: 'Module:GameData/data3',
},
];


        this.transformDataPackage(dataPackage);
this.packData = {};
        this.packData[dataPackage.namespace] = dataPackage;
this.gameData = {};
        this.registerDataPackage(dataPackage.namespace);
this.skillDataInit = {};
    }
}
    transformDataPackage(dataPackage) {
getDataPackURL(nsID) {
        // Takes a raw data package and performs various manipulations
return 'https://' + location.hostname + '/assets/data/' + this.namespaces[nsID].packFile + '?' + DATA_VERSION.toString();
        const ns = dataPackage.namespace;
}
        const packData = dataPackage.data;
async getWikiData() {
if (!isLoaded) {
throw new Error('Game must be loaded into a character first');
}
for (const nsIdx in Object.keys(this.namespaces)) {
const ns = Object.keys(this.namespaces)[nsIdx];
const dataURL = this.getDataPackURL(ns);
console.log(`URL: ${dataURL}`);
const dataPackage = await this.getDataPackage(dataURL);
if (dataPackage.namespace === undefined) {
throw new Error(`Data package has no namespace: ${dataURL}`);
} else if (dataPackage.data === undefined) {
throw new Error(`Data package has no data: ${dataURL}`);
}
console.log(
`Obtained data for namespace ${dataPackage.namespace}, ${JSON.stringify(
dataPackage.data
).length.toLocaleString()} bytes`
);
this.processDataPackage(dataPackage);
console.log(`After transformation: ${JSON.stringify(dataPackage.data).length.toLocaleString()} bytes`);
}
// Process dependent data after all packages processed
console.log('Processing dependent data for all packages...');
this.processDependentData();
// All data packages should now be within this.gameData
}
getGameFileVersion() {
const fileDOM = document.querySelector('#sidebar ul.nav-main');
let fileVer = 'Unknown';
if (fileDOM !== null && fileDOM.dataset !== undefined) {
return fileDOM.dataset.fileVersion;
}
}
getGameVersion() {
return gameVersion;
}
getGameVersionText() {
return this.getGameVersion() + ' (' + this.getGameFileVersion() + ')';
}
getObjectByID(data, objectID, idKey = 'id') {
if (data !== undefined && objectID !== undefined) {
return data.find((obj) => obj[idKey] === objectID);
}
}
getCategoriesForPage(page) {
if (Array.isArray(page.includeCategories)) {
return page.includeCategories;
} else if (page.includeCategories === '*') {
// Special value, include all categories other than those included within
// other pages
return Object.keys(this.gameData).filter(
(cat) => !this.printPages.some((p) => Array.isArray(p.includeCategories) && p.includeCategories.includes(cat))
);
}
}
escapeQuotes(data) {
var newData = data.replace(/\\/g, '\\\\');
newData = newData.replace(/'/g, "\\'");
newData = newData.replace(/"/g, '\\"');
return newData;
}
formatJSONData(category, data) {
if (data === undefined) {
console.warn(`dataFormatter: Data for category ${category} is undefined`);
return '';
}
if (this.debugMode) {
console.debug('Formatting category data: ' + category);
}
if (category === 'skillData') {
return '"' + category + '":[' + data.map((x) => this.escapeQuotes(JSON.stringify(x))).join(",' ..\n'") + ']';
} else {
return '"' + category + '":' + this.escapeQuotes(JSON.stringify(data));
}
}
dataFullyLoaded() {
return Object.keys(this.packData).length >= Object.keys(this.namespaces).length;
}
printCategoryDataLength() {
if (!this.dataFullyLoaded()) {
throw new Error('Game data not loaded, use printWikiData first');
}
let dataLengths = [];
this.printPages.forEach((page) => {
const inclCat = this.getCategoriesForPage(page);
inclCat.forEach((cat) => {
dataLengths.push({
page: page.destination,
category: cat,
length: this.formatJSONData(cat, this.gameData[cat]).length,
});
});
});
console.table(dataLengths);
}
async printWikiData() {
if (!isLoaded) {
throw new Error('Game must be loaded into a character first');
}
if (!this.dataFullyLoaded()) {
// Need to retrieve game data first
const result = await this.getWikiData();
}
console.log('Printing data for game version ' + this.getGameVersionText());
this.printPages.forEach((page) => {
const inclCat = this.getCategoriesForPage(page);
let gameDataFiltered = {};
inclCat.forEach((cat) => (gameDataFiltered[cat] = this.gameData[cat]));


        Object.keys(packData).forEach((categoryName) => {
// Convert game data into a JSON string for export
            switch(categoryName) {
let dataText;
                case 'bankSortOrder':
if (this.prettyPrint) {
                case 'steamAchievements':
dataText = JSON.stringify(gameDataFiltered, undefined, '\t');
                    // This data serves no purpose for the wiki and only serves to bloat
} else {
                    // the data, so simply delete it
dataText = JSON.stringify(gameDataFiltered);
                    delete packData[categoryName];
}
                    break;
                default:
                    this.transformDataNode(ns, categoryName, packData, categoryName);
                    break;
            }
        });
    }
    transformDataNode(ns, categoryName, parentNode, nodeKey) {
        let dataNode = parentNode[nodeKey];
        const transformFunc = this.dataPropTransforms[nodeKey];
        if (transformFunc !== undefined) {
            // A transformation function is defined for this node
            parentNode[nodeKey] = transformFunc(ns, categoryName, dataNode);
            dataNode = parentNode[nodeKey];
        }
        if (Array.isArray(dataNode)) {
            // Recursive call to ensure all data is transformed, regardless of its depth
            dataNode.forEach((entity, idx) => this.transformDataNode(ns, categoryName, dataNode, idx));
        }
        else if (typeof dataNode === 'object' && dataNode !== null) {
            // Iterate properties of object, checking if each should be deleted or transformed
            Object.keys(dataNode).forEach((key) => {
                // Check if property is to be deleted or not
                const filterFunc = this.dataPropFilters[key];
                if (filterFunc !== undefined && !filterFunc(categoryName, dataNode)) {
                    delete dataNode[key];
                }
                else if (typeof dataNode[key] === "object" && dataNode[key] !== null) {
                    // If an object (either an array or key/value store) is within the current
                    // object then we must traverse this too
                    this.transformDataNode(ns, categoryName, dataNode, key);
                }
                else {
                    // Transform property, if a transformation is defined below
                    switch(key) {
                        case 'id':
                            // Add namespace to ID if it isn't already
                            dataNode[key] = this.getNamespacedID(ns, dataNode[key]);
                            break;
                        case 'name':
                            // Some items have underscores in their names, replace with spaces
                            if (categoryName == 'items') {
                                dataNode[key] = dataNode[key].replaceAll('_', ' ');
                            }
                            break;
                    }
                }
            });
        }
        // Special case for skillData so that certain values initialized when the various Skill
        // classes are initialized may be added here also
        if ((categoryName === 'skillData') && dataNode.skillID !== undefined && dataNode.data !== undefined && !this.skillDataInit[dataNode.skillID]) {
            // We are currently at the topmost level of a skill object
            const gameSkill = game.skills.registeredObjects.get(dataNode.skillID);
            if (gameSkill !== undefined) {
                dataNode.data.name = getLangString('SKILL_NAME', this.getLocalID(dataNode.skillID));


                if (gameSkill.milestones !== undefined && dataNode.data.milestoneCount === undefined) {
console.log(`For page "${page.destination}" (${dataText.length.toLocaleString()} bytes):`);
                    dataNode.data.milestoneCount = gameSkill.milestones.length;
if (dataText.length > this.maxPageBytes) {
                }
console.warn(
                // For every skill with mastery, add mastery checkpoint descriptions
`Page "${page.destination}" exceeds max page size of ${(this.maxPageBytes / 1024).toLocaleString()}KB by ${(
                if (gameSkill instanceof SkillWithMastery && dataNode.data.masteryTokenID !== undefined && dataNode.data.masteryCheckpoints === undefined) {
dataText.length - this.maxPageBytes
                    const localID = this.getLocalID(dataNode.skillID);
).toLocaleString()} bytes. Consider amending the printPages configuration to move some data categories from this page onto other pages.`
                    dataNode.data.baseMasteryPoolCap = gameSkill.baseMasteryPoolCap;
);
                    dataNode.data.masteryCheckpoints = [];
}
                    masteryCheckpoints.forEach((pct, idx) => {
console.log(dataText);
                        dataNode.data.masteryCheckpoints[idx] = getLangString('MASTERY_CHECKPOINT', `${ localID }_${ idx }`);
});
                    });
}
                }
async getDataPackage(url) {
// Based largely on Game.fetchAndRegisterDataPackage()
const headers = new Headers();
headers.append('Content-Type', 'application/json');
return await fetch(url, {
method: 'GET',
headers,
}).then(function (response) {
if (!response.ok) {
throw new Error(`Couldn't fetch data package from URL: ${url}`);
}
return response.json();
});
}
processDataPackage(dataPackage) {
// Transforms the raw data from data packages in various ways, then
// consolidates into this.packData & this.gameData
const ns = dataPackage.namespace;
const packData = dataPackage.data;


                // Import other attributes varying by skill
this.transformDataPackage(dataPackage);
                let importKeys = [];
this.packData[dataPackage.namespace] = dataPackage;
                switch(dataNode.skillID) {
this.registerDataPackage(dataPackage.namespace);
                    case 'melvorD:Firemaking':
}
                        importKeys = [
transformDataPackage(dataPackage) {
                            'baseAshChance',
// Takes a raw data package and performs various manipulations
                            'baseStardustChance',
const ns = dataPackage.namespace;
                            'baseCharcoalChance'
const packData = dataPackage.data;
                        ];
                        break;
                    case 'melvorD:Mining':
                        importKeys = [
                            'baseInterval',
                            'baseRockHP',
                            'passiveRegenInterval'
                        ];
                        dataNode.baseGemChance = 1;
                        break;
                    case 'melvorD:Smithing':
                    case 'melvorD:Fletching':
                    case 'melvorD:Crafting':
                    case 'melvorD:Runecrafting':
                    case 'melvorD:Herblore':
                        importKeys = [
                            'baseInterval'
                        ];
                        break;
                    case 'melvorD:Thieving':
                        importKeys = [
                            'baseInterval',
                            'baseStunInterval',
                            'itemChance',
                            'baseAreaUniqueChance'
                        ];
                        break;
                    case 'melvorD:Agility':
                        importKeys = [
                            'obstacleUnlockLevels'
                        ];
                        break;
                    case 'melvorD:Summoning':
                        importKeys = [
                            'baseInterval'
                        ];
                        const sumKeys = [
                            'recipeGPCost',
                            'markLevels' 
                        ];
                        sumKeys.forEach((k) => dataNode.data[k] = Summoning[k]);
                        break;
                    case 'melvorD:Astrology':
                        // Astrology has a number of values stored outside of gameSkill
                        const astKeys = [
                            'standardModifierLevels',
                            'uniqueModifierLevels',
                            'standardModifierCosts',
                            'uniqueModifierCosts',
                            'baseStardustChance',
                            'baseGoldenStardustChance',
                            'baseInterval'
                        ];
                        astKeys.forEach((k) => dataNode.data[k] = Astrology[k]);
                        break;
                    case 'melvorD:Township':
                        // Remap a number of keys from their in-game names
                        const townKeys = [
                            {'from': 'TICK_LENGTH', 'to': 'tickLength'},
                            {'from': 'MAX_TOWN_SIZE', 'to': 'maxTownSize'},
                            {'from': 'SECTION_SIZE', 'to': 'sectionSize'},
                            {'from': 'INITIAL_CITIZEN_COUNT', 'to': 'initialCitizenCount'},
                            {'from': 'MIN_WORKER_AGE', 'to': 'minWorkerAge'},
                            {'from': 'MAX_WORKER_AGE', 'to': 'maxWorkerAge'},
                            {'from': 'AGE_OF_DEATH', 'to': 'ageOfDeath'},
                            {'from': 'MIN_MIGRATION_AGE', 'to': 'minMigrationAge'},
                            {'from': 'MAX_MIGRATION_AGE', 'to': 'maxMigrationAge'},
                            {'from': 'BASE_TAX_RATE', 'to': 'baseTaxRate'},
                            {'from': 'EDUCATION_PER_CITIZEN', 'to': 'educationPerCitizen'},
                            {'from': 'HAPPINESS_PER_CITIZEN', 'to': 'happinessPerCitizen'},
                            {'from': 'CITIZEN_FOOD_USAGE', 'to': 'citizenFoodUsage'},
                            {'from': 'POPULATION_REQUIRED_FOR_BIRTH', 'to': 'populationRequiredForBirth'},
                            {'from': 'BASE_STORAGE', 'to': 'baseStorage'},
                            {'from': 'WORSHIP_CHECKPOINTS', 'to': 'worshipCheckpoints'},
                            {'from': 'MAX_WORSHIP', 'to': 'maxWorship'},
                            {'from': 'populationForTier', 'to': 'populationForTier'},
                            {'from': 'MAX_TRADER_STOCK_INCREASE', 'to': 'maxTraderStockIncrease'},
                        ];
                        townKeys.forEach((k) => dataNode.data[k.to] = gameSkill[k.from]);
                        break;
                }
                if (importKeys.length > 0) {
                    importKeys.forEach((k) => dataNode.data[k] = gameSkill[k]);
                }
            }
            this.skillDataInit[dataNode.skillID] = true;
        }
    }
    registerDataPackage(namespace) {
        // Consolidates the data package identified by namespace with existing data within
        // this.gameData
        const packData = this.packData[namespace].data;
        if (packData === undefined) {
            throw new Error(`Couldn't find data for package ${ namespace }`);
        }
        // Add data within the game but outside of data packs
        this.registerNonPackData();
        // Consolidate data
        Object.keys(packData).forEach((categoryName) => {
            let categoryData = packData[categoryName];
            // Some data is adjusted before combining - do this here
            if (['combatAreas', 'dungeons', 'slayerAreas'].includes(categoryName)) {
                // Add area type to each area object
                const areaTypes = {
                    'combatAreas': 'combatArea',
                    'dungeons': 'dungeon',
                    'slayerAreas': 'slayerArea'
                }
                const areaType = areaTypes[categoryName];
                const newData = structuredClone(categoryData);
                newData.forEach((x) => x.type = areaType);
                categoryData = newData;
            }
            else if (['ancientSpells', 'archaicSpells', 'auroraSpells', 'curseSpells', 'standardSpells'].includes(categoryName)) {
                // For spell books, add the spell type to each spell object.
                // Alt Magic spells are handled elsewhere, as they are within a skill object
                const spellType = categoryName.replace('Spells', '');
                const newData = structuredClone(categoryData);
                newData.forEach((x) => x.spellBook = spellType);
                categoryData = newData;
            }
            else if (categoryName === 'golbinRaid') {


            }
Object.keys(packData)
            // Data must be pushed into the consoldiated data, rules for vary
.filter((categoryName) => !this.excludedCategories.includes(categoryName))
            // depending on the category in question
.forEach((categoryName) => {
            switch(categoryName) {
this.transformDataNode(ns, categoryName, packData, categoryName);
                case 'ancientSpells':
});
                case 'archaicSpells':
}
                case 'attackStyles':
transformDataNode(ns, categoryName, parentNode, nodeKey) {
                case 'attacks':
let dataNode = parentNode[nodeKey];
                case 'auroraSpells':
const transformedValue = this.transformProperty(categoryName, dataNode, nodeKey, ns);
                case 'combatAreas':
if (transformedValue !== undefined) {
                case 'combatEvents':
// A transformed value exists for this node
                case 'combatPassives':
parentNode[nodeKey] = transformedValue;
                case 'curseSpells':
dataNode = parentNode[nodeKey];
                case 'dungeons':
}
                case 'gamemodes':
if (Array.isArray(dataNode)) {
                case 'itemEffects':
// Recursive call to ensure all data is transformed, regardless of its depth
                case 'itemSynergies':
dataNode.forEach((entity, idx) => this.transformDataNode(ns, categoryName, dataNode, idx));
                case 'itemUpgrades':
} else if (typeof dataNode === 'object' && dataNode !== null) {
                case 'itmMonsters':
// Iterate properties of object, checking if each should be deleted or transformed
                case 'items':
Object.keys(dataNode).forEach((key) => {
                case 'lore':
// Check if property is to be deleted or not
                case 'monsters':
if (this.isPropertyFiltered(categoryName, dataNode, key)) {
                case 'pages':
delete dataNode[key];
                case 'pets':
} else if (typeof dataNode[key] === 'object' && dataNode[key] !== null) {
                case 'prayers':
// If an object (either an array or key/value store) is within the current
                case 'randomGems':
// object then we must traverse this too
                case 'randomSuperiorGems':
this.transformDataNode(ns, categoryName, dataNode, key);
                case 'shopCategories':
} else {
                case 'shopPurchases':
// Transform property, if a transformation is defined below
                case 'shopUpgradeChains':
switch (key) {
                case 'slayerAreas':
case 'id':
                case 'stackingEffects':
// Add namespace to ID if it isn't already
                case 'standardSpells':
const id = dataNode[key];
                case 'steamAchievements':
if (!Number.isInteger(id)) dataNode[key] = this.getNamespacedID(ns, dataNode[key]);
                case 'tutorialStages':
break;
                case 'spiderLairMonsters':
}
                    // Plain old push to the end of the array
}
                    if (this.gameData[categoryName] === undefined) {
});
                        // Category doesn't exist yet in consolidated data, so create it
}
                        this.gameData[categoryName] = categoryData;
// Apply localization, except for if this is skill data. That is handled separately below
                    }
if (categoryName !== 'skillData' && categoryName == nodeKey) {
                    else {
this.langApply(parentNode, nodeKey, false);
                        this.gameData[categoryName].push(...categoryData);
}
                    }
 
                    break;
// Special case for skillData so that certain values initialized when the various Skill
                case 'combatAreaDisplayOrder':
// classes are initialized may be added here also
                case 'dungeonDisplayOrder':
if (categoryName === 'skillData' && dataNode.skillID !== undefined && dataNode.data !== undefined) {
                case 'shopCategoryOrder':
// We are currently at the topmost level of a skill object
                case 'shopDisplayOrder':
const gameSkill = game.skills.getObjectByID(dataNode.skillID);
                case 'slayerAreaDisplayOrder':
// For every skill with mastery, add mastery checkpoint descriptions
                case 'tutorialStageOrder':
if (
                    // Elements are inserted at a particular index, controlled by rules
gameSkill instanceof SkillWithMastery &&
                    // specified within the data package
dataNode.data.masteryTokenID !== undefined &&
dataNode.data.masteryCheckpoints === undefined
) {
const localID = this.getLocalID(dataNode.skillID);
dataNode.data.baseMasteryPoolCap = gameSkill.baseMasteryPoolCap;
dataNode.data.masteryCheckpoints = [];
masteryCheckpoints.forEach((pct, idx) => {
dataNode.data.masteryCheckpoints[idx] = this.getLangString('MASTERY_CHECKPOINT', `${localID}_${idx}`);
});
}
if (!this.skillDataInit[dataNode.skillID]) {
if (gameSkill !== undefined) {
// Import other attributes varying by skill
let importKeys = [];
switch (dataNode.skillID) {
case 'melvorD:Mining':
importKeys = ['baseInterval', 'baseRockHP', 'passiveRegenInterval'];
dataNode.data.baseGemChance = 1;
dataNode.data.rockTypes = loadedLangJson.MINING_TYPE;
break;
case 'melvorItA:Harvesting':
importKeys = [
'baseInterval',
'baseVeinIntensity',
'passiveRegenInterval',
'uniqueProductChance',
'hpCheckpoints',
];
break;
case 'melvorD:Smithing':
case 'melvorD:Fletching':
case 'melvorD:Crafting':
case 'melvorD:Runecrafting':
case 'melvorD:Herblore':
importKeys = ['baseInterval'];
break;
case 'melvorD:Thieving':
importKeys = ['baseInterval', 'baseStunInterval', 'itemChance', 'baseAreaUniqueChance'];
break;
case 'melvorD:Summoning':
importKeys = ['baseInterval'];
const sumKeys = ['recipeAPCost', 'recipeGPCost', 'markLevels'];
sumKeys.forEach((k) => (dataNode.data[k] = Summoning[k]));
break;
case 'melvorD:Astrology':
// Astrology has a number of values stored outside of gameSkill
const astKeys = [
'standardModifierLevels',
'uniqueModifierLevels',
'abyssalModifierLevels',
'baseInterval',
];
astKeys.forEach((k) => (dataNode.data[k] = Astrology[k]));
break;
case 'melvorD:Township':
// Remap a number of keys from their in-game names
const townKeys = [
{ from: 'BASE_STORAGE', to: 'baseStorage' },
{ from: 'BASE_TAX_RATE', to: 'baseTaxRate' },
{ from: 'DECREASED_BUILDING_COST_CAP', to: 'decreasedBuildingCostCap' },
{ from: 'GP_PER_CITIZEN', to: 'gpPerCitizen' },
{ from: 'MAX_WORSHIP', to: 'maxWorship' },
{ from: 'MINIMUM_HEALTH', to: 'minimumHealth' },
{ from: 'populationForTier', to: 'populationForTier' },
{ from: 'TICK_LENGTH', to: 'tickLength' },
{ from: 'RARE_SEASON_CHANCE', to: 'rareSeasonChance' },
{ from: 'WORSHIP_CHANGE_COST', to: 'worshipChangeCost' },
{ from: 'WORSHIP_CHECKPOINTS', to: 'worshipCheckpoints' },
{ from: 'BASE_MAX_HEALTH', to: 'baseMaxHealth' },
{ from: 'abyssalTierRequirements', to: 'abyssalTierRequirements' },
{ from: 'BASE_SOUL_STORAGE', to: 'baseSoulStorage' },
];
townKeys.forEach((k) => (dataNode.data[k.to] = gameSkill[k.from]));
// Add task categories & localization of name
const taskCategories = Array.from(new Set(gameSkill.tasks.tasks.allObjects.map((t) => t.category)));
dataNode.data.taskCategories = taskCategories.map((category) => ({
id: category.id,
name: category.name,
}));
break;
}
if (importKeys.length > 0) {
importKeys.forEach((k) => (dataNode.data[k] = gameSkill[k]));
}
}
this.skillDataInit[dataNode.skillID] = true;
}
// Appy localization (skills)
this.langApply(parentNode, nodeKey, true);
}
}
registerPackData(packData) {
Object.keys(packData)
.filter((categoryName) => !this.excludedCategories.includes(categoryName))
.forEach((categoryName) => {
let categoryData = packData[categoryName];
// Some data is adjusted before combining - do this here
if (['combatAreas', 'dungeons', 'slayerAreas', 'abyssDepths', 'strongholds'].includes(categoryName)) {
// Add area type to each area object
const areaTypes = {
combatAreas: 'combatArea',
dungeons: 'dungeon',
slayerAreas: 'slayerArea',
strongholds: 'stronghold',
abyssDepths: 'abyssDepth',
};
const areaType = areaTypes[categoryName];
const newData = structuredClone(categoryData);
newData.forEach((x) => (x.type = areaType));
categoryData = newData;
}
else if (categoryName === 'golbinRaid') {
}
// Data must be pushed into the consoldiated data, rules for vary
// depending on the category in question
switch (categoryName) {
case 'realms':
case 'attackSpellbooks':
case 'damageTypes':
case 'equipmentSlots':
case 'combatAreaCategories':
case 'combatEffects':
case 'combatEffectGroups':
case 'combatEffectTables':
case 'combatEffectTemplates':
case 'combatTriangleSets':
case 'masterPoolBonuses':
case 'masteryLevelUnlocks':
case 'masteryLevelBonuses':
case 'masterPoolBonuses':
case 'ancientRelics':
case 'attackSpells':
case 'attackStyles':
case 'attacks':
case 'auroraSpells':
case 'combatAreas':
case 'combatEvents':
case 'combatPassives':
case 'curseSpells':
case 'dungeons':
case 'strongholds':
case 'abyssDepths':
case 'gamemodes':
case 'itemEffects':
case 'itemSynergies':
case 'itemUpgrades':
case 'itmMonsters':
case 'items':
case 'lore':
case 'modifiers':
case 'monsters':
case 'pages':
case 'pets':
case 'prayers':
case 'randomGems':
case 'randomSuperiorGems':
case 'randomAbyssalGems':
case 'randomFragments':
case 'randomFiremakingOils':
case 'shopCategories':
case 'shopPurchases':
case 'shopUpgradeChains':
case 'skillLevelCapIncreases':
case 'slayerAreas':
case 'slayerTaskCategories':
case 'steamAchievements':
case 'tutorialStages':
case 'spiderLairMonsters':
// Plain old push to the end of the array
if (this.gameData[categoryName] === undefined) {
// Category doesn't exist yet in consolidated data, so create it
this.gameData[categoryName] = categoryData;
} else {
this.gameData[categoryName].push(...categoryData);
}
break;
case 'ancientRelicsDisplayOrder':
case 'bankSortOrder':
case 'combatAreaCategoryOrder':
case 'combatAreaDisplayOrder':
case 'dungeonDisplayOrder':
case 'shopCategoryOrder':
case 'shopDisplayOrder':
case 'skillTreesDisplayOrder':
case 'slayerAreaDisplayOrder':
case 'tutorialStageOrder':
// Elements are inserted at a particular index, controlled by rules
// specified within the data package
this.gameData[categoryName] = this.combineOrderedData(this.gameData[categoryName], categoryData);
this.gameData[categoryName] = this.combineOrderedData(this.gameData[categoryName], categoryData);
                    break;
break;
                case 'golbinRaid':
case 'golbinRaid':
                    // Properties contain unordered arrays that need to be combined
// Properties contain unordered arrays that need to be combined
                    if (this.gameData[categoryName] === undefined) {
if (this.gameData[categoryName] === undefined) {
                        this.gameData[categoryName] = categoryData;
this.gameData[categoryName] = categoryData;
                        this.gameData.golbinRaid.possibleModifiers = RaidManager.possibleModifiers;
this.gameData.golbinRaid.possibleModifiers = RaidManager.possibleModifiers;
                    }
} else {
                    else {
Object.keys(categoryData).forEach((dataKey) => {
                        Object.keys(categoryData).forEach((dataKey) => {
if (
                            if ((this.gameData[categoryName][dataKey] === undefined) || !Array.isArray(this.gameData[categoryName][dataKey])) {
this.gameData[categoryName][dataKey] === undefined ||
                                // Property is undefined or isn't an array
!Array.isArray(this.gameData[categoryName][dataKey])
                                this.gameData[categoryName][dataKey] = categoryData[dataKey];
) {
                            }  
// Property is undefined or isn't an array
                            else {
this.gameData[categoryName][dataKey] = categoryData[dataKey];
                                // Property is an array
} else {
                                this.gameData[categoryName][dataKey].push(...categoryData[dataKey]);
// Property is an array
                            }
this.gameData[categoryName][dataKey].push(...categoryData[dataKey]);
                        });
}
                    }
});
                    break;
}
                case 'skillData':
break;
                    // Contains nested objects
case 'skillData':
                    if (this.gameData[categoryName] === undefined) {
// Contains nested objects
                        this.gameData[categoryName] = [];
if (this.gameData[categoryName] === undefined) {
                    }
this.gameData[categoryName] = [];
}
// Find the appropriate skill object and combine properties with that
// Find the appropriate skill object and combine properties with that
categoryData.forEach((skillData) => {
categoryData.forEach((skillData) => {
Line 492: Line 556:
const skillObj = this.gameData[categoryName][skillIdx].data;
const skillObj = this.gameData[categoryName][skillIdx].data;
Object.keys(skillData.data).forEach((dataKey) => {
Object.keys(skillData.data).forEach((dataKey) => {
if (Array.isArray(skillData.data[dataKey]) && skillData.data[dataKey].length > 0 && skillData.data[dataKey][0].insertAt !== undefined) {
// Special case for Township item conversions
//Data is ordered, special handling applies
if (
skillObj[dataKey] !== undefined &&
skillData.skillID === 'melvorD:Township' &&
dataKey === 'itemConversions'
) {
Object.keys(skillData.data[dataKey]).forEach((convKey) => {
skillData.data[dataKey][convKey].forEach((resource) => {
// Find the resource if it already exists within the combined data
const resourceIdx = skillObj[dataKey][convKey].findIndex(
(res) => res.resourceID === resource.resourceID
);
if (resourceIdx === -1) {
skillObj[dataKey][convKey].push(resource);
} else {
skillObj[dataKey][convKey][resourceIdx].items.push(...resource.items);
}
});
});
} else if (
Array.isArray(skillData.data[dataKey]) &&
skillData.data[dataKey].length > 0 &&
skillData.data[dataKey][0].insertAt !== undefined
) {
// Data is ordered, special handling applies
skillObj[dataKey] = this.combineOrderedData(skillObj[dataKey], skillData.data[dataKey]);
skillObj[dataKey] = this.combineOrderedData(skillObj[dataKey], skillData.data[dataKey]);
} else if (skillObj[dataKey] === undefined || !Array.isArray(skillObj[dataKey])) {
// Property is undefined or isn't an array
skillObj[dataKey] = skillData.data[dataKey];
} else {
// Property is an array
skillObj[dataKey].push(...skillData.data[dataKey]);
}
});
});
break;
default:
console.warn(`Skipping unknown category while registering data package: ${categoryName}`);
break;
}
});
}
registerDataPackage(namespace) {
// Consolidates the data package identified by namespace with existing data within
// this.gameData
const packData = this.packData[namespace].data;
if (packData === undefined) {
throw new Error(`Couldn't find data for package ${namespace}`);
}
// Add data within the game but outside of data packs
this.registerNonPackData();
// Consolidate data
this.registerPackData(packData);
// If the data package contains modifications, apply these also
const modificationData = this.packData[namespace].modifications;
if (modificationData !== undefined) {
this.applyDataModifications(modificationData);
}
// Dependent data is handled later, once all packages have been registered
if (!this.registeredNamespaces.includes(namespace)) {
this.registeredNamespaces.push(namespace);
}
}
processDependentData() {
Object.entries(this.packData)
.forEach(([namespace, packData]) => {
if (packData.dependentData !== undefined) {
packData.dependentData.forEach((depDataForNS) => {
const depNS = depDataForNS.namespace;
if (!this.registeredNamespaces.includes(depNS)) {
console.warn(
`Could not apply dependent data from package ${namespace}: Data depends on namespace ${depNS}, which has not been registered`
);
}
else {
console.log(`Attempting to apply dependent data for ${depNS} from package ${namespace}`);
if (depDataForNS.data !== undefined) {
this.registerPackData(depDataForNS.data)
}
if (depDataForNS.modifications !== undefined) {
this.applyDataModifications(depDataForNS.modifications);
}
}
});
}
});
}
getDataToModify(modCat) {
switch (modCat) {
case 'combatAreaCategories':
case 'damageTypes':
case 'dungeons':
case 'equipmentSlots':
case 'gamemodes':
case 'items':
case 'modifiers':
case 'pets':
case 'shopUpgradeChains':
case 'shopPurchases':
case 'skillData':
case 'slayerAreas':
return this.gameData[modCat];
case 'cookingCategories':
const cookingSkill = this.getObjectByID(this.gameData.skillData, 'melvorD:Cooking', 'skillID');
return cookingSkill.data.categories;
case 'fletchingRecipes':
const fletchingSkill = this.getObjectByID(this.gameData.skillData, 'melvorD:Fletching', 'skillID');
return fletchingSkill.data.recipes;
}
return undefined;
}
applyModifierModifications(objToModify, adjustments) {
if (objToModify.modifiers === undefined) {
objToModify.modifiers = {};
}
Object.keys(adjustments)
.forEach((adjType) => {
if (adjType === 'add') {
Object.entries(adjustments[adjType])
.forEach(([chgKey, chgVal]) => {
if (objToModify.modifiers[chgKey] === undefined) {
objToModify.modifiers[chgKey] = chgVal;
}
}
else if ((skillObj[dataKey] === undefined) || !Array.isArray(skillObj[dataKey])) {
else if (Array.isArray(chgVal)) {
// Property is undefined or isn't an array
objToModify.modifiers[chgKey].push(...chgVal);
skillObj[dataKey] = skillData.data[dataKey];
}
}
else {
else {
// Property is an array
objToModify.modifiers[chgKey] += chgVal;
skillObj[dataKey].push(...skillData.data[dataKey]);
}
}
});
});
});
}
                    break;
else {
                default:
console.warn(
                    console.warn(`Skipping unknown category while registering data package: ${ categoryName }`);
`Could not apply data modification: Unhandled modifier adjustment "${adjType}"`
                    break;
);
            }
}
        });
}
    }
);
    registerNonPackData() {
}
        // Some data resides outside of packages. Add any such data to this.gameData within this function
applyAddRemoveModifications(objToModify, adjustments, modifyKey) {
        if (this.gameData.namespaces === undefined) {
if (adjustments.remove !== undefined && Array.isArray(objToModify[modifyKey])) {
            const nsData = [];
// adjustments.remove is an array of requirement types to be removed
            game.registeredNamespaces.forEach((ns) => {
let i = 0;
                if (ns.isModded) {
while (i < objToModify[modifyKey].length) {
                    throw new Error(`Modded namespace '${ ns.displayName }' found, all mods must be disabled before game data can be generated`);
if (adjustments.remove.includes(objToModify[modifyKey][i].type)) {
                }
objToModify[modifyKey].splice(i, 1);
                else {
}
                    nsData.push(ns);
else {
                }
i++;
            });
}
            this.gameData.namespaces = nsData;
}
        }
}
        if (this.gameData.combatTriangles === undefined) {
if (adjustments.add !== undefined) {
            const ctData = [];
if (objToModify[modifyKey] === undefined) {
            Object.keys(COMBAT_TRIANGLE_IDS).forEach((id) => {
objToModify[modifyKey] = adjustments.add;
                const newObj = structuredClone(combatTriangle[COMBAT_TRIANGLE_IDS[id]]);
}
                newObj.id = id;
else {
                ctData.push(newObj);
objToModify[modifyKey].push(...adjustments.add);
            });
}
            this.gameData.combatTriangles = ctData;
}
        }
}
        if (this.gameData.masteryCheckpoints === undefined) {
applyGamemodeSpecificModifications(objToModify, adjustments, newProperty) {
            this.gameData.masteryCheckpoints = masteryCheckpoints;
const gamemodeID = adjustments.gamemodeID;
        }
if (objToModify.gamemodeOverrides === undefined) {
        if (this.gameData.combatAreaDifficulties === undefined) {
objToModify.gamemodeOverrides = [];
            this.gameData.combatAreaDifficulties = CombatAreaMenu.difficulty.map((i) => i.name);
}
        }
let gamemodeEntryToModify = this.getObjectByID(objToModify.gamemodeOverrides, gamemodeID, 'gamemodeID');
        if (this.gameData.equipmentSlots === undefined) {
if (gamemodeEntryToModify === undefined) {
            this.gameData.equipmentSlots = EquipmentSlots;
// Initialize gamemode overrides
        }
objToModify.gamemodeOverrides.push({
        if (this.gameData.attackTypes === undefined) {
gamemodeID: gamemodeID
            this.gameData.attackTypes = AttackTypeID;
});
        }  
gamemodeEntryToModify = this.getObjectByID(objToModify.gamemodeOverrides, gamemodeID, 'gamemodeID');
        if (this.gameData.slayerTiers === undefined) {
}
            const newData = structuredClone(SlayerTask.data)
if (gamemodeEntryToModify[newProperty] === undefined) {
            newData.forEach((tier) => delete tier.engDisplay);
gamemodeEntryToModify[newProperty] = structuredClone(objToModify[newProperty]) ?? {};
            this.gameData.slayerTiers = newData;
}
        }
this.applyAddRemoveModifications(gamemodeEntryToModify, adjustments, newProperty);
    }
}
applyDataModifications(modData) {
const modDataKeys = Object.keys(modData).filter((modCatID) => !this.excludedCategories.includes(modCatID));
for (const modCatID in modDataKeys) {
const modCat = modDataKeys[modCatID];
const catData = modData[modCat];
const dataToModify = this.getDataToModify(modCat);
const modObjIDKey = (modCat === 'skillData' ? 'skillID' : 'id');
if (dataToModify === undefined) {
console.warn(
`Could not apply data modification for category "${modCat}": Unable to retrieve category data to be modified`
);
}
else {
catData.forEach((modItem) => {
const modObjID = modItem[modObjIDKey];
if (modObjID === undefined) {
console.warn(
`Could not apply data modification for category "${modCat}": ID of object to be modified not found`
);
} else {
const objToModify = this.getObjectByID(dataToModify, modObjID, modObjIDKey);
if (objToModify === undefined) {
console.warn(
`Could not apply data modification: Object with ID "${modObjID}" not found for ctaegory "${modCat}"`
);
}
else {
switch (modCat) {
case 'combatAreaCategories':
// The 'areas' property of elements within the category data are ordered data
objToModify.areas = this.combineOrderedData(objToModify.areas, modItem.areas.add);
break;
case 'damageTypes':
Object.entries(modItem)
.filter(([k, v]) => k !== 'id')
.forEach(([k, v]) => {
if (typeof v === 'object' && (v.add !== undefined || v.remove !== undefined)) {
this.applyAddRemoveModifications(objToModify, v, k);
}
else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
});
break;
case 'gamemodes':
Object.entries(modItem)
.filter(([k, v]) => k !== 'id')
.forEach(([k, v]) => {
if (typeof v === 'object' && (v.add !== undefined || v.remove !== undefined)) {
this.applyAddRemoveModifications(objToModify, v, k);
}
else if (['abyssalLevelCapCost', 'post99RollConversion'].includes(k)) {
objToModify[k] = v;
}
else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
});
break;
case 'shopPurchases':
case 'shopUpgradeChains':
// Modify the root upgrade ID of shop upgrade chains, and modify attributes of shop purchases
const overrideKeys = {
purchaseRequirements: {
sourceKey: 'newRequirements', // Key that holds the data in the data package
destKey: 'purchaseRequirementsOverrides', // Key to insert into within this.gameData
subKey: 'requirements', // Sub-key containing the override data
},
cost: {
sourceKey: 'newCosts',
destKey: 'costOverrides',
subKey: 'cost',
},
};
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
const overrideKey = overrideKeys[k];
if (overrideKey !== undefined) {
// Is an override specific to a gamemode, do not replace
// the key's existing data
const destKey = overrideKey.destKey;
if (objToModify[destKey] === undefined) {
objToModify[destKey] = [];
}
modItem[k].forEach((gamemodeOverride) => {
var newData = {};
newData.gamemodeID = gamemodeOverride.gamemodeID;
newData[overrideKey.subKey] = gamemodeOverride[overrideKey.sourceKey];
objToModify[destKey].push(newData);
});
} else {
objToModify[k] = modItem[k];
}
});
break;
case 'cookingCategories':
// Append to the list of shop upgrade IDs for cooking utilities/categories
case 'fletchingRecipes':
// Append to alternativeCosts property of recipes (e.g. Arrow shafts)
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
if ((k === 'shopUpgradeIDs') || (k === 'alternativeCosts')) {
if (objToModify[k] === undefined) {
objToModify[k] = modItem[k];
} else {
objToModify[k].push(...modItem[k]);
}
} else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
});
break;
case 'skillData':
Object.entries(modItem.data)
.forEach(([skillProp, propModData]) => {
propModData.forEach((subModItem) => {
const subObjToModify = this.getObjectByID(objToModify.data[skillProp], subModItem.id);
if (subObjToModify === undefined) {
console.warn(`Couldn't find skill object with ID ${subModItem.id} to modify. Property ${skillProp} in skill ID ${objToModify.skillID}`);
}
else {
Object.entries(subModItem)
.forEach(([subProp, subData]) => {
if (subProp === 'modifiers') {
this.applyModifierModifications(subObjToModify, subData);
}
else if (subProp !== 'id') {
this.applyAddRemoveModifications(subObjToModify, subData, subProp);
}
});
}
});
});
break;
case 'dungeons':
// Add gamemode specific data to dungeons
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
if (k === 'gamemodeRewardItemIDs') {
// Add gamemode specific item rewards to dungeon data
const itemRules = modItem[k];
Object.keys(itemRules).forEach((ruleKey) => {
if (ruleKey === 'add') {
itemRules[ruleKey].forEach((itemDef) => {
const modToApply = {
gamemodeID: itemDef.gamemodeID,
add: itemDef.rewardItemIDs
}
this.applyGamemodeSpecificModifications(objToModify, modToApply, 'rewardItemIDs');
});
} else {
console.warn(
`Could not apply data modification: Unknown rule for gamemode item rewards: "${ruleKey}", object "${modObjID}"`
);
}
});
} else if (k === 'gamemodeEntryRequirements') {
// Add or remove gamemode specific entry requirements to dungeon data
this.applyGamemodeSpecificModifications(objToModify, modItem[k], 'entryRequirements');
} else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
});
break;
case 'modifiers':
// Add modifier aliases to existing mod scopes
if (objToModify.allowedScopes === undefined) {
console.warn(`Could not apply data modification: Modifier with ID ${modObjID} not found or modifier has no scopes`);
} else {
modItem.allowedScopes.forEach((srcScope) => {
// Find scope within modifier objToModify with matching scopes definition
const srcScopeKeys = Object.keys(srcScope.scopes);
objToModify.allowedScopes.forEach((destScope) => {
const destScopeKeys = Object.keys(destScope.scopes);
const scopeMatch = (
srcScopeKeys.length === destScopeKeys.length
&& srcScopeKeys.every((k) => destScope.scopes[k] !== undefined && srcScope.scopes[k] == destScope.scopes[k])
);
if (scopeMatch) {
// Scopes match - add aliases to modifier allowedScope definition
const aliasKeys = ['posAliases', 'negAliases'];
aliasKeys.forEach((aliasKey) => {
if (srcScope[aliasKey] !== undefined) {
if (destScope[aliasKey] === undefined) {
destScope[aliasKey] = [];
}
destScope[aliasKey].push(...srcScope[aliasKey]);
}
});
}
});
});
}
break;
case 'items':
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
if (k === 'modifiers') {
this.applyModifierModifications(objToModify, modItem[k]);
}
else if (k === 'consumesOn') {
Object.keys(modItem[k])
.forEach((adjType) => {
if (adjType === 'add') {
if (objToModify[k] === undefined) {
objToModify[k] = modItem[k][adjType];
}
else {
objToModify[k].push(...modItem[k][adjType]);
}
}
else {
console.warn(
`Could not apply data modification: Unhandled adjustment type "${adjType}" for category "${modCat}", object "${modObjID}, property ${k}"`
);
}
});
}
else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
}
);
break;
case 'pets':
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
if (k === 'modifiers') {
this.applyModifierModifications(objToModify, modItem[k]);
}
else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
}
);
break;
case 'equipmentSlots':
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
if (k === 'requirements') {
this.applyAddRemoveModifications(objToModify, modItem[k], 'requirements');
}
else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
}
);
break;
case 'slayerAreas':
Object.keys(modItem)
.filter((k) => k !== 'id')
.forEach((k) => {
if (k === 'gamemodeEntryRequirements') {
this.applyGamemodeSpecificModifications(objToModify, modItem[k], 'entryRequirements');
}
else {
console.warn(
`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
);
}
}
);
break;
default:
console.warn(
`Could not apply data modification: Unhandled category "${modCat}"`
);
}
}
}
});
}
}
}
registerNonPackData() {
// Some data resides outside of packages. Add any such data to this.gameData within this function
// Metadata for data/file version
if (this.gameData._dataVersion === undefined) {
this.gameData._dataVersion = ({
gameVersion: this.getGameVersion().substring(1),
fileVersion: this.getGameFileVersion().substring(1)
});
}
// Namespaces
if (this.gameData.namespaces === undefined) {
const nsData = [];
game.registeredNamespaces.forEach((ns) => {
if (ns.isModded) {
throw new Error(
`Modded namespace '${ns.displayName}' found, all mods must be disabled before game data can be generated`
);
} else {
nsData.push(ns);
}
});
this.gameData.namespaces = nsData;
}
if (this.gameData.currencies === undefined) {
this.gameData.currencies = game.currencies.allObjects.map((c) => ({
id: c.id,
name: c.name,
type: c.type
}));
}
// Melvor realm exists outside of data packages
if (this.gameData.realms === undefined) {
this.gameData.realms = game.realms
.filter((r) => r.id === 'melvorD:Melvor')
.map((r) => ({
id: r.id,
name: r.name,
unlockRequirements: r.unlockRequirements
}));
}
// Normal damage type exists outside of data packages
if (this.gameData.damageTypes === undefined) {
this.gameData.damageTypes =  game.damageTypes
.filter((d) => d.id === 'melvorD:Normal')
.map((d) => ({
id: d.id,
name: d.name,
resistanceCap: d._resistanceCap,
resistanceName: d.resistanceName
}));
}
if (this.gameData.combatAreaDifficulties === undefined) {
this.gameData.combatAreaDifficulties = CombatAreaMenuElement.difficulty.map((i) => i.name);
}
if (this.gameData.attackTypes === undefined) {
this.gameData.attackTypes = AttackTypeID;
}
}
combineOrderedData(existingData, newData) {
combineOrderedData(existingData, newData) {
// Elements are inserted at a particular index, controlled by rules
// Elements are inserted at a particular index, controlled by rules
Line 560: Line 1,094:
if (existingData === undefined) {
if (existingData === undefined) {
resultData = [];
resultData = [];
}
} else {
else {
resultData = structuredClone(existingData);
resultData = structuredClone(existingData);
}
}
newData.forEach((orderData) => {
newData.forEach((orderData) => {
switch(orderData.insertAt) {
switch (orderData.insertAt) {
case 'Start':
case 'Start':
resultData.splice(0, 0, ...orderData.ids);
resultData.splice(0, 0, ...orderData.ids);
Line 575: Line 1,108:
const beforeIdx = resultData.findIndex((item) => item === orderData.beforeID);
const beforeIdx = resultData.findIndex((item) => item === orderData.beforeID);
if (beforeIdx === -1) {
if (beforeIdx === -1) {
throw new Error(`Couldn't insert before: Item ${ orderData.beforeID } is not in the array.`);
throw new Error(`Couldn't insert before: Item ${orderData.beforeID} is not in the array.`);
}
}
resultData.splice(beforeIndex, 0, ...orderData.ids);
resultData.splice(beforeIdx, 0, ...orderData.ids);
break;
break;
case 'After':
case 'After':
const afterIdx = resultData.findIndex((item) => item === orderData.afterID);
const afterIdx = resultData.findIndex((item) => item === orderData.afterID);
if (afterIdx === -1) {
if (afterIdx === -1) {
throw new Error(`Couldn't insert after: Item ${ orderData.afterID } is not in the array.`);
throw new Error(`Couldn't insert after: Item ${orderData.afterID} is not in the array.`);
}
}
resultData.splice(afterIdx + 1, 0, ...orderData.ids);
resultData.splice(afterIdx + 1, 0, ...orderData.ids);
Line 590: Line 1,123:
return resultData;
return resultData;
}
}
    getNamespacedID(namespace, ID) {
// Determines if properties of entities are to be removed, as they are unused in the wiki
        if (ID.indexOf(':') > 0) {
// and would otherwise bloat the data.
            return ID;
// Returns true if the property is to be removed, false if it is to be retained
        }
isPropertyFiltered(entityType, entity, propertyName) {
        else {
switch (propertyName) {
            return namespace + ':' + ID;
case 'media':
        }
case 'altMedia':
    }
case 'markMedia':
    getLocalID(ID) {
case 'icon':
        if (ID.indexOf(':') > 0) {
case 'barStyle': // See: melvorD:Compost
            return ID.split(':').pop();
case 'buttonStyle':
        }
case 'descriptionGenerator':
        else {
case 'containerID':
            return ID;
case 'headerBgClass':
        }
case 'textClass':
    }
case 'btnClass':
return true;
case 'golbinRaidExclusive':
case 'ignoreCompletion':
case 'obtainFromItemLog':
// Property is boolean & isn't of interest when false
return !entity[propertyName];
case 'validSlots':
case 'occupiesSlots':
case 'equipRequirements':
case 'equipmentStats':
// Property is an array & isn't of interest when zero elements in length
return entity[propertyName].length === 0;
case 'tier':
if (entityType === 'items') {
return entity.tier === 'none';
} else {
return false;
}
default:
// Always retain property
return false;
}
}
// Specifies rules for transforming values of entity properties.
// Returns undefined if the property has no transformation
transformProperty(entityType, entity, propertyName, namespace) {
switch (propertyName) {
case 'langHint':
case 'langCustomDescription':
return this.getLangString(entity.category, this.getLocalID(entity.id));
case 'equipmentStats':
const newStats = {};
entity.forEach((stat) => {
let statKey = stat.key;
if (stat.damageType !== undefined) {
statKey += this.getLocalID(stat.damageType);
}
if (newStats[statKey] === undefined) {
newStats[statKey] = stat.value;
} else {
newStats[statKey] += stat.value;
}
});
return newStats;
case 'altSpells':
if (entityType !== 'skillData') {
return undefined;
} else {
const newData = structuredClone(entity);
newData.forEach((i) => {
i.spellBook = 'altMagic';
});
return newData;
}
default:
return undefined;
}
}
langApply(parentNode, nodeKey, isSkill) {
const nodeName = isSkill ? parentNode[nodeKey].skillID : nodeKey;
const altMagicDescIDKey = function (data) {
// Accepts an Alt. Magic spell object, returns the ID format for that spell
// Using a function for this as some spells (e.g. Superheat) have bespoke logic
if (data.specialCost !== undefined && data.specialCost.type !== undefined) {
if (data.id.includes('HolyInvocation')) {
return 'HOLY_INVOCATION';
}
switch (data.specialCost.type) {
case 'BarIngredientsWithCoal':
return 'SUPERHEAT';
case 'BarIngredientsWithoutCoal':
return 'SUPERHEAT_NO_COAL';
case 'AnyItem':
if (data.produces !== undefined && data.produces === 'GP') {
return 'ITEM_ALCHEMY';
}
break;
}
}
return 'ALTMAGIC_DESC_{ID}';
};
const shopChainPropKey = (data, dataKey, propName) => {
// Accepts an upgrade chain data object & key of the property being localized
const propToLang = {
chainName: 'chainNameLang',
defaultDescription: 'descriptionLang',
defaultName: 'defaultNameLang',
};
const langPropName = propToLang[dataKey];
if (langPropName !== undefined) {
const langProp = data[langPropName];
if (langProp !== undefined) {
return langProp[propName];
}
}
};
const itemDesc = (data) => {
const item = game.items.getObjectByID(data.id);
if (item !== undefined && item.hasDescription) {
return item.description;
} else return '';
};
const shopPurchaseDesc = (data) => {
const purchase = game.shop.purchases.getObjectByID(data.id);
if (purchase !== undefined) {
// Logic taken from description method of ShopPurchase class & slightly modified
// to avoid retrieving an item's modified description, which can include HTML
let desc = '';
if (purchase._customDescription !== undefined) {
if (purchase.isModded) {
return purchase._customDescription;
}
else {
return getLangString(`SHOP_DESCRIPTION_${ purchase.localID }`);
}
}
if (purchase.contains.itemCharges !== undefined) {
  return purchase.contains.itemCharges.item.description;
}
if (purchase.contains.items.length === 1) {
  return purchase.contains.items[0].item.description; // Was modifiedDescription
}
if (purchase.contains.pet !== undefined) {
  return purchase.contains.pet.description;
}
if (purchase.contains.stats !== undefined) {
  desc = purchase.contains.stats.describePlain();
}
if (purchase.hasDisabledModifier) {
desc += getLangString('MENU_TEXT_CONTAINS_DISABLED_MODIFIER');
}
return desc;
} else return '';
};
const relicDesc = (data) => {
const relic = game.ancientRelics.getObjectByID(data.id);
if (relic !== undefined) {
return relic.name;
}
};
const passiveDesc = (data) => {
const passive = game.combatPassives.getObjectByID(data.id);
if (passive !== undefined) {
return passive.description;
}
};
const spAttDesc = (data) => {
const spAtt = game.specialAttacks.getObjectByID(data.id);
if (spAtt !== undefined) {
return spAtt.description;
}
};
const tsWorshipName = (data) => {
const worship = game.township.worships.getObjectByID(data.id);
if (worship !== undefined) {
return worship.name;
}
};
const tsWorshipStatueName = (data) => {
const worship = game.township.worships.getObjectByID(data.id);
if (worship !== undefined) {
return worship.statueName;
}
};
const attackSpellbooksName = (data) => {
const book = game.attackSpellbooks.getObjectByID(data.id);
if (book !== undefined) {
return book.name;
}
};
const attackSpellName = (data) => {
const spell = game.attackSpells.getObjectByID(data.id);
if (spell !== undefined) {
return this.getLangString(`${ spell.spellbook.spellNameLangPrefix }${ spell.localID }`);
}
};
const hasNoLangData = [
// Categories that contain no localized text. Supresses warnings about no lang data
'ancientRelicsDisplayOrder',
'bankSortOrder',
'combatAreaDisplayOrder',
'combatAreaCategoryOrder',
'combatEffectTables',
'combatEffectTemplates',
'combatEvents',
'dungeonDisplayOrder',
'golbinRaid',
'itemEffects',
'itemSynergies',
'itemUpgrades',
'itmMonsters',
'modifiers', // TODO Does have lang data, supressing warning for now
'randomAbyssalGems',
'randomFiremakingOils',
'randomFragments',
'randomGems',
'randomSuperiorGems',
'slayerAreaDisplayOrder',
'slayerTaskCategories', // TODO Does have lang data, supressing warning for now
'shopCategoryOrder',
'shopDisplayOrder',
'skillLevelCapIncreases',
'skillTreesDisplayOrder',
'spiderLairMonsters',
'stackingEffects',
];
const langKeys = {
realms: {
name: { key: 'REALM', idFormat: 'NAME_{ID}' },
},
damageTypes: {
name: { idFormat: 'DAMAGE_TYPE_{ID}' },
},
combatTriangleSets: {
name: { key: 'COMBAT_TRIANGLE_NAME', idFormat: 'NAME_{ID}' },
},
attackSpellbooks: {
name: { stringSpecial: 'attackSpellbooksName' },
},
attackSpells: {
name: { stringSpecial: 'attackSpellName' },
},
ancientRelics: {
name: { stringSpecial: 'relicDesc' },
},
attackStyles: {
name: { key: 'COMBAT_MISC', idFormat: 'ATTACK_STYLE_NAME_{ID}' },
},
attacks: {
name: { key: 'SPECIAL_ATTACK_NAME' },
description: { stringSpecial: 'spAttDesc' },
},
auroraSpells: {
name: { key: 'MAGIC', idFormat: 'AURORA_NAME_{ID}' },
},
combatAreaCategories: {
name: { key: 'COMBAT_AREA_CATEGORY' }
},
combatAreas: {
name: { key: 'COMBAT_AREA', idFormat: 'NAME_{ID}' },
},
combatEffectGroups: {
name: { idKey: 'nameLang' }
},
combatEffects: {
name: { idKey: 'nameLang' }
},
combatPassives: {
name: { key: 'PASSIVES', idFormat: 'NAME_{ID}' },
customDescription: { stringSpecial: 'passiveDesc' },
//customDescription: { key: 'PASSIVES', idFormat: 'DESC_{ID}' }
},
curseSpells: {
name: { key: 'MAGIC', idFormat: 'CURSE_NAME_{ID}' },
},
dungeons: {
name: { key: 'DUNGEON', idFormat: 'NAME_{ID}' },
},
abyssDepths: {
name: { key: 'THE_ABYSS', idFormat: 'NAME_{ID}' },
},
strongholds: {
name: { idFormat: 'STRONGHOLD_NAME_{ID}' },
},
equipmentSlots: {
emptyName: { idFormat: 'EQUIP_SLOT_{ID}' }
},
gamemodes: {
name: { key: 'GAMEMODES', idFormat: 'GAMEMODE_NAME_{ID}' },
description: { key: 'GAMEMODES', idFormat: 'GAMEMODE_DESC_{ID}' },
// Gamemodes have an array of rules
rules: { key: 'GAMEMODES', idFormat: 'GAMEMODE_RULES_{ID}_{NUM}' },
},
items: {
name: { key: 'ITEM_NAME' },
customDescription: { stringSpecial: 'itemDesc', onlyIfExists: false },
},
lore: {
title: { key: 'LORE', idFormat: 'TITLE_{ID}' },
},
monsters: {
name: { key: 'MONSTER_NAME' },
description: { key: 'MONSTER_DESCRIPTION' },
},
pets: {
name: { key: 'PET_NAME' },
hint: { idKey: 'langHint' }
},
prayers: {
name: { key: 'PRAYER', idFormat: 'PRAYER_NAME_{ID}' },
},
shopCategories: {
name: { key: 'SHOP_CAT' },
},
shopPurchases: {
customName: { key: 'SHOP_NAME', onlyIfExists: true },
customDescription: { stringSpecial: 'shopPurchaseDesc', onlyIfExists: false },
},
shopUpgradeChains: {
chainName: { keySpecial: 'shopChainKey', idSpecial: 'shopChainID' },
defaultDescription: { keySpecial: 'shopChainKey', idSpecial: 'shopChainID' },
defaultName: { keySpecial: 'shopChainKey', idSpecial: 'shopChainID' },
},
slayerAreas: {
name: { key: 'SLAYER_AREA', idFormat: 'NAME_{ID}' },
areaEffectDescription: { key: 'SLAYER_AREA', idFormat: 'EFFECT_{ID}' },
},
skillData: {
// Each skill is nested within this, so follow much the same structure
// Keys here are each skill's local ID
_common: {
// Special entry, contains lang definitions which are the same
// for all skills
_root: {
name: { key: 'SKILL_NAME', idFormat: '{SKILLID}' },
},
customMilestones: {
name: { key: 'MILESTONES', idKey: 'milestoneID' },
},
masteryLevelUnlocks: {
description: { key: 'MASTERY_BONUS', idKey: 'descriptionID', idFormat: '{SKILLID}_{ID}' },
},
},
Archaeology: {
digSites: {
name: { key: 'POI_NAME_Melvor' },
},
// TODO Tool names
},
Agility: {
elitePillars: {
name: { key: 'AGILITY', idFormat: 'PILLAR_NAME_{ID}' },
},
obstacles: {
name: { key: 'AGILITY', idFormat: 'OBSTACLE_NAME_{ID}' },
},
pillars: {
name: { key: 'AGILITY', idFormat: 'PILLAR_NAME_{ID}' },
},
},
Astrology: {
recipes: {
name: { key: 'ASTROLOGY', idFormat: 'NAME_{ID}' },
},
},
Cartography: {
mapPortals: { _handler: 'mapPortals' },
travelEvents: {
description: { key: 'TRAVEL_EVENT' },
},
worldMaps: { _handler: 'cartoMaps' },
//name: { key: 'WORLD_MAP_NAME' },
//pointsOfInterest: { _handler: 'mapPOI' }
//name: { key: 'POI_NAME', idFormat: '{MAPID}_{ID}' },
//description: { key: 'POI_DESCRIPTION', idFormat: '{MAPID}_{ID}' }
},
Cooking: {
categories: {
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
}
},
Crafting: {
categories: {
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
}
},
Farming: {
categories: {
description: { key: 'SKILL_CATEGORY', idFormat: '{SKILLID}_{ID}_description' },
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'},
seedNotice: { key: 'SKILL_CATEGORY', idFormat: '{SKILLID}_{ID}_seedNotice' },
singularName: { key: 'SKILL_CATEGORY', idFormat: '{SKILLID}_{ID}_singular' },
},
},
Fletching: {
categories: {
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
}
},
Fishing: {
areas: {
name: { key: 'FISHING', idFormat: 'AREA_NAME_{ID}' },
},
},
Herblore: {
categories: {
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
},
recipes: {
name: { key: 'POTION_NAME' },
},
},
Magic: {
altSpells: {
name: { key: 'MAGIC', idFormat: 'ALTMAGIC_NAME_{ID}' },
description: { key: 'MAGIC', idSpecial: 'altMagicDesc' },
},
},
Mining: {
categories: {
name: { idFormat: 'MINING_TYPE_{ID}' }
},
rockData: {
name: { key: 'ORE_NAME' },
},
},
Runecrafting: {
categories: {
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
}
},
Summoning: {
categories: {
name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
},
synergies: {
customDescription: {
key: 'SUMMONING_SYNERGY',
idKey: 'summonIDs',
idFormat: 'DESC_{ID0}_{ID1}',
onlyIfExists: true,
},
},
},
Thieving: {
areas: {
name: { key: 'THIEVING', idFormat: 'AREA_NAME_{ID}' },
},
npcs: {
name: { key: 'THIEVING', idFormat: 'NPC_NAME_{ID}' },
},
},
Township: {
biomes: {
// Can't locate biome description localization, don't think this is exposed in game UI
name: { key: 'TOWNSHIP', idFormat: 'BIOME_{ID}' },
},
buildings: {
// Building description has no localization, as it is unused
name: { key: 'TOWNSHIP', idFormat: 'BUILDING_{ID}' },
},
jobs: {
name: { key: 'TOWNSHIP', idFormat: 'JOB_{ID}' },
},
resources: {
name: { key: 'TOWNSHIP', idFormat: 'RESOURCE_{ID}' },
},
tasks: {
// name is not exposed in game UI, and has no localization
// category is localized in transformDataNode
description: { key: 'TOWNSHIP_TASKS', idFormat: '{ID}_description' },
},
worships: {
name: { stringSpecial: 'tsWorshipName' },
statueName: { stringSpecial: 'tsWorshipStatueName' },
},
},
Woodcutting: {
trees: {
name: { key: 'TREE_NAME' },
},
},
},
};
 
// Determine which language key data applies
var langKeyData;
if (isSkill) {
// Combine common & skill specific keys
const skillKey = this.getLocalID(parentNode[nodeKey].skillID);
const langCommon = langKeys.skillData._common;
let langSkill = structuredClone(langKeys.skillData[skillKey]);
 
if (langCommon !== undefined) {
if (langSkill === undefined) {
langSkill = {};
}
Object.keys(langCommon).forEach((k) => {
if (langSkill[k] === undefined) {
langSkill[k] = {};
}
Object.keys(langCommon[k]).forEach((prop) => {
langSkill[k][prop] = langCommon[k][prop];
});
});
}
langKeyData = langSkill;
} else if (langKeys[nodeKey] !== undefined) {
langKeyData = { _root: langKeys[nodeKey] };
} else if (!hasNoLangData.includes(nodeKey)) {
console.warn('No lang key data found for ' + nodeKey);
}
 
if (langKeyData !== undefined) {
var dataToTranslate = parentNode[nodeKey];
if (isSkill) {
dataToTranslate = dataToTranslate.data;
}
if (!Array.isArray(dataToTranslate)) {
dataToTranslate = [dataToTranslate];
}
dataToTranslate.forEach((tData) => {
Object.keys(langKeyData).forEach((langKey) => {
const targetData = langKey === '_root' ? tData : tData[langKey];
if (targetData !== undefined) {
const targetArr = Array.isArray(targetData) ? targetData : [targetData];
targetArr.forEach((target) => {
const handlerFunc = langKeyData[langKey]['_handler'];
if (handlerFunc !== undefined) {
switch (handlerFunc) {
case 'mapPortals':
Object.keys(target).forEach((portalKey) => {
let portalData = target[portalKey];
const langID = this.getLocalID(portalData.originWorldMap) + '_' + this.getLocalID(portalData.id);
portalData.name = this.getLangString('POI_NAME', langID);
portalData.description = this.getLangString('POI_DESCRIPTION', langID);
});
break;
case 'cartoMaps':
// Target represents a world map
const mapID = this.getLocalID(target.id);
target.name = this.getLangString('WORLD_MAP_NAME', mapID);
// Process POIs
target.pointsOfInterest.forEach((poi) => {
const langID = mapID + '_' + this.getLocalID(poi.id);
poi.name = this.getLangString('POI_NAME', langID);
poi.description = this.getLangString('POI_DESCRIPTION', langID);
});
break;
}
} else {
Object.keys(langKeyData[langKey]).forEach((langPropID) => {
const langProp = langKeyData[langKey][langPropID];
if (!langProp.onlyIfExists || target[langPropID] !== undefined) {
const langIDKey = langProp.idKey ?? 'id';
var langIDValue;
if (Array.isArray(target[langIDKey])) {
// The ID key can sometimes be an array of IDs (e.g. Summoning synergies)
langIDValue = target[langIDKey].map((id) => this.getLocalID((id ?? '').toString()));
} else {
langIDValue = this.getLocalID((target[langIDKey] ?? '').toString());
}
let langIdent = langProp.idFormat;
if (langProp.idSpecial !== undefined) {
// Use a special method to determine the ID format
switch (langProp.idSpecial) {
case 'altMagicDesc':
langIdent = altMagicDescIDKey(target);
break;
case 'shopChainID':
langIdent = this.getLocalID(shopChainPropKey(target, langPropID, 'id'));
break;
}
}
if (langIdent === undefined) {
langIdent = langIDValue;
} else {
// langIdent is in a specific format
const langTemplate = {};
if (isSkill) {
langTemplate.SKILLID = this.getLocalID(parentNode[nodeKey].skillID);
}
if (Array.isArray(langIDValue)) {
langIDValue.forEach((val, idx) => {
langTemplate['ID' + idx] = this.getLocalID(val);
});
} else {
langTemplate.ID = langIDValue;
}
Object.keys(langTemplate).forEach((k) => {
langIdent = langIdent.replaceAll('{' + k + '}', langTemplate[k]);
});
}
 
let langCategoryKey = langProp.key;
if (langProp.keySpecial !== undefined) {
// Use a special method to determine the category key
switch (langProp.keySpecial) {
case 'shopChainKey':
langCategoryKey = shopChainPropKey(target, langPropID, 'category');
break;
}
}
 
if (Array.isArray(target[langPropID])) {
target[langPropID].forEach((targetElem, num) => {
const langIdentFinal = langIdent.replaceAll('{NUM}', num.toString());
const langString = this.getLangString(langCategoryKey, langIdentFinal);
target[langPropID][num] = langString;
if (this.debugMode) {
if (langString !== undefined) {
console.debug(
'Set value of property ' +
langPropID +
'[' +
num.toString() +
'] for ' +
langIdentFinal +
' in node ' +
nodeName +
' to: ' +
langString
);
} else {
console.debug(
'No translation: property ' +
langPropID +
' for ' +
langIdentFinal +
' in node ' +
nodeName
);
}
}
});
} else {
let langString;
if (langProp.stringSpecial !== undefined) {
// Use a custom function to determine the string
switch (langProp.stringSpecial) {
case 'itemDesc':
langString = itemDesc(target);
break;
case 'shopPurchaseDesc':
langString = shopPurchaseDesc(target);
break;
case 'passiveDesc':
langString = passiveDesc(target);
break;
case 'relicDesc':
langString = relicDesc(target);
break;
case 'spAttDesc':
langString = spAttDesc(target);
break;
case 'tsWorshipName':
langString = tsWorshipName(target);
break;
case 'tsWorshipStatueName':
langString = tsWorshipStatueName(target);
break;
case 'attackSpellbooksName':
langString = attackSpellbooksName(target);
break;
case 'attackSpellName':
langString = attackSpellName(target);
break;
}
} else {
langString = this.getLangString(langCategoryKey, langIdent);
}
target[langPropID] = langString;
if (this.debugMode) {
if (langString !== undefined) {
console.debug(
'Set value of property ' +
langPropID +
' for ' +
langIdent +
' in node ' +
nodeName +
' to: ' +
langString
);
} else {
console.debug(
'No translation: property ' + langPropID + ' for ' + langIdent + ' in node ' + nodeName
);
}
}
}
}
});
}
});
}
});
});
}
}
getLangString(key, identifier) {
let lookupVal = '';
if (key !== undefined) {
lookupVal = key;
}
if (identifier !== undefined) {
lookupVal += (lookupVal.length > 0 ? '_' : '') + identifier;
}
return this.customLocalizations[lookupVal] ?? loadedLangJson[lookupVal];
}
getNamespacedID(namespace, ID) {
if (ID.indexOf(':') > 0) {
return ID;
} else {
return namespace + ':' + ID;
}
}
getLocalID(ID) {
if (ID !== undefined && ID.indexOf(':') > 0) {
return ID.split(':').pop();
} else {
return ID;
}
}
}
}


let wd = new Wiki;
let wd = new Wiki();
wd.printWikiData();</pre>}}
wd.printWikiData();</syntaxhighlight>}}

Latest revision as of 00:06, 19 September 2024

The GameData module is the source of all game data which many other Lua modules rely upon. This module deals with the initial loading of the game data structure, and then enables other modules to access this both via a library of functions (preferred) and in its raw format.

The game data used by the wiki is currently at version V1.3.1 (?11964).

To generate game data, do the following:

  1. Navigate to https://melvoridle.com within your preferred web browser
  2. Select any character, the character that is chosen has no impact but you may consider creating a new one as a precaution - the below code is designed to execute without affecting the character, although this is not guaranteed
  3. Ensure mods are disabled such that the generated data excludes any modded content. If disabling mods, the game should be reloaded first before trying to generate game data
  4. Open the browser console/developer mode (usually by hitting the F12 key for most browsers)
  5. Within the browser console, enter the following code then hit enter. If successful, the game data should appear within the console
  6. Copy the game data & update Module:GameData/data, Module:GameData/data2, Module:GameData/data3 accordingly
Code
class Wiki {
	constructor() {
		this.debugMode = false;
		this.prettyPrint = false;
		this.customLocalizations = {
			// Contains custom localization strings, to override any game provided localizations.
			// To be used sparingly, for instances where 2+ objects of the same type
			// (e.g. monsters) have the same name, as this isn't convenient to deal with in Lua

			// TotH curse also named 'Madness'
			MAGIC_ABYSSAL_NAME_Madness: 'Madness (ItA)',

			// Stronghold boss monsters, where names overlap with normal monster variants
			MONSTER_NAME_FierceDevilBoss: 'Fierce Devil (Stronghold)',
			MONSTER_NAME_ElementalistBoss: 'Elementalist (Stronghold)',
			MONSTER_NAME_PratTheGuardianOfSecretsBoss: 'Prat, the Guardian of Secrets (Stronghold)',
			MONSTER_NAME_MysteriousFigurePhase1Stronghold: 'Mysterious Figure - Phase 1 (Stronghold)',
			MONSTER_NAME_MysteriousFigurePhase2Stronghold: 'Mysterious Figure - Phase 2 (Stronghold)',
			MONSTER_NAME_AhreniaStronghold: 'Ahrenia (Stronghold)'
		};
		this.namespaces = {
			melvorD: {
				displayName: 'Demo',
				packFile: 'melvorDemo.json',
			},
			melvorF: {
				displayName: 'Full Version',
				packFile: 'melvorFull.json',
			},
			melvorTotH: {
				displayName: 'Throne of the Herald',
				packFile: 'melvorTotH.json',
			},
			melvorAoD: {
				displayName: 'Atlas of Discovery',
				packFile: 'melvorExpansion2.json',
			},
			melvorBirthday2023: {
				displayName: 'Melvor Birthday 2023',
				packFile: 'melvorBirthday2023.json',
			},
			melvorItA: {
				displayName: 'Into the Abyss',
				packFile: 'melvorItA.json',
			},
		};
		this.registeredNamespaces = [];
		// List of categories to be excluded from the generated game data.
		// These serve no purpose for the wiki and so would otherwise bloat the data
		this.excludedCategories = [
			'pages',
			'steamAchievements',
			'tutorialStageOrder',
			'tutorialStages'
		];
		// Check all required namespaces are registered, as there are still some bits of data extracted from in-game rather than the data packages
		Object.keys(this.namespaces).forEach((nsID) => {
			const nsTest = game.registeredNamespaces.getNamespace(nsID);
			if (nsTest === undefined) {
				throw new Error(
					`Namespace ${nsID} (${this.namespaces[nsID].displayName}) is not registered - Ensure you are signed in and have the expansion.`
				);
			}
		});
		// The output data is now long enough that it exceeds the maximum allowed MediaWiki article
		// length of 2,048KB. The below determines how the data should be separated over multiple
		// pages (Module:GameData then combines the data into a single structure upon
		// initialization).
		this.maxPageBytes = 2 * 1024 ** 2; // 2048KB
		this.printPages = [
			{ includeCategories: '*', destination: 'Module:GameData/data' },
			{
				includeCategories: ['items'],
				destination: 'Module:GameData/data2',
			},
			{
				includeCategories: [
					'itemUpgrades',
					'itemSynergies',
					'modifiers',
					'shopPurchases',
					'realms',
					'damageTypes',
					'combatTriangleSets',
					'randomAbyssalGems',
					'randomFragments',
					'randomFiremakingOils',
					'ancientRelics',
					'attackSpells',
					'attacks',
					'combatPassives',
					'monsters',
					'bankSortOrder',
					'combatEffects',
					'combatEffectTemplates',
					'combatEffectGroups'
				],
				destination: 'Module:GameData/data3',
			},
		];

		this.packData = {};
		this.gameData = {};
		this.skillDataInit = {};
	}
	getDataPackURL(nsID) {
		return 'https://' + location.hostname + '/assets/data/' + this.namespaces[nsID].packFile + '?' + DATA_VERSION.toString();
	}
	async getWikiData() {
		if (!isLoaded) {
			throw new Error('Game must be loaded into a character first');
		}
		for (const nsIdx in Object.keys(this.namespaces)) {
			const ns = Object.keys(this.namespaces)[nsIdx];
			const dataURL = this.getDataPackURL(ns);
			console.log(`URL: ${dataURL}`);
			const dataPackage = await this.getDataPackage(dataURL);
			if (dataPackage.namespace === undefined) {
				throw new Error(`Data package has no namespace: ${dataURL}`);
			} else if (dataPackage.data === undefined) {
				throw new Error(`Data package has no data: ${dataURL}`);
			}
			console.log(
				`Obtained data for namespace ${dataPackage.namespace}, ${JSON.stringify(
					dataPackage.data
				).length.toLocaleString()} bytes`
			);
			this.processDataPackage(dataPackage);
			console.log(`After transformation: ${JSON.stringify(dataPackage.data).length.toLocaleString()} bytes`);
		}
		// Process dependent data after all packages processed
		console.log('Processing dependent data for all packages...');
		this.processDependentData();
		// All data packages should now be within this.gameData
	}
	getGameFileVersion() {
		const fileDOM = document.querySelector('#sidebar ul.nav-main');
		let fileVer = 'Unknown';
		if (fileDOM !== null && fileDOM.dataset !== undefined) {
			return fileDOM.dataset.fileVersion;
		}
	}
	getGameVersion() {
		return gameVersion;
	}
	getGameVersionText() {
		return this.getGameVersion() + ' (' + this.getGameFileVersion() + ')';
	}
	getObjectByID(data, objectID, idKey = 'id') {
		if (data !== undefined && objectID !== undefined) {
			return data.find((obj) => obj[idKey] === objectID);
		}
	}
	getCategoriesForPage(page) {
		if (Array.isArray(page.includeCategories)) {
			return page.includeCategories;
		} else if (page.includeCategories === '*') {
			// Special value, include all categories other than those included within
			// other pages
			return Object.keys(this.gameData).filter(
				(cat) => !this.printPages.some((p) => Array.isArray(p.includeCategories) && p.includeCategories.includes(cat))
			);
		}
	}
	escapeQuotes(data) {
		var newData = data.replace(/\\/g, '\\\\');
		newData = newData.replace(/'/g, "\\'");
		newData = newData.replace(/"/g, '\\"');
		return newData;
	}
	formatJSONData(category, data) {
		if (data === undefined) {
			console.warn(`dataFormatter: Data for category ${category} is undefined`);
			return '';
		}
		if (this.debugMode) {
			console.debug('Formatting category data: ' + category);
		}
		if (category === 'skillData') {
			return '"' + category + '":[' + data.map((x) => this.escapeQuotes(JSON.stringify(x))).join(",' ..\n'") + ']';
		} else {
			return '"' + category + '":' + this.escapeQuotes(JSON.stringify(data));
		}
	}
	dataFullyLoaded() {
		return Object.keys(this.packData).length >= Object.keys(this.namespaces).length;
	}
	printCategoryDataLength() {
		if (!this.dataFullyLoaded()) {
			throw new Error('Game data not loaded, use printWikiData first');
		}
		let dataLengths = [];
		this.printPages.forEach((page) => {
			const inclCat = this.getCategoriesForPage(page);
			inclCat.forEach((cat) => {
				dataLengths.push({
					page: page.destination,
					category: cat,
					length: this.formatJSONData(cat, this.gameData[cat]).length,
				});
			});
		});
		console.table(dataLengths);
	}
	async printWikiData() {
		if (!isLoaded) {
			throw new Error('Game must be loaded into a character first');
		}
		if (!this.dataFullyLoaded()) {
			// Need to retrieve game data first
			const result = await this.getWikiData();
		}
		console.log('Printing data for game version ' + this.getGameVersionText());
		this.printPages.forEach((page) => {
			const inclCat = this.getCategoriesForPage(page);
			let gameDataFiltered = {};
			inclCat.forEach((cat) => (gameDataFiltered[cat] = this.gameData[cat]));

			// Convert game data into a JSON string for export
			let dataText;
			if (this.prettyPrint) {
				dataText = JSON.stringify(gameDataFiltered, undefined, '\t');
			} else {
				dataText = JSON.stringify(gameDataFiltered);
			}

			console.log(`For page "${page.destination}" (${dataText.length.toLocaleString()} bytes):`);
			if (dataText.length > this.maxPageBytes) {
				console.warn(
					`Page "${page.destination}" exceeds max page size of ${(this.maxPageBytes / 1024).toLocaleString()}KB by ${(
						dataText.length - this.maxPageBytes
					).toLocaleString()} bytes. Consider amending the printPages configuration to move some data categories from this page onto other pages.`
				);
			}
			console.log(dataText);
		});
	}
	async getDataPackage(url) {
		// Based largely on Game.fetchAndRegisterDataPackage()
		const headers = new Headers();
		headers.append('Content-Type', 'application/json');
		return await fetch(url, {
			method: 'GET',
			headers,
		}).then(function (response) {
			if (!response.ok) {
				throw new Error(`Couldn't fetch data package from URL: ${url}`);
			}
			return response.json();
		});
	}
	processDataPackage(dataPackage) {
		// Transforms the raw data from data packages in various ways, then
		// consolidates into this.packData & this.gameData
		const ns = dataPackage.namespace;
		const packData = dataPackage.data;

		this.transformDataPackage(dataPackage);
		this.packData[dataPackage.namespace] = dataPackage;
		this.registerDataPackage(dataPackage.namespace);
	}
	transformDataPackage(dataPackage) {
		// Takes a raw data package and performs various manipulations
		const ns = dataPackage.namespace;
		const packData = dataPackage.data;

		Object.keys(packData)
			.filter((categoryName) => !this.excludedCategories.includes(categoryName))
			.forEach((categoryName) => {
				this.transformDataNode(ns, categoryName, packData, categoryName);
			});
	}
	transformDataNode(ns, categoryName, parentNode, nodeKey) {
		let dataNode = parentNode[nodeKey];
		const transformedValue = this.transformProperty(categoryName, dataNode, nodeKey, ns);
		if (transformedValue !== undefined) {
			// A transformed value exists for this node
			parentNode[nodeKey] = transformedValue;
			dataNode = parentNode[nodeKey];
		}
		if (Array.isArray(dataNode)) {
			// Recursive call to ensure all data is transformed, regardless of its depth
			dataNode.forEach((entity, idx) => this.transformDataNode(ns, categoryName, dataNode, idx));
		} else if (typeof dataNode === 'object' && dataNode !== null) {
			// Iterate properties of object, checking if each should be deleted or transformed
			Object.keys(dataNode).forEach((key) => {
				// Check if property is to be deleted or not
				if (this.isPropertyFiltered(categoryName, dataNode, key)) {
					delete dataNode[key];
				} else if (typeof dataNode[key] === 'object' && dataNode[key] !== null) {
					// If an object (either an array or key/value store) is within the current
					// object then we must traverse this too
					this.transformDataNode(ns, categoryName, dataNode, key);
				} else {
					// Transform property, if a transformation is defined below
					switch (key) {
						case 'id':
							// Add namespace to ID if it isn't already
							const id = dataNode[key];
							if (!Number.isInteger(id)) dataNode[key] = this.getNamespacedID(ns, dataNode[key]);
							break;
					}
				}
			});
		}
		// Apply localization, except for if this is skill data. That is handled separately below
		if (categoryName !== 'skillData' && categoryName == nodeKey) {
			this.langApply(parentNode, nodeKey, false);
		}

		// Special case for skillData so that certain values initialized when the various Skill
		// classes are initialized may be added here also
		if (categoryName === 'skillData' && dataNode.skillID !== undefined && dataNode.data !== undefined) {
			// We are currently at the topmost level of a skill object
			const gameSkill = game.skills.getObjectByID(dataNode.skillID);
			// For every skill with mastery, add mastery checkpoint descriptions
			if (
				gameSkill instanceof SkillWithMastery &&
				dataNode.data.masteryTokenID !== undefined &&
				dataNode.data.masteryCheckpoints === undefined
			) {
				const localID = this.getLocalID(dataNode.skillID);
				dataNode.data.baseMasteryPoolCap = gameSkill.baseMasteryPoolCap;
				dataNode.data.masteryCheckpoints = [];
				masteryCheckpoints.forEach((pct, idx) => {
					dataNode.data.masteryCheckpoints[idx] = this.getLangString('MASTERY_CHECKPOINT', `${localID}_${idx}`);
				});
			}
			if (!this.skillDataInit[dataNode.skillID]) {
				if (gameSkill !== undefined) {
					// Import other attributes varying by skill
					let importKeys = [];
					switch (dataNode.skillID) {
						case 'melvorD:Mining':
							importKeys = ['baseInterval', 'baseRockHP', 'passiveRegenInterval'];
							dataNode.data.baseGemChance = 1;
							dataNode.data.rockTypes = loadedLangJson.MINING_TYPE;
							break;
						case 'melvorItA:Harvesting':
							importKeys = [
								'baseInterval',
								'baseVeinIntensity',
								'passiveRegenInterval',
								'uniqueProductChance',
								'hpCheckpoints',
							];
							break;
						case 'melvorD:Smithing':
						case 'melvorD:Fletching':
						case 'melvorD:Crafting':
						case 'melvorD:Runecrafting':
						case 'melvorD:Herblore':
							importKeys = ['baseInterval'];
							break;
						case 'melvorD:Thieving':
							importKeys = ['baseInterval', 'baseStunInterval', 'itemChance', 'baseAreaUniqueChance'];
							break;
						case 'melvorD:Summoning':
							importKeys = ['baseInterval'];
							const sumKeys = ['recipeAPCost', 'recipeGPCost', 'markLevels'];
							sumKeys.forEach((k) => (dataNode.data[k] = Summoning[k]));
							break;
						case 'melvorD:Astrology':
							// Astrology has a number of values stored outside of gameSkill
							const astKeys = [
								'standardModifierLevels',
								'uniqueModifierLevels',
								'abyssalModifierLevels',
								'baseInterval',
							];
							astKeys.forEach((k) => (dataNode.data[k] = Astrology[k]));
							break;
						case 'melvorD:Township':
							// Remap a number of keys from their in-game names
							const townKeys = [
								{ from: 'BASE_STORAGE', to: 'baseStorage' },
								{ from: 'BASE_TAX_RATE', to: 'baseTaxRate' },
								{ from: 'DECREASED_BUILDING_COST_CAP', to: 'decreasedBuildingCostCap' },
								{ from: 'GP_PER_CITIZEN', to: 'gpPerCitizen' },
								{ from: 'MAX_WORSHIP', to: 'maxWorship' },
								{ from: 'MINIMUM_HEALTH', to: 'minimumHealth' },
								{ from: 'populationForTier', to: 'populationForTier' },
								{ from: 'TICK_LENGTH', to: 'tickLength' },
								{ from: 'RARE_SEASON_CHANCE', to: 'rareSeasonChance' },
								{ from: 'WORSHIP_CHANGE_COST', to: 'worshipChangeCost' },
								{ from: 'WORSHIP_CHECKPOINTS', to: 'worshipCheckpoints' },
								{ from: 'BASE_MAX_HEALTH', to: 'baseMaxHealth' },
								{ from: 'abyssalTierRequirements', to: 'abyssalTierRequirements' },
								{ from: 'BASE_SOUL_STORAGE', to: 'baseSoulStorage' },
							];
							townKeys.forEach((k) => (dataNode.data[k.to] = gameSkill[k.from]));
							// Add task categories & localization of name
							const taskCategories = Array.from(new Set(gameSkill.tasks.tasks.allObjects.map((t) => t.category)));
							dataNode.data.taskCategories = taskCategories.map((category) => ({
								id: category.id,
								name: category.name,
							}));
							break;
					}
					if (importKeys.length > 0) {
						importKeys.forEach((k) => (dataNode.data[k] = gameSkill[k]));
					}
				}
				this.skillDataInit[dataNode.skillID] = true;
			}
			// Appy localization (skills)
			this.langApply(parentNode, nodeKey, true);
		}
	}
	registerPackData(packData) {
		Object.keys(packData)
			.filter((categoryName) => !this.excludedCategories.includes(categoryName))
			.forEach((categoryName) => {
			let categoryData = packData[categoryName];
			// Some data is adjusted before combining - do this here
			if (['combatAreas', 'dungeons', 'slayerAreas', 'abyssDepths', 'strongholds'].includes(categoryName)) {
				// Add area type to each area object
				const areaTypes = {
					combatAreas: 'combatArea',
					dungeons: 'dungeon',
					slayerAreas: 'slayerArea',
					strongholds: 'stronghold',
					abyssDepths: 'abyssDepth',
				};
				const areaType = areaTypes[categoryName];
				const newData = structuredClone(categoryData);
				newData.forEach((x) => (x.type = areaType));
				categoryData = newData;
			}
			else if (categoryName === 'golbinRaid') {
			}
			// Data must be pushed into the consoldiated data, rules for vary
			// depending on the category in question
			switch (categoryName) {
				case 'realms':
				case 'attackSpellbooks':
				case 'damageTypes':
				case 'equipmentSlots':
				case 'combatAreaCategories':
				case 'combatEffects':
				case 'combatEffectGroups':
				case 'combatEffectTables':
				case 'combatEffectTemplates':
				case 'combatTriangleSets':
				case 'masterPoolBonuses':
				case 'masteryLevelUnlocks':
				case 'masteryLevelBonuses':
				case 'masterPoolBonuses':
				case 'ancientRelics':
				case 'attackSpells':
				case 'attackStyles':
				case 'attacks':
				case 'auroraSpells':
				case 'combatAreas':
				case 'combatEvents':
				case 'combatPassives':
				case 'curseSpells':
				case 'dungeons':
				case 'strongholds':
				case 'abyssDepths':
				case 'gamemodes':
				case 'itemEffects':
				case 'itemSynergies':
				case 'itemUpgrades':
				case 'itmMonsters':
				case 'items':
				case 'lore':
				case 'modifiers':
				case 'monsters':
				case 'pages':
				case 'pets':
				case 'prayers':
				case 'randomGems':
				case 'randomSuperiorGems':
				case 'randomAbyssalGems':
				case 'randomFragments':
				case 'randomFiremakingOils':
				case 'shopCategories':
				case 'shopPurchases':
				case 'shopUpgradeChains':
				case 'skillLevelCapIncreases':
				case 'slayerAreas':
				case 'slayerTaskCategories':
				case 'steamAchievements':
				case 'tutorialStages':
				case 'spiderLairMonsters':
					// Plain old push to the end of the array
					if (this.gameData[categoryName] === undefined) {
						// Category doesn't exist yet in consolidated data, so create it
						this.gameData[categoryName] = categoryData;
					} else {
						this.gameData[categoryName].push(...categoryData);
					}
					break;
				case 'ancientRelicsDisplayOrder':
				case 'bankSortOrder':
				case 'combatAreaCategoryOrder':
				case 'combatAreaDisplayOrder':
				case 'dungeonDisplayOrder':
				case 'shopCategoryOrder':
				case 'shopDisplayOrder':
				case 'skillTreesDisplayOrder':
				case 'slayerAreaDisplayOrder':
				case 'tutorialStageOrder':
					// Elements are inserted at a particular index, controlled by rules
					// specified within the data package
					this.gameData[categoryName] = this.combineOrderedData(this.gameData[categoryName], categoryData);
					break;
				case 'golbinRaid':
					// Properties contain unordered arrays that need to be combined
					if (this.gameData[categoryName] === undefined) {
						this.gameData[categoryName] = categoryData;
						this.gameData.golbinRaid.possibleModifiers = RaidManager.possibleModifiers;
					} else {
						Object.keys(categoryData).forEach((dataKey) => {
							if (
								this.gameData[categoryName][dataKey] === undefined ||
								!Array.isArray(this.gameData[categoryName][dataKey])
							) {
								// Property is undefined or isn't an array
								this.gameData[categoryName][dataKey] = categoryData[dataKey];
							} else {
								// Property is an array
								this.gameData[categoryName][dataKey].push(...categoryData[dataKey]);
							}
						});
					}
					break;
				case 'skillData':
					// Contains nested objects
					if (this.gameData[categoryName] === undefined) {
						this.gameData[categoryName] = [];
					}
					// Find the appropriate skill object and combine properties with that
					categoryData.forEach((skillData) => {
						var skillIdx = this.gameData[categoryName].findIndex((skill) => skill.skillID === skillData.skillID);
						if (skillIdx === -1) {
							// Initialize skill
							const initData = structuredClone(skillData);
							initData.data = {};
							this.gameData[categoryName].push(initData);
							skillIdx = this.gameData[categoryName].findIndex((skill) => skill.skillID === skillData.skillID);
						}
						const skillObj = this.gameData[categoryName][skillIdx].data;
						Object.keys(skillData.data).forEach((dataKey) => {
							// Special case for Township item conversions
							if (
								skillObj[dataKey] !== undefined &&
								skillData.skillID === 'melvorD:Township' &&
								dataKey === 'itemConversions'
							) {
								Object.keys(skillData.data[dataKey]).forEach((convKey) => {
									skillData.data[dataKey][convKey].forEach((resource) => {
										// Find the resource if it already exists within the combined data
										const resourceIdx = skillObj[dataKey][convKey].findIndex(
											(res) => res.resourceID === resource.resourceID
										);
										if (resourceIdx === -1) {
											skillObj[dataKey][convKey].push(resource);
										} else {
											skillObj[dataKey][convKey][resourceIdx].items.push(...resource.items);
										}
									});
								});
							} else if (
								Array.isArray(skillData.data[dataKey]) &&
								skillData.data[dataKey].length > 0 &&
								skillData.data[dataKey][0].insertAt !== undefined
							) {
								// Data is ordered, special handling applies
								skillObj[dataKey] = this.combineOrderedData(skillObj[dataKey], skillData.data[dataKey]);
							} else if (skillObj[dataKey] === undefined || !Array.isArray(skillObj[dataKey])) {
								// Property is undefined or isn't an array
								skillObj[dataKey] = skillData.data[dataKey];
							} else {
								// Property is an array
								skillObj[dataKey].push(...skillData.data[dataKey]);
							}
						});
					});
					break;
				default:
					console.warn(`Skipping unknown category while registering data package: ${categoryName}`);
					break;
			}
		});
	}
	registerDataPackage(namespace) {
		// Consolidates the data package identified by namespace with existing data within
		// this.gameData
		const packData = this.packData[namespace].data;
		if (packData === undefined) {
			throw new Error(`Couldn't find data for package ${namespace}`);
		}
		// Add data within the game but outside of data packs
		this.registerNonPackData();
		// Consolidate data
		this.registerPackData(packData);
		// If the data package contains modifications, apply these also
		const modificationData = this.packData[namespace].modifications;
		if (modificationData !== undefined) {
			this.applyDataModifications(modificationData);
		}
		// Dependent data is handled later, once all packages have been registered

		if (!this.registeredNamespaces.includes(namespace)) {
			this.registeredNamespaces.push(namespace);
		}
	}
	processDependentData() {
		Object.entries(this.packData)
			.forEach(([namespace, packData]) => {
				if (packData.dependentData !== undefined) {
					packData.dependentData.forEach((depDataForNS) => {
						const depNS = depDataForNS.namespace;
						if (!this.registeredNamespaces.includes(depNS)) {
							console.warn(
								`Could not apply dependent data from package ${namespace}: Data depends on namespace ${depNS}, which has not been registered`
							);
						}
						else {
							console.log(`Attempting to apply dependent data for ${depNS} from package ${namespace}`);
							if (depDataForNS.data !== undefined) {
								this.registerPackData(depDataForNS.data)
							}
							if (depDataForNS.modifications !== undefined) {
								this.applyDataModifications(depDataForNS.modifications);
							}
						}
					});
				}
			});
	}
	getDataToModify(modCat) {
		switch (modCat) {
			case 'combatAreaCategories':
			case 'damageTypes':
			case 'dungeons':
			case 'equipmentSlots':
			case 'gamemodes':
			case 'items':
			case 'modifiers':
			case 'pets':
			case 'shopUpgradeChains':
			case 'shopPurchases':
			case 'skillData':
			case 'slayerAreas':
				return this.gameData[modCat];
			case 'cookingCategories':
				const cookingSkill = this.getObjectByID(this.gameData.skillData, 'melvorD:Cooking', 'skillID');
				return cookingSkill.data.categories;
			case 'fletchingRecipes':
				const fletchingSkill = this.getObjectByID(this.gameData.skillData, 'melvorD:Fletching', 'skillID');
				return fletchingSkill.data.recipes;
		}
		return undefined;
	}
	applyModifierModifications(objToModify, adjustments) {
		if (objToModify.modifiers === undefined) {
			objToModify.modifiers = {};
		}
		Object.keys(adjustments)
			.forEach((adjType) => {
				if (adjType === 'add') {
					Object.entries(adjustments[adjType])
						.forEach(([chgKey, chgVal]) => {
							if (objToModify.modifiers[chgKey] === undefined) {
								objToModify.modifiers[chgKey] = chgVal;
							}
							else if (Array.isArray(chgVal)) {
								objToModify.modifiers[chgKey].push(...chgVal);
							}
							else {
								objToModify.modifiers[chgKey] += chgVal;
							}
						});
				}
				else {
					console.warn(
						`Could not apply data modification: Unhandled modifier adjustment "${adjType}"`
					);
				}
			}
		);
	}
	applyAddRemoveModifications(objToModify, adjustments, modifyKey) {
		if (adjustments.remove !== undefined && Array.isArray(objToModify[modifyKey])) {
			// adjustments.remove is an array of requirement types to be removed
			let i = 0;
			while (i < objToModify[modifyKey].length) {
				if (adjustments.remove.includes(objToModify[modifyKey][i].type)) {
					objToModify[modifyKey].splice(i, 1);
				}
				else {
					i++;
				}
			}
		}
		if (adjustments.add !== undefined) {
			if (objToModify[modifyKey] === undefined) {
				objToModify[modifyKey] = adjustments.add;
			}
			else {
				objToModify[modifyKey].push(...adjustments.add);
			}
		}
	}
	applyGamemodeSpecificModifications(objToModify, adjustments, newProperty) {
		const gamemodeID = adjustments.gamemodeID;
		if (objToModify.gamemodeOverrides === undefined) {
			objToModify.gamemodeOverrides = [];
		}
		let gamemodeEntryToModify = this.getObjectByID(objToModify.gamemodeOverrides, gamemodeID, 'gamemodeID');
		if (gamemodeEntryToModify === undefined) {
			// Initialize gamemode overrides
			objToModify.gamemodeOverrides.push({
				gamemodeID: gamemodeID
			});
			gamemodeEntryToModify = this.getObjectByID(objToModify.gamemodeOverrides, gamemodeID, 'gamemodeID');
		}
		if (gamemodeEntryToModify[newProperty] === undefined) {
			gamemodeEntryToModify[newProperty] = structuredClone(objToModify[newProperty]) ?? {};
		}
		this.applyAddRemoveModifications(gamemodeEntryToModify, adjustments, newProperty);
	}
	applyDataModifications(modData) {
		const modDataKeys = Object.keys(modData).filter((modCatID) => !this.excludedCategories.includes(modCatID));
		for (const modCatID in modDataKeys) {
			const modCat = modDataKeys[modCatID];
			const catData = modData[modCat];
			const dataToModify = this.getDataToModify(modCat);
			const modObjIDKey = (modCat === 'skillData' ? 'skillID' : 'id');
			if (dataToModify === undefined) {
				console.warn(
					`Could not apply data modification for category "${modCat}": Unable to retrieve category data to be modified`
				);
			}
			else {
				catData.forEach((modItem) => {
					const modObjID = modItem[modObjIDKey];
					if (modObjID === undefined) {
						console.warn(
							`Could not apply data modification for category "${modCat}": ID of object to be modified not found`
						);
					} else {
						const objToModify = this.getObjectByID(dataToModify, modObjID, modObjIDKey);
						if (objToModify === undefined) {
							console.warn(
								`Could not apply data modification: Object with ID "${modObjID}" not found for ctaegory "${modCat}"`
							);
						}
						else {
							switch (modCat) {
								case 'combatAreaCategories':
									// The 'areas' property of elements within the category data are ordered data
									objToModify.areas = this.combineOrderedData(objToModify.areas, modItem.areas.add);
									break;
								case 'damageTypes':
									Object.entries(modItem)
										.filter(([k, v]) => k !== 'id')
										.forEach(([k, v]) => {
											if (typeof v === 'object' && (v.add !== undefined || v.remove !== undefined)) {
												this.applyAddRemoveModifications(objToModify, v, k);
											}
											else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										});
									break;
								case 'gamemodes':
									Object.entries(modItem)
										.filter(([k, v]) => k !== 'id')
										.forEach(([k, v]) => {
											if (typeof v === 'object' && (v.add !== undefined || v.remove !== undefined)) {
												this.applyAddRemoveModifications(objToModify, v, k);
											}
											else if (['abyssalLevelCapCost', 'post99RollConversion'].includes(k)) {
												objToModify[k] = v;
											}
											else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										});
									break;
								case 'shopPurchases':
								case 'shopUpgradeChains':
									// Modify the root upgrade ID of shop upgrade chains, and modify attributes of shop purchases
									const overrideKeys = {
										purchaseRequirements: {
											sourceKey: 'newRequirements', // Key that holds the data in the data package
											destKey: 'purchaseRequirementsOverrides', // Key to insert into within this.gameData
											subKey: 'requirements', // Sub-key containing the override data
										},
										cost: {
											sourceKey: 'newCosts',
											destKey: 'costOverrides',
											subKey: 'cost',
										},
									};
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											const overrideKey = overrideKeys[k];
											if (overrideKey !== undefined) {
												// Is an override specific to a gamemode, do not replace
												// the key's existing data
												const destKey = overrideKey.destKey;
												if (objToModify[destKey] === undefined) {
													objToModify[destKey] = [];
												}
												modItem[k].forEach((gamemodeOverride) => {
													var newData = {};
													newData.gamemodeID = gamemodeOverride.gamemodeID;
													newData[overrideKey.subKey] = gamemodeOverride[overrideKey.sourceKey];
													objToModify[destKey].push(newData);
												});
											} else {
												objToModify[k] = modItem[k];
											}
										});
									break;
								case 'cookingCategories':
									// Append to the list of shop upgrade IDs for cooking utilities/categories
								case 'fletchingRecipes':
									// Append to alternativeCosts property of recipes (e.g. Arrow shafts)
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											if ((k === 'shopUpgradeIDs') || (k === 'alternativeCosts')) {
												if (objToModify[k] === undefined) {
													objToModify[k] = modItem[k];
												} else {
													objToModify[k].push(...modItem[k]);
												}
											} else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										});
									break;
								case 'skillData':
									Object.entries(modItem.data)
										.forEach(([skillProp, propModData]) => {
											propModData.forEach((subModItem) => {
												const subObjToModify = this.getObjectByID(objToModify.data[skillProp], subModItem.id);
												if (subObjToModify === undefined) {
													console.warn(`Couldn't find skill object with ID ${subModItem.id} to modify. Property ${skillProp} in skill ID ${objToModify.skillID}`);
												}
												else {
													Object.entries(subModItem)
														.forEach(([subProp, subData]) => {
															if (subProp === 'modifiers') {
																this.applyModifierModifications(subObjToModify, subData);
															}
															else if (subProp !== 'id') {
																this.applyAddRemoveModifications(subObjToModify, subData, subProp);
															}
														});
												}
											});
										});
									break;
								case 'dungeons':
									// Add gamemode specific data to dungeons
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											if (k === 'gamemodeRewardItemIDs') {
												// Add gamemode specific item rewards to dungeon data
												const itemRules = modItem[k];
												Object.keys(itemRules).forEach((ruleKey) => {
													if (ruleKey === 'add') {
														itemRules[ruleKey].forEach((itemDef) => {
															const modToApply = {
																gamemodeID: itemDef.gamemodeID,
																add: itemDef.rewardItemIDs
															}
															this.applyGamemodeSpecificModifications(objToModify, modToApply, 'rewardItemIDs');
														});
													} else {
														console.warn(
															`Could not apply data modification: Unknown rule for gamemode item rewards: "${ruleKey}", object "${modObjID}"`
														);
													}
												});
											} else if (k === 'gamemodeEntryRequirements') {
												// Add or remove gamemode specific entry requirements to dungeon data
												this.applyGamemodeSpecificModifications(objToModify, modItem[k], 'entryRequirements');
											} else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										});
									break;
								case 'modifiers':
									// Add modifier aliases to existing mod scopes
									if (objToModify.allowedScopes === undefined) {
										console.warn(`Could not apply data modification: Modifier with ID ${modObjID} not found or modifier has no scopes`);
									} else {
										modItem.allowedScopes.forEach((srcScope) => {
											// Find scope within modifier objToModify with matching scopes definition
											const srcScopeKeys = Object.keys(srcScope.scopes);
											objToModify.allowedScopes.forEach((destScope) => {
												const destScopeKeys = Object.keys(destScope.scopes);
												const scopeMatch = (
													srcScopeKeys.length === destScopeKeys.length
													&& srcScopeKeys.every((k) => destScope.scopes[k] !== undefined && srcScope.scopes[k] == destScope.scopes[k])
												);
												if (scopeMatch) {
													// Scopes match - add aliases to modifier allowedScope definition
													const aliasKeys = ['posAliases', 'negAliases'];
													aliasKeys.forEach((aliasKey) => {
														if (srcScope[aliasKey] !== undefined) {
															if (destScope[aliasKey] === undefined) {
																destScope[aliasKey] = [];
															}
															destScope[aliasKey].push(...srcScope[aliasKey]);
														}
													});
												}
											});
										});
									}
									break;
								case 'items':
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											if (k === 'modifiers') {
												this.applyModifierModifications(objToModify, modItem[k]);
											}
											else if (k === 'consumesOn') {
												Object.keys(modItem[k])
													.forEach((adjType) => {
														if (adjType === 'add') {
															if (objToModify[k] === undefined) {
																objToModify[k] = modItem[k][adjType];
															}
															else {
																objToModify[k].push(...modItem[k][adjType]);
															}
														}
														else {
															console.warn(
																`Could not apply data modification: Unhandled adjustment type "${adjType}" for category "${modCat}", object "${modObjID}, property ${k}"`
															);
														}
													});
											}
											else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										}
									);
									break;
								case 'pets':
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											if (k === 'modifiers') {
												this.applyModifierModifications(objToModify, modItem[k]);
											}
											else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										}
									);
									break;
								case 'equipmentSlots':
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											if (k === 'requirements') {
												this.applyAddRemoveModifications(objToModify, modItem[k], 'requirements');
											}
											else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										}
									);
									break;
								case 'slayerAreas':
									Object.keys(modItem)
										.filter((k) => k !== 'id')
										.forEach((k) => {
											if (k === 'gamemodeEntryRequirements') {
												this.applyGamemodeSpecificModifications(objToModify, modItem[k], 'entryRequirements');
											}
											else {
												console.warn(
													`Could not apply data modification: Unhandled key "${k}" for category "${modCat}", object "${modObjID}"`
												);
											}
										}
									);
									break;
								default:
									console.warn(
										`Could not apply data modification: Unhandled category "${modCat}"`
									);
							}
						}
					}
				});
			}
		}
	}
	registerNonPackData() {
		// Some data resides outside of packages. Add any such data to this.gameData within this function
		// Metadata for data/file version
		if (this.gameData._dataVersion === undefined) {
			this.gameData._dataVersion = ({
				gameVersion: this.getGameVersion().substring(1),
				fileVersion: this.getGameFileVersion().substring(1)
			});
		}
		// Namespaces
		if (this.gameData.namespaces === undefined) {
			const nsData = [];
			game.registeredNamespaces.forEach((ns) => {
				if (ns.isModded) {
					throw new Error(
						`Modded namespace '${ns.displayName}' found, all mods must be disabled before game data can be generated`
					);
				} else {
					nsData.push(ns);
				}
			});
			this.gameData.namespaces = nsData;
		}
		if (this.gameData.currencies === undefined) {
			this.gameData.currencies = game.currencies.allObjects.map((c) => ({
				id: c.id,
				name: c.name,
				type: c.type
			}));
		}
		// Melvor realm exists outside of data packages
		if (this.gameData.realms === undefined) {
			this.gameData.realms = game.realms
				.filter((r) => r.id === 'melvorD:Melvor')
				.map((r) => ({
					id: r.id,
					name: r.name,
					unlockRequirements: r.unlockRequirements
				}));
		}
		// Normal damage type exists outside of data packages
		if (this.gameData.damageTypes === undefined) {
			this.gameData.damageTypes =  game.damageTypes
				.filter((d) => d.id === 'melvorD:Normal')
				.map((d) => ({
					id: d.id,
					name: d.name,
					resistanceCap: d._resistanceCap,
					resistanceName: d.resistanceName
				}));
		}
		if (this.gameData.combatAreaDifficulties === undefined) {
			this.gameData.combatAreaDifficulties = CombatAreaMenuElement.difficulty.map((i) => i.name);
		}
		if (this.gameData.attackTypes === undefined) {
			this.gameData.attackTypes = AttackTypeID;
		}
	}
	combineOrderedData(existingData, newData) {
		// Elements are inserted at a particular index, controlled by rules
		// specified within the data package
		var resultData = undefined;
		if (existingData === undefined) {
			resultData = [];
		} else {
			resultData = structuredClone(existingData);
		}
		newData.forEach((orderData) => {
			switch (orderData.insertAt) {
				case 'Start':
					resultData.splice(0, 0, ...orderData.ids);
					break;
				case 'End':
					resultData.push(...orderData.ids);
					break;
				case 'Before':
					const beforeIdx = resultData.findIndex((item) => item === orderData.beforeID);
					if (beforeIdx === -1) {
						throw new Error(`Couldn't insert before: Item ${orderData.beforeID} is not in the array.`);
					}
					resultData.splice(beforeIdx, 0, ...orderData.ids);
					break;
				case 'After':
					const afterIdx = resultData.findIndex((item) => item === orderData.afterID);
					if (afterIdx === -1) {
						throw new Error(`Couldn't insert after: Item ${orderData.afterID} is not in the array.`);
					}
					resultData.splice(afterIdx + 1, 0, ...orderData.ids);
					break;
			}
		});
		return resultData;
	}
	// Determines if properties of entities are to be removed, as they are unused in the wiki
	// and would otherwise bloat the data.
	// Returns true if the property is to be removed, false if it is to be retained
	isPropertyFiltered(entityType, entity, propertyName) {
		switch (propertyName) {
			case 'media':
			case 'altMedia':
			case 'markMedia':
			case 'icon':
			case 'barStyle': // See: melvorD:Compost
			case 'buttonStyle':
			case 'descriptionGenerator':
			case 'containerID':
			case 'headerBgClass':
			case 'textClass':
			case 'btnClass':
				return true;
			case 'golbinRaidExclusive':
			case 'ignoreCompletion':
			case 'obtainFromItemLog':
				// Property is boolean & isn't of interest when false
				return !entity[propertyName];
			case 'validSlots':
			case 'occupiesSlots':
			case 'equipRequirements':
			case 'equipmentStats':
				// Property is an array & isn't of interest when zero elements in length
				return entity[propertyName].length === 0;
			case 'tier':
				if (entityType === 'items') {
					return entity.tier === 'none';
				} else {
					return false;
				}
			default:
				// Always retain property
				return false;
		}
	}
	// Specifies rules for transforming values of entity properties.
	// Returns undefined if the property has no transformation
	transformProperty(entityType, entity, propertyName, namespace) {
		switch (propertyName) {
			case 'langHint':
			case 'langCustomDescription':
				return this.getLangString(entity.category, this.getLocalID(entity.id));
			case 'equipmentStats':
				const newStats = {};
				entity.forEach((stat) => {
					let statKey = stat.key;
					if (stat.damageType !== undefined) {
						statKey += this.getLocalID(stat.damageType);
					}
					if (newStats[statKey] === undefined) {
						newStats[statKey] = stat.value;
					} else {
						newStats[statKey] += stat.value;
					}
				});
				return newStats;
			case 'altSpells':
				if (entityType !== 'skillData') {
					return undefined;
				} else {
					const newData = structuredClone(entity);
					newData.forEach((i) => {
						i.spellBook = 'altMagic';
					});
					return newData;
				}
			default:
				return undefined;
		}
	}
	langApply(parentNode, nodeKey, isSkill) {
		const nodeName = isSkill ? parentNode[nodeKey].skillID : nodeKey;
		const altMagicDescIDKey = function (data) {
			// Accepts an Alt. Magic spell object, returns the ID format for that spell
			// Using a function for this as some spells (e.g. Superheat) have bespoke logic
			if (data.specialCost !== undefined && data.specialCost.type !== undefined) {
				if (data.id.includes('HolyInvocation')) {
					return 'HOLY_INVOCATION';
				}
				switch (data.specialCost.type) {
					case 'BarIngredientsWithCoal':
						return 'SUPERHEAT';
					case 'BarIngredientsWithoutCoal':
						return 'SUPERHEAT_NO_COAL';
					case 'AnyItem':
						if (data.produces !== undefined && data.produces === 'GP') {
							return 'ITEM_ALCHEMY';
						}
						break;
				}
			}
			return 'ALTMAGIC_DESC_{ID}';
		};
		const shopChainPropKey = (data, dataKey, propName) => {
			// Accepts an upgrade chain data object & key of the property being localized
			const propToLang = {
				chainName: 'chainNameLang',
				defaultDescription: 'descriptionLang',
				defaultName: 'defaultNameLang',
			};
			const langPropName = propToLang[dataKey];
			if (langPropName !== undefined) {
				const langProp = data[langPropName];
				if (langProp !== undefined) {
					return langProp[propName];
				}
			}
		};
		const itemDesc = (data) => {
			const item = game.items.getObjectByID(data.id);
			if (item !== undefined && item.hasDescription) {
				return item.description;
			} else return '';
		};
		const shopPurchaseDesc = (data) => {
			const purchase = game.shop.purchases.getObjectByID(data.id);
			if (purchase !== undefined) {
				// Logic taken from description method of ShopPurchase class & slightly modified
				// to avoid retrieving an item's modified description, which can include HTML
				let desc = '';
				if (purchase._customDescription !== undefined) {
					if (purchase.isModded) {
						return purchase._customDescription;
					} 
					else {
						return getLangString(`SHOP_DESCRIPTION_${ purchase.localID }`);
					}
				}
				if (purchase.contains.itemCharges !== undefined) {
				  return purchase.contains.itemCharges.item.description;
				}
				if (purchase.contains.items.length === 1) {
				  return purchase.contains.items[0].item.description; // Was modifiedDescription
				}
				if (purchase.contains.pet !== undefined) {
				  return purchase.contains.pet.description;
				}
				if (purchase.contains.stats !== undefined) {
				  desc = purchase.contains.stats.describePlain();
				}
				if (purchase.hasDisabledModifier) {
					desc += getLangString('MENU_TEXT_CONTAINS_DISABLED_MODIFIER');
				}
				return desc;
			} else return '';
		};
		const relicDesc = (data) => {
			const relic = game.ancientRelics.getObjectByID(data.id);
			if (relic !== undefined) {
				return relic.name;
			}
		};
		const passiveDesc = (data) => {
			const passive = game.combatPassives.getObjectByID(data.id);
			if (passive !== undefined) {
				return passive.description;
			}
		};
		const spAttDesc = (data) => {
			const spAtt = game.specialAttacks.getObjectByID(data.id);
			if (spAtt !== undefined) {
				return spAtt.description;
			}
		};
		const tsWorshipName = (data) => {
			const worship = game.township.worships.getObjectByID(data.id);
			if (worship !== undefined) {
				return worship.name;
			}
		};
		const tsWorshipStatueName = (data) => {
			const worship = game.township.worships.getObjectByID(data.id);
			if (worship !== undefined) {
				return worship.statueName;
			}
		};
		const attackSpellbooksName = (data) => {
			const book = game.attackSpellbooks.getObjectByID(data.id);
			if (book !== undefined) {
				return book.name;
			}
		};
		const attackSpellName = (data) => {
			const spell = game.attackSpells.getObjectByID(data.id);
			if (spell !== undefined) {
				return this.getLangString(`${ spell.spellbook.spellNameLangPrefix }${ spell.localID }`);
			}
		};
		const hasNoLangData = [
			// Categories that contain no localized text. Supresses warnings about no lang data
			'ancientRelicsDisplayOrder',
			'bankSortOrder',
			'combatAreaDisplayOrder',
			'combatAreaCategoryOrder',
			'combatEffectTables',
			'combatEffectTemplates',
			'combatEvents',
			'dungeonDisplayOrder',
			'golbinRaid',
			'itemEffects',
			'itemSynergies',
			'itemUpgrades',
			'itmMonsters',
			'modifiers', // TODO Does have lang data, supressing warning for now
			'randomAbyssalGems',
			'randomFiremakingOils',
			'randomFragments',
			'randomGems',
			'randomSuperiorGems',
			'slayerAreaDisplayOrder',
			'slayerTaskCategories', // TODO Does have lang data, supressing warning for now
			'shopCategoryOrder',
			'shopDisplayOrder',
			'skillLevelCapIncreases',
			'skillTreesDisplayOrder',
			'spiderLairMonsters',
			'stackingEffects',
		];
		const langKeys = {
			realms: {
				name: { key: 'REALM', idFormat: 'NAME_{ID}' },
			},
			damageTypes: {
				name: { idFormat: 'DAMAGE_TYPE_{ID}' },
			},
			combatTriangleSets: {
				name: { key: 'COMBAT_TRIANGLE_NAME', idFormat: 'NAME_{ID}' },
			},
			attackSpellbooks: {
				name: { stringSpecial: 'attackSpellbooksName' },
			},
			attackSpells: {
				name: { stringSpecial: 'attackSpellName' },
			},
			ancientRelics: {
				name: { stringSpecial: 'relicDesc' },
			},
			attackStyles: {
				name: { key: 'COMBAT_MISC', idFormat: 'ATTACK_STYLE_NAME_{ID}' },
			},
			attacks: {
				name: { key: 'SPECIAL_ATTACK_NAME' },
				description: { stringSpecial: 'spAttDesc' },
			},
			auroraSpells: {
				name: { key: 'MAGIC', idFormat: 'AURORA_NAME_{ID}' },
			},
			combatAreaCategories: {
				name: { key: 'COMBAT_AREA_CATEGORY' }
			},
			combatAreas: {
				name: { key: 'COMBAT_AREA', idFormat: 'NAME_{ID}' },
			},
			combatEffectGroups: {
				name: { idKey: 'nameLang' }
			},
			combatEffects: {
				name: { idKey: 'nameLang' }
			},
			combatPassives: {
				name: { key: 'PASSIVES', idFormat: 'NAME_{ID}' },
				customDescription: { stringSpecial: 'passiveDesc' },
				//customDescription: { key: 'PASSIVES', idFormat: 'DESC_{ID}' }
			},
			curseSpells: {
				name: { key: 'MAGIC', idFormat: 'CURSE_NAME_{ID}' },
			},
			dungeons: {
				name: { key: 'DUNGEON', idFormat: 'NAME_{ID}' },
			},
			abyssDepths: {
				name: { key: 'THE_ABYSS', idFormat: 'NAME_{ID}' },
			},
			strongholds: {
				name: { idFormat: 'STRONGHOLD_NAME_{ID}' },
			},
			equipmentSlots: {
				emptyName: { idFormat: 'EQUIP_SLOT_{ID}' }
			},
			gamemodes: {
				name: { key: 'GAMEMODES', idFormat: 'GAMEMODE_NAME_{ID}' },
				description: { key: 'GAMEMODES', idFormat: 'GAMEMODE_DESC_{ID}' },
				// Gamemodes have an array of rules
				rules: { key: 'GAMEMODES', idFormat: 'GAMEMODE_RULES_{ID}_{NUM}' },
			},
			items: {
				name: { key: 'ITEM_NAME' },
				customDescription: { stringSpecial: 'itemDesc', onlyIfExists: false },
			},
			lore: {
				title: { key: 'LORE', idFormat: 'TITLE_{ID}' },
			},
			monsters: {
				name: { key: 'MONSTER_NAME' },
				description: { key: 'MONSTER_DESCRIPTION' },
			},
			pets: {
				name: { key: 'PET_NAME' },
				hint: { idKey: 'langHint' }
			},
			prayers: {
				name: { key: 'PRAYER', idFormat: 'PRAYER_NAME_{ID}' },
			},
			shopCategories: {
				name: { key: 'SHOP_CAT' },
			},
			shopPurchases: {
				customName: { key: 'SHOP_NAME', onlyIfExists: true },
				customDescription: { stringSpecial: 'shopPurchaseDesc', onlyIfExists: false },
			},
			shopUpgradeChains: {
				chainName: { keySpecial: 'shopChainKey', idSpecial: 'shopChainID' },
				defaultDescription: { keySpecial: 'shopChainKey', idSpecial: 'shopChainID' },
				defaultName: { keySpecial: 'shopChainKey', idSpecial: 'shopChainID' },
			},
			slayerAreas: {
				name: { key: 'SLAYER_AREA', idFormat: 'NAME_{ID}' },
				areaEffectDescription: { key: 'SLAYER_AREA', idFormat: 'EFFECT_{ID}' },
			},
			skillData: {
				// Each skill is nested within this, so follow much the same structure
				// Keys here are each skill's local ID
				_common: {
					// Special entry, contains lang definitions which are the same
					// for all skills
					_root: {
						name: { key: 'SKILL_NAME', idFormat: '{SKILLID}' },
					},
					customMilestones: {
						name: { key: 'MILESTONES', idKey: 'milestoneID' },
					},
					masteryLevelUnlocks: {
						description: { key: 'MASTERY_BONUS', idKey: 'descriptionID', idFormat: '{SKILLID}_{ID}' },
					},
				},
				Archaeology: {
					digSites: {
						name: { key: 'POI_NAME_Melvor' },
					},
					// TODO Tool names
				},
				Agility: {
					elitePillars: {
						name: { key: 'AGILITY', idFormat: 'PILLAR_NAME_{ID}' },
					},
					obstacles: {
						name: { key: 'AGILITY', idFormat: 'OBSTACLE_NAME_{ID}' },
					},
					pillars: {
						name: { key: 'AGILITY', idFormat: 'PILLAR_NAME_{ID}' },
					},
				},
				Astrology: {
					recipes: {
						name: { key: 'ASTROLOGY', idFormat: 'NAME_{ID}' },
					},
				},
				Cartography: {
					mapPortals: { _handler: 'mapPortals' },
					travelEvents: {
						description: { key: 'TRAVEL_EVENT' },
					},
					worldMaps: { _handler: 'cartoMaps' },
					//name: { key: 'WORLD_MAP_NAME' },
					//pointsOfInterest: {	_handler: 'mapPOI' }
					//name: { key: 'POI_NAME', idFormat: '{MAPID}_{ID}' },
					//description: { key: 'POI_DESCRIPTION', idFormat: '{MAPID}_{ID}' }
				},
				Cooking: {
					categories: { 
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
					}
				},
				Crafting: {
					categories: { 
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
					}
				},
				Farming: {
					categories: {
						description: { key: 'SKILL_CATEGORY', idFormat: '{SKILLID}_{ID}_description' },
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'},
						seedNotice: { key: 'SKILL_CATEGORY', idFormat: '{SKILLID}_{ID}_seedNotice' },
						singularName: { key: 'SKILL_CATEGORY', idFormat: '{SKILLID}_{ID}_singular' },
					},
				},
				Fletching: {
					categories: { 
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
					}
				},
				Fishing: {
					areas: {
						name: { key: 'FISHING', idFormat: 'AREA_NAME_{ID}' },
					},
				},
				Herblore: {
					categories: { 
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
					},
					recipes: {
						name: { key: 'POTION_NAME' },
					},
				},
				Magic: {
					altSpells: {
						name: { key: 'MAGIC', idFormat: 'ALTMAGIC_NAME_{ID}' },
						description: { key: 'MAGIC', idSpecial: 'altMagicDesc' },
					},
				},
				Mining: {
					categories: {
						name: { idFormat: 'MINING_TYPE_{ID}' }
					},
					rockData: {
						name: { key: 'ORE_NAME' },
					},
				},
				Runecrafting: {
					categories: { 
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
					}
				},
				Summoning: {
					categories: { 
						name: { idFormat: 'SKILL_CATEGORY_{SKILLID}_{ID}'}
					},
					synergies: {
						customDescription: {
							key: 'SUMMONING_SYNERGY',
							idKey: 'summonIDs',
							idFormat: 'DESC_{ID0}_{ID1}',
							onlyIfExists: true,
						},
					},
				},
				Thieving: {
					areas: {
						name: { key: 'THIEVING', idFormat: 'AREA_NAME_{ID}' },
					},
					npcs: {
						name: { key: 'THIEVING', idFormat: 'NPC_NAME_{ID}' },
					},
				},
				Township: {
					biomes: {
						// Can't locate biome description localization, don't think this is exposed in game UI
						name: { key: 'TOWNSHIP', idFormat: 'BIOME_{ID}' },
					},
					buildings: {
						// Building description has no localization, as it is unused
						name: { key: 'TOWNSHIP', idFormat: 'BUILDING_{ID}' },
					},
					jobs: {
						name: { key: 'TOWNSHIP', idFormat: 'JOB_{ID}' },
					},
					resources: {
						name: { key: 'TOWNSHIP', idFormat: 'RESOURCE_{ID}' },
					},
					tasks: {
						// name is not exposed in game UI, and has no localization
						// category is localized in transformDataNode
						description: { key: 'TOWNSHIP_TASKS', idFormat: '{ID}_description' },
					},
					worships: {
						name: { stringSpecial: 'tsWorshipName' },
						statueName: { stringSpecial: 'tsWorshipStatueName' },
					},
				},
				Woodcutting: {
					trees: {
						name: { key: 'TREE_NAME' },
					},
				},
			},
		};

		// Determine which language key data applies
		var langKeyData;
		if (isSkill) {
			// Combine common & skill specific keys
			const skillKey = this.getLocalID(parentNode[nodeKey].skillID);
			const langCommon = langKeys.skillData._common;
			let langSkill = structuredClone(langKeys.skillData[skillKey]);

			if (langCommon !== undefined) {
				if (langSkill === undefined) {
					langSkill = {};
				}
				Object.keys(langCommon).forEach((k) => {
					if (langSkill[k] === undefined) {
						langSkill[k] = {};
					}
					Object.keys(langCommon[k]).forEach((prop) => {
						langSkill[k][prop] = langCommon[k][prop];
					});
				});
			}
			langKeyData = langSkill;
		} else if (langKeys[nodeKey] !== undefined) {
			langKeyData = { _root: langKeys[nodeKey] };
		} else if (!hasNoLangData.includes(nodeKey)) {
			console.warn('No lang key data found for ' + nodeKey);
		}

		if (langKeyData !== undefined) {
			var dataToTranslate = parentNode[nodeKey];
			if (isSkill) {
				dataToTranslate = dataToTranslate.data;
			}
			if (!Array.isArray(dataToTranslate)) {
				dataToTranslate = [dataToTranslate];
			}
			dataToTranslate.forEach((tData) => {
				Object.keys(langKeyData).forEach((langKey) => {
					const targetData = langKey === '_root' ? tData : tData[langKey];
					if (targetData !== undefined) {
						const targetArr = Array.isArray(targetData) ? targetData : [targetData];
						targetArr.forEach((target) => {
							const handlerFunc = langKeyData[langKey]['_handler'];
							if (handlerFunc !== undefined) {
								switch (handlerFunc) {
									case 'mapPortals':
										Object.keys(target).forEach((portalKey) => {
											let portalData = target[portalKey];
											const langID = this.getLocalID(portalData.originWorldMap) + '_' + this.getLocalID(portalData.id);
											portalData.name = this.getLangString('POI_NAME', langID);
											portalData.description = this.getLangString('POI_DESCRIPTION', langID);
										});
										break;
									case 'cartoMaps':
										// Target represents a world map
										const mapID = this.getLocalID(target.id);
										target.name = this.getLangString('WORLD_MAP_NAME', mapID);
										// Process POIs
										target.pointsOfInterest.forEach((poi) => {
											const langID = mapID + '_' + this.getLocalID(poi.id);
											poi.name = this.getLangString('POI_NAME', langID);
											poi.description = this.getLangString('POI_DESCRIPTION', langID);
										});
										break;
								}
							} else {
								Object.keys(langKeyData[langKey]).forEach((langPropID) => {
									const langProp = langKeyData[langKey][langPropID];
									if (!langProp.onlyIfExists || target[langPropID] !== undefined) {
										const langIDKey = langProp.idKey ?? 'id';
										var langIDValue;
										if (Array.isArray(target[langIDKey])) {
											// The ID key can sometimes be an array of IDs (e.g. Summoning synergies)
											langIDValue = target[langIDKey].map((id) => this.getLocalID((id ?? '').toString()));
										} else {
											langIDValue = this.getLocalID((target[langIDKey] ?? '').toString());
										}
										let langIdent = langProp.idFormat;
										if (langProp.idSpecial !== undefined) {
											// Use a special method to determine the ID format
											switch (langProp.idSpecial) {
												case 'altMagicDesc':
													langIdent = altMagicDescIDKey(target);
													break;
												case 'shopChainID':
													langIdent = this.getLocalID(shopChainPropKey(target, langPropID, 'id'));
													break;
											}
										}
										if (langIdent === undefined) {
											langIdent = langIDValue;
										} else {
											// langIdent is in a specific format
											const langTemplate = {};
											if (isSkill) {
												langTemplate.SKILLID = this.getLocalID(parentNode[nodeKey].skillID);
											}
											if (Array.isArray(langIDValue)) {
												langIDValue.forEach((val, idx) => {
													langTemplate['ID' + idx] = this.getLocalID(val);
												});
											} else {
												langTemplate.ID = langIDValue;
											}
											Object.keys(langTemplate).forEach((k) => {
												langIdent = langIdent.replaceAll('{' + k + '}', langTemplate[k]);
											});
										}

										let langCategoryKey = langProp.key;
										if (langProp.keySpecial !== undefined) {
											// Use a special method to determine the category key
											switch (langProp.keySpecial) {
												case 'shopChainKey':
													langCategoryKey = shopChainPropKey(target, langPropID, 'category');
													break;
											}
										}

										if (Array.isArray(target[langPropID])) {
											target[langPropID].forEach((targetElem, num) => {
												const langIdentFinal = langIdent.replaceAll('{NUM}', num.toString());
												const langString = this.getLangString(langCategoryKey, langIdentFinal);
												target[langPropID][num] = langString;
												if (this.debugMode) {
													if (langString !== undefined) {
														console.debug(
															'Set value of property ' +
																langPropID +
																'[' +
																num.toString() +
																'] for ' +
																langIdentFinal +
																' in node ' +
																nodeName +
																' to: ' +
																langString
														);
													} else {
														console.debug(
															'No translation: property ' +
																langPropID +
																' for ' +
																langIdentFinal +
																' in node ' +
																nodeName
														);
													}
												}
											});
										} else {
											let langString;
											if (langProp.stringSpecial !== undefined) {
												// Use a custom function to determine the string
												switch (langProp.stringSpecial) {
													case 'itemDesc':
														langString = itemDesc(target);
														break;
													case 'shopPurchaseDesc':
														langString = shopPurchaseDesc(target);
														break;
													case 'passiveDesc':
														langString = passiveDesc(target);
														break;
													case 'relicDesc':
														langString = relicDesc(target);
														break;
													case 'spAttDesc':
														langString = spAttDesc(target);
														break;
													case 'tsWorshipName':
														langString = tsWorshipName(target);
														break;
													case 'tsWorshipStatueName':
														langString = tsWorshipStatueName(target);
														break;
													case 'attackSpellbooksName':
														langString = attackSpellbooksName(target);
														break;
													case 'attackSpellName':
														langString = attackSpellName(target);
														break;
												}
											} else {
												langString = this.getLangString(langCategoryKey, langIdent);
											}
											target[langPropID] = langString;
											if (this.debugMode) {
												if (langString !== undefined) {
													console.debug(
														'Set value of property ' +
															langPropID +
															' for ' +
															langIdent +
															' in node ' +
															nodeName +
															' to: ' +
															langString
													);
												} else {
													console.debug(
														'No translation: property ' + langPropID + ' for ' + langIdent + ' in node ' + nodeName
													);
												}
											}
										}
									}
								});
							}
						});
					}
				});
			});
		}
	}
	getLangString(key, identifier) {
		let lookupVal = '';
		if (key !== undefined) {
			lookupVal = key;
		}
		if (identifier !== undefined) {
			lookupVal += (lookupVal.length > 0 ? '_' : '') + identifier;
		}
		return this.customLocalizations[lookupVal] ?? loadedLangJson[lookupVal];
	}
	getNamespacedID(namespace, ID) {
		if (ID.indexOf(':') > 0) {
			return ID;
		} else {
			return namespace + ':' + ID;
		}
	}
	getLocalID(ID) {
		if (ID !== undefined && ID.indexOf(':') > 0) {
			return ID.split(':').pop();
		} else {
			return ID;
		}
	}
}

let wd = new Wiki();
wd.printWikiData();