@reldens/game-data-generator 0.1.0 → 0.2.0

package/examples/{generate-monsters-attributes-per-level.js → generate-attributes-per-level.js}

@@ -4,10 +4,10 @@
  *
  */
 
-const { MonsterAttributesPerLevel } = require('../lib/generator/monsters-attributes-per-level');
+const { AttributesPerLevel } = require('../lib/generator/attributes-per-level');
 
-let monstersExperiencePerLevel = new MonsterAttributesPerLevel({
-    monsterBase: {
+let attributesPerLevel = new AttributesPerLevel({
+    templateBase: {
         hp: 10,
         atk: 10,
         def: 10,
@@ -19,9 +19,9 @@ let monstersExperiencePerLevel = new MonsterAttributesPerLevel({
     },
     typeTemplates: {
         melee: {
-            hp: {min: 7, max: 20},
-            atk: {min: 7, max: 20},
-            def: {min: 7, max: 20},
+            hp: {min: 10, max: 20},
+            atk: {min: 10, max: 20},
+            def: {min: 10, max: 20},
             speed: {min: 1, max: 2},
             mAtk: {min: 1, max: 2},
             mDef: {min: 1, max: 2},
@@ -33,8 +33,8 @@ let monstersExperiencePerLevel = new MonsterAttributesPerLevel({
             atk: {min: 1, max: 2},
             def: {min: 1, max: 2},
             speed: {min: 1, max: 4},
-            mAtk: {min: 7, max: 20},
-            mDef: {min: 7, max: 20},
+            mAtk: {min: 10, max: 20},
+            mDef: {min: 10, max: 20},
             dodge: {min: 1, max: 2},
             aim: {min: 5, max: 10}
         },
@@ -49,12 +49,11 @@ let monstersExperiencePerLevel = new MonsterAttributesPerLevel({
             aim: {min: 7, max: 20}
         }
     },
-    variationsScaleFactorsMinMax: {
+    typesVariations: {
         monsterA: {min: 1, max: 1.5},
         monsterB: {min: 1.5, max: 1.8},
         boss: {min: 2.5, max: 3.5}
-    },
-    monsterTypesVariations: ['monsterA', 'monsterB', 'boss']
+    }
 });
 
-monstersExperiencePerLevel.generate();
+attributesPerLevel.generate();

package/lib/generator/{monsters-attributes-per-level.js → attributes-per-level.js}

@@ -4,31 +4,31 @@
  *
  */
 
-const { MonstersAttributesPerLevelValidator } = require('../validator/monsters-attributes-per-level-validator');
+const { AttributesPerLevelValidator } = require('../validator/attributes-per-level-validator');
 const { GameDataGenerator } = require('./game-data-generator');
-const { sc, Logger} = require('@reldens/utils');
+const { Logger, sc } = require('@reldens/utils');
 
-class MonsterAttributesPerLevel extends GameDataGenerator
+class AttributesPerLevel extends GameDataGenerator
 {
 
     constructor(props)
     {
         super();
-        this.optionsValidator = new MonstersAttributesPerLevelValidator();
+        this.optionsValidator = new AttributesPerLevelValidator();
         this.typeScaleFactors = {};
-        this.monsters = {};
+        this.variations = {};
         this.setReady(props);
     }
 
     setOptions(options)
     {
         // required:
-        this.monsterBase = sc.get(options, 'monsterBase', false);
+        this.templateBase = sc.get(options, 'templateBase', false);
         this.typeTemplates = sc.get(options, 'typeTemplates', false);
-        this.monsterTypesVariations = sc.get(options, 'monsterTypesVariations', false);
-        this.variationsScaleFactorsMinMax = sc.get(options, 'variationsScaleFactorsMinMax', false);
+        this.typesVariations = sc.get(options, 'typesVariations', false);
         // optional:
-        this.jsonFileName = sc.get(options, 'jsonFileName', 'monsters-attributes-per-level-'+this.currentDate+'.json');
+        this.maxLevel = sc.get(options, 'maxLevel', 100);
+        this.jsonFileName = sc.get(options, 'jsonFileName', 'attributes-per-level-'+this.currentDate+'.json');
         this.generateFolderPath = sc.get(options, 'generateFolderPath', 'generated');
     }
 
@@ -39,9 +39,9 @@ class MonsterAttributesPerLevel extends GameDataGenerator
             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;
+        for (let variationType of Object.keys(this.typesVariations)) {
+            let factor = this.typesVariations[variationType];
+            this.typeScaleFactors[variationType] = Math.random() * (factor.max - factor.min) + factor.min;
         }
         await this.fileHandler.createFolder(this.generateFolderPath);
         await this.fileHandler.writeFile(
@@ -53,38 +53,38 @@ class MonsterAttributesPerLevel extends GameDataGenerator
 
     generateMonstersData()
     {
-        for (let level = 1; level <= 100; level ++) {
-            this.monsters[level] = {};
+        for (let level = 1; level <= this.maxLevel; level ++) {
+            this.variations[level] = {};
             this.generateMonster(level);
         }
-        return this.monsters;
+        return this.variations;
     }
 
     generateMonster(level)
     {
         let typesKeys = Object.keys(this.typeTemplates);
-        for (let monstersType of this.monsterTypesVariations) {
-            this.monsters[level][monstersType] = {};
+        for (let variationType of Object.keys(this.typesVariations)) {
+            this.variations[level][variationType] = {};
             for (let typeKey of typesKeys) {
-                this.monsters[level][monstersType][typeKey] = this.applyTemplate(typeKey, level, monstersType);
+                this.variations[level][variationType][typeKey] = this.applyTemplate(typeKey, level, variationType);
             }
         }
     }
 
-    applyTemplate(typeKey, level, monsterType)
+    applyTemplate(typeKey, level, variationType)
     {
-        let base = this.monsterBase;
+        let base = this.templateBase;
         let result = {...base};
-        let scaleTypeFactor = this.typeScaleFactors[monsterType];
+        let scaleTypeFactor = this.typeScaleFactors[variationType];
         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);
+            result[key] = Math.round(base[key] * (1 + scale / 100) * (1 + level / scale) * scaleTypeFactor);
         }
         return result;
     }
 
 }
 
-module.exports.MonsterAttributesPerLevel = MonsterAttributesPerLevel;
+module.exports.AttributesPerLevel = AttributesPerLevel;

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/game-data-generator",
     "scope": "@reldens",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "Reldens - Game Data Generator",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -29,7 +29,9 @@
         "enemy",
         "enemies",
         "level",
-        "experience"
+        "experience",
+        "stats",
+        "attribute"
     ],
     "bugs": {
         "url": "https://github.com/damian-pastorini/game-data-generator/issues"