Anonymous

Module:GameData/doc: Difference between revisions

From Melvor Idle

Module:GameData/doc (view source)

Revision as of 21:01, 16 October 2022

1,394 bytes added ,  16 October 2022
Update code
(Initial creation)
 
(Update code)
Line 7: Line 7:


{{SpoilerBox|color=default|title=Code|text=<pre>// TODO:
{{SpoilerBox|color=default|title=Code|text=<pre>// TODO:
// Additional properties for some skills (e.g. Firemaking) defined within the JS its self at runtime - add from game
// Special attack description generation
// Special attack description generation
class Wiki {
class Wiki {
Line 72: Line 71:
         };
         };
         this.dataPropTransforms.langCustomDescription = this.dataPropTransforms.langHint;
         this.dataPropTransforms.langCustomDescription = this.dataPropTransforms.langHint;
        this.skillDataKeyRemaps = [
            { id: "melvorD:Woodcutting", maps: [{ from: "trees", to: "actions" }] },
            { id: "melvorD:Fishing", maps: [{ from: "fish", to: "actions" }] },
            { id: "melvorD:Firemaking", maps: [{ from: "logs", to: "actions" }] },
            { id: "melvorD:Cooking", maps: [{ from: "recipes", to: "actions" }] },
            { id: "melvorD:Mining", maps: [{ from: "rockData", to: "actions" }] },
        ];
     };
     };
     async getWikiData() {
     async getWikiData() {
Line 208: Line 199:
             });
             });
         }
         }
    }
        // Special case for skillData so that certain values initialized when the various Skill
    _Old_transformDataNode(ns, categoryName, dataNode) {
        // classes are initialized may be added here also
         if (Array.isArray(dataNode)) {
         if ((categoryName === 'skillData') && dataNode.skillID !== undefined && dataNode.data !== undefined) {
             // Recursive call to ensure all data is transformed, regardless of its depth
             // We are currently at the topmost level of a skill object
             dataNode.forEach((entity) => this.transformDataNode(ns, categoryName, entity));
             const gameSkill = game.skills.registeredObjects.get(dataNode.skillID);
 
            if (gameSkill !== undefined) {
            // Are the elements of the array objects & do these objects have IDs?
                let importKeys = [];
            // If so convert the array to an object with keys equal to those IDs
                switch(dataNode.skillID) {
            if (typeof dataNode[0] === 'object' && !Array.isArray(dataNode[0]) && Object.keys(dataNode[0]).length > 2) {
                    case 'melvorD:Firemaking':
 
                        importKeys = [
                let idKeyName = undefined;
                            'baseAshChance',
                if (dataNode[0].id !== undefined) {
                            'baseStardustChance',
                     idKeyName = "id";
                            'baseCharcoalChance'
                }
                        ];
                else if (dataNode[0].skillID !== undefined) {
                        break;
                    idKeyName = "skillID";
                    case 'melvorD:Mining':
                        importKeys = [
                            'baseInterval',
                            'baseRockHP',
                            'passiveRegenInterval'
                        ];
                        break;
                    case 'melvorD:Smithing':
                    case 'melvorD:Fletching':
                    case 'melvorD:Crafting':
                    case 'melvorD:Runecrafting':
                    case 'melvorD:Herblore':
                    case 'melvorD:Summoning':
                        importKeys = [
                            'baseInterval'
                        ];
                        break;
                    case 'melvorD:Thieving':
                        importKeys = [
                            'baseInterval',
                            'baseStunInterval',
                            'itemChance',
                            'baseAreaUniqueChance'
                        ];
                        break;
                    case 'melvorD:Agility':
                        importKeys = [
                            'obstacleUnlockLevels'
                        ];
                        break;
                    case 'melvorD:Astrology':
                        // Astrology has a number of values stored outside of gameSkill
                        const astKeys = [
                            'standardModifierLevels',
                            'uniqueModifierLevels',
                            'standardModifierCosts',
                            'uniqueModifierCosts',
                            'baseStardustChance',
                            'goldenStardustChance',
                            'baseInterval'
                        ];
                        astKeys.forEach((k) => dataNode.data[k] = Astrology[k]);
                     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'},
                        ];
                        townKeys.forEach((k) => dataNode.data[k.to] = gameSkill[k.from]);
                 }
                 }
                 if (idKeyName !== undefined) {
                 if (importKeys.length > 0) {
                     const newObj = {};
                     importKeys.forEach((k) => dataNode.data[k] = gameSkill[k]);
                    dataNode.forEach((entity) => {
                        const idKey = entity[idKeyName];
                        delete entity[idKeyName];
                        newObj[idKey] = entity;
                    });
                    if (categoryName === "items") { console.log(newObj); }
                    dataNode = newObj;
                 }
                 }
             }
             }
        }
        else if (typeof dataNode === 'object' && dataNode !== null) {
            // Iterate properties of object, checking if each should be deleted or transformed
            Object.keys(dataNode).forEach((key) => {
                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 {
                    // Check if property is to be deleted or not
                    const filterFunc = this.dataPropFilters[key];
                    if (filterFunc !== undefined && !filterFunc(categoryName, dataNode)) {
                        delete 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;
                        }
                    }
                }
            });
         }
         }
     }
     }
Retrieved from "https://testwiki.melvoridle.com/w/Special:MobileDiff/55490"