@reldens/game-data-generator 0.1.0

package/lib/generator/monsters-attributes-per-level.js

@@ -0,0 +1,90 @@
+/**
+ *
+ * Reldens - Game Data Generator - MonsterAttributesPerLevel
+ *
+ */
+
+const { MonstersAttributesPerLevelValidator } = require('../validator/monsters-attributes-per-level-validator');
+const { GameDataGenerator } = require('./game-data-generator');
+const { sc, Logger} = require('@reldens/utils');
+
+class MonsterAttributesPerLevel extends GameDataGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.optionsValidator = new MonstersAttributesPerLevelValidator();
+        this.typeScaleFactors = {};
+        this.monsters = {};
+        this.setReady(props);
+    }
+
+    setOptions(options)
+    {
+        // required:
+        this.monsterBase = sc.get(options, 'monsterBase', false);
+        this.typeTemplates = sc.get(options, 'typeTemplates', false);
+        this.monsterTypesVariations = sc.get(options, 'monsterTypesVariations', false);
+        this.variationsScaleFactorsMinMax = sc.get(options, 'variationsScaleFactorsMinMax', false);
+        // optional:
+        this.jsonFileName = sc.get(options, 'jsonFileName', 'monsters-attributes-per-level-'+this.currentDate+'.json');
+        this.generateFolderPath = sc.get(options, 'generateFolderPath', 'generated');
+    }
+
+    async generate()
+    {
+        this.isReady = this.validate();
+        if(!this.isReady){
+            return false;
+        }
+        // define scale factors for each monster type:
+        for (let monsterType of this.monsterTypesVariations) {
+            let factor = this.variationsScaleFactorsMinMax[monsterType];
+            this.typeScaleFactors[monsterType] = Math.random() * (factor.max - factor.min) + factor.min;
+        }
+        await this.fileHandler.createFolder(this.generateFolderPath);
+        await this.fileHandler.writeFile(
+            this.fileHandler.joinPaths(this.generateFolderPath, this.jsonFileName),
+            JSON.stringify(this.generateMonstersData())
+        );
+        Logger.info('Data saved! Check the "generated" folder.');
+    }
+
+    generateMonstersData()
+    {
+        for (let level = 1; level <= 100; level ++) {
+            this.monsters[level] = {};
+            this.generateMonster(level);
+        }
+        return this.monsters;
+    }
+
+    generateMonster(level)
+    {
+        let typesKeys = Object.keys(this.typeTemplates);
+        for (let monstersType of this.monsterTypesVariations) {
+            this.monsters[level][monstersType] = {};
+            for (let typeKey of typesKeys) {
+                this.monsters[level][monstersType][typeKey] = this.applyTemplate(typeKey, level, monstersType);
+            }
+        }
+    }
+
+    applyTemplate(typeKey, level, monsterType)
+    {
+        let base = this.monsterBase;
+        let result = {...base};
+        let scaleTypeFactor = this.typeScaleFactors[monsterType];
+        let templatesProperties = Object.keys(this.typeTemplates[typeKey]);
+        for (let key of templatesProperties) {
+            let range = this.typeTemplates[typeKey][key];
+            let scale = Math.random() * (range.max - range.min) + range.min;
+            result[key] = Math.round(base[key] * (1 + scale / 100) * (1 + level / 20) * scaleTypeFactor);
+        }
+        return result;
+    }
+
+}
+
+module.exports.MonsterAttributesPerLevel = MonsterAttributesPerLevel;

package/lib/generator/monsters-experience-per-level.js

@@ -0,0 +1,129 @@
+/**
+ *
+ * Reldens - Game Data Generator - MonstersExperiencePerLevel
+ *
+ */
+
+const { MonstersExperiencePerLevelValidator } = require('../validator/monsters-experience-per-level-validator');
+const { GameDataGenerator } = require('./game-data-generator');
+const { Logger, sc } = require('@reldens/utils');
+
+class MonstersExperiencePerLevel extends GameDataGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.optionsValidator = new MonstersExperiencePerLevelValidator();
+        this.experiencePerVariationAndLevel = {};
+        this.setReady(props);
+    }
+
+    setOptions(options)
+    {
+        // required:
+        this.levelsExperienceByKey = sc.get(options, 'levelsExperienceByKey', false);
+        this.variations = sc.get(options, 'variations', false);
+        this.decrementProportionPerLevel = sc.get(options, 'decrementProportionPerLevel', false);
+        // optional:
+        this.jsonFileName = sc.get(options, 'jsonFileName', 'monsters-experience-per-level-'+this.currentDate+'.json');
+        this.generateFolderPath = sc.get(options, 'generateFolderPath', 'generated');
+    }
+
+    async generate()
+    {
+        this.isReady = this.validate();
+        if(!this.isReady){
+            return false;
+        }
+        await this.fileHandler.createFolder(this.generateFolderPath);
+        await this.fileHandler.writeFile(
+            this.fileHandler.joinPaths(this.generateFolderPath, this.jsonFileName),
+            JSON.stringify(this.generateExperience())
+        );
+        Logger.info('Data saved! Check the "generated" folder.');
+    }
+
+    generateExperience()
+    {
+        let levelsKeys = Object.keys(this.levelsExperienceByKey);
+        let variationsKeys = Object.keys(this.variations);
+        let decrementProportion = {};
+        for (let variationKey of variationsKeys) {
+            decrementProportion[variationKey] = 0;
+        }
+        for (let levelKey of levelsKeys) {
+            this.experiencePerVariationAndLevel[levelKey] = this.levelsExperienceByKey[levelKey];
+            let reqExp = this.levelsExperienceByKey[levelKey].req;
+            for (let variationKey of variationsKeys) {
+                decrementProportion[variationKey] = Number(this.decrementProportionPerLevel[levelKey] || decrementProportion[variationKey]);
+                let newVariationValue = this.calculateVariation(this.variations[variationKey], decrementProportion[variationKey]);
+                let newVariationExperience = this.calculateExperience(newVariationValue, reqExp);
+                let previousLevel = this.experiencePerVariationAndLevel[Number(levelKey) - 1];
+                let previousExp = 0;
+                if (previousLevel) {
+                    previousExp = this.experiencePerVariationAndLevel[Number(levelKey) - 1][variationKey].exp;
+                    if(previousExp > newVariationExperience){
+                        let fixedValidation = false;
+                        for (let i = 0.9; i >= 0.1; i -= 0.1) {
+                            let testDecrementProportion = this.roundToPrecision(decrementProportion[variationKey] * i, 5);
+                            let testNewVariationValue = this.calculateVariation(this.variations[variationKey], testDecrementProportion);
+                            let testNewVariationExperience = this.calculateExperience(testNewVariationValue, reqExp);
+                            if (previousExp <= testNewVariationExperience) {
+                                Logger.warning('Level decrement fixed.', {
+                                    levelKey,
+                                    variationKey,
+                                    decrementProportion: decrementProportion[variationKey],
+                                    testDecrementProportion
+                                });
+                                decrementProportion[variationKey] = testDecrementProportion;
+                                newVariationValue = testNewVariationValue;
+                                newVariationExperience = testNewVariationExperience;
+                                fixedValidation = true;
+                                break;
+                            }
+                        }
+                        if (!fixedValidation) {
+                            Logger.warning('Level decrement not fixed.', {
+                                levelKey,
+                                variationKey,
+                                decrementProportion: decrementProportion[variationKey]
+                            });
+                        }
+                    }
+                }
+                let kills = Math.ceil(reqExp / newVariationExperience);
+                this.variations[variationKey] = newVariationValue;
+                this.experiencePerVariationAndLevel[levelKey][variationKey] = {
+                    decrementProportion: decrementProportion[variationKey],
+                    randomVariation: this.variations[variationKey],
+                    exp: this.roundToPrecision(newVariationExperience, 2),
+                    kills: kills
+                }
+            }
+        }
+        return this.experiencePerVariationAndLevel;
+    }
+
+    calculateExperience(variationValue, reqExp)
+    {
+        return this.roundToPrecision((variationValue * reqExp) / 100, 0);
+    }
+
+    calculateVariation(variationValue, decrementProportion)
+    {
+        let newVariation = this.roundToPrecision(variationValue - decrementProportion, 5);
+        if (newVariation <= 0) {
+            newVariation = variationValue;
+        }
+        return newVariation;
+    }
+
+    roundToPrecision(number, precision = 4)
+    {
+        return Number(number.toFixed(precision));
+    }
+
+}
+
+module.exports.MonstersExperiencePerLevel = MonstersExperiencePerLevel;

package/lib/generator/players-experience-per-level.js

@@ -0,0 +1,82 @@
+/**
+ *
+ * Reldens - Game Data Generator - PlayersExperiencePerLevel
+ *
+ */
+
+const { PlayersExperiencePerLevelValidator } = require('../validator/players-experience-per-level-validator');
+const { GameDataGenerator } = require('./game-data-generator');
+const { Logger, sc } = require('@reldens/utils');
+
+class PlayersExperiencePerLevel extends GameDataGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.optionsValidator = new PlayersExperiencePerLevelValidator();
+        this.levels = {};
+        this.setReady(props);
+    }
+
+    setOptions(options)
+    {
+        // required:
+        // experience required to reach level 2 from level 1 (example: 10):
+        this.startExp = sc.get(options, 'startExp', false);
+        // initial growth per level (example: 1.1):
+        this.baseGrowthFactor = sc.get(options, 'baseGrowthFactor', false);
+        // maximum level you want to calculate up to (example: 100):
+        this.maxLevel = sc.get(options, 'maxLevel', false);
+        // optional:
+        // increase in growth factor per level (example: 0.01):
+        this.growthIncrease = sc.get(options, 'growthIncrease', 0);
+        this.jsonFileName = sc.get(options, 'jsonFileName', 'players-experience-per-level-'+this.currentDate+'.json');
+        this.generateFolderPath = sc.get(options, 'generateFolderPath', 'generated');
+        this.baseGrowthFactorPerLevel = sc.get(options, 'baseGrowthFactorPerLevel', {});
+    }
+
+    async generate()
+    {
+        this.isReady = this.validate();
+        if(!this.isReady){
+            return;
+        }
+        await this.fileHandler.createFolder(this.generateFolderPath);
+        await this.fileHandler.writeFile(
+            this.fileHandler.joinPaths(this.generateFolderPath, this.jsonFileName),
+            JSON.stringify(this.calculateLevelExpDynamicGrowth())
+        );
+        Logger.info('Data saved! Check the "generated" folder.');
+    }
+
+    calculateLevelExpDynamicGrowth()
+    {
+        let totalExp = 0;
+        let growthFactor = this.baseGrowthFactor;
+        for (let level = 1; level <= this.maxLevel; level++) {
+            if (level === 1) {
+                totalExp = this.startExp;
+                this.levels[level] = {req: this.startExp, total: this.startExp, growthFactor: growthFactor};
+
+                continue;
+            }
+            growthFactor = this.roundToPrecision(this.baseGrowthFactorPerLevel[level] || growthFactor);
+            let previousLevelReqExp = this.levels[level - 1].req;
+            let reqExp = Math.floor(previousLevelReqExp * growthFactor);
+            // increase the growth factor for the next level:
+            growthFactor = this.roundToPrecision(growthFactor + this.growthIncrease);
+            totalExp += reqExp;
+            this.levels[level] = {diff: reqExp - previousLevelReqExp, req: reqExp, total: totalExp, growthFactor};
+        }
+        return this.levels;
+    }
+
+    roundToPrecision(number, precision = 4)
+    {
+        return Number(number.toFixed(precision));
+    }
+
+}
+
+module.exports.PlayersExperiencePerLevel = PlayersExperiencePerLevel;

package/lib/validator/monsters-attributes-per-level-validator.js

@@ -0,0 +1,33 @@
+/**
+ *
+ * Reldens - Game Data Generator - MonstersAttributesPerLevelValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class MonstersAttributesPerLevelValidator
+{
+    validate(options)
+    {
+        if(!sc.get(options, 'monsterBase')){
+            Logger.error('Missing required option: "monsterBase".');
+            return false;
+        }
+        if(!sc.get(options, 'typeTemplates')){
+            Logger.error('Missing required option: "typeTemplates".');
+            return false;
+        }
+        if(!sc.get(options, 'monsterTypesVariations')){
+            Logger.error('Missing required option: "monsterTypesVariations".');
+            return false;
+        }
+        if(!sc.get(options, 'variationsScaleFactorsMinMax')){
+            Logger.error('Missing required option: "variationsScaleFactorsMinMax".');
+            return false;
+        }
+        return true;
+    }
+}
+
+module.exports.MonstersAttributesPerLevelValidator = MonstersAttributesPerLevelValidator;

package/lib/validator/monsters-experience-per-level-validator.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * Reldens - Game Data Generator - MonstersExperiencePerLevelValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class MonstersExperiencePerLevelValidator
+{
+    validate(options)
+    {
+        if(!sc.get(options, 'levelsExperienceByKey')){
+            Logger.error('Missing required option: "levelsExperienceByKey".');
+            return false;
+        }
+        if(!sc.get(options, 'variations')){
+            Logger.error('Missing required option: "variations".');
+            return false;
+        }
+        if(!sc.get(options, 'decrementProportionPerLevel')){
+            Logger.error('Missing required option: "decrementProportionPerLevel".');
+            return false;
+        }
+        return true;
+    }
+}
+
+module.exports.MonstersExperiencePerLevelValidator = MonstersExperiencePerLevelValidator;

package/lib/validator/players-experience-per-level-validator.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * Reldens - Game Data Generator - PlayersExperiencePerLevelValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class PlayersExperiencePerLevelValidator
+{
+    validate(options)
+    {
+        if(!sc.get(options, 'startExp')){
+            Logger.error('Missing required option: "startExp".');
+            return false;
+        }
+        if(!sc.get(options, 'baseGrowthFactor')){
+            Logger.error('Missing required option: "baseGrowthFactor".');
+            return false;
+        }
+        if(!sc.get(options, 'maxLevel')){
+            Logger.error('Missing required option: "maxLevel".');
+            return false;
+        }
+        return true;
+    }
+}
+
+module.exports.PlayersExperiencePerLevelValidator = PlayersExperiencePerLevelValidator;

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@reldens/game-data-generator",
+    "scope": "@reldens",
+    "version": "0.1.0",
+    "description": "Reldens - Game Data Generator",
+    "author": "Damian A. Pastorini",
+    "license": "MIT",
+    "homepage": "https://github.com/damian-pastorini/game-data-generator",
+    "source": true,
+    "main": "index.js",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/damian-pastorini/game-data-generator.git"
+    },
+    "keywords": [
+        "reldens",
+        "game",
+        "data",
+        "generate",
+        "generator",
+        "random",
+        "nodejs",
+        "javascript",
+        "js",
+        "rpg",
+        "multiplayer",
+        "npc",
+        "player",
+        "enemy",
+        "enemies",
+        "level",
+        "experience"
+    ],
+    "bugs": {
+        "url": "https://github.com/damian-pastorini/game-data-generator/issues"
+    },
+    "dependencies": {
+        "@reldens/utils": "^0.23.0"
+    }
+}