Define HP calculations

package.json

@@ -41,7 +41,7 @@
     "redux": "3.6.0",
     "redux-create-reducer": "1.1.1",
     "redux-thunk": "2.1.0",
-    "rpgparameter": "2.0.2",
+    "rpgparameter": "2.1.0",
     "run-sequence": "1.2.2",
     "sanitize.css": "4.1.0",
     "string": "3.3.3",

src/lib/parameters.js

@@ -0,0 +1,15 @@
+const rpgparameter = require('rpgparameter');
+
+const { PARAMETERS } = require('../immutable/constants');
+
+
+const maxHitPoints = rpgparameter.createIntegerParameterShape({
+  min: PARAMETERS.MIN_MAX_HIT_POINTS,
+  max: PARAMETERS.MAX_MAX_HIT_POINTS,
+  defaultValue: PARAMETERS.MIN_MAX_HIT_POINTS,
+});
+
+
+module.exports = {
+  maxHitPoints,
+};

src/state-models/unit.js

@@ -32,13 +32,12 @@ const uuidV4 = require('uuid/v4');
 const { FACTION_TYPES, FRIENDSHIP_TYPES, PARAMETERS } = require('../immutable/constants');
 const { ACT_IDS, acts } = require('../immutable/acts');
 const { JOB_IDS, jobs } = require('../immutable/jobs');
+const parameters = require('../lib/parameters');
 const { createNewPlacementState } = require('./placement');
 const { areSameLocations, performPseudoVectorAddition } = require('./location');
 
 
 const createNewUnitState = () => {
-  const maxHitPoints = PARAMETERS.MIN_MAX_HIT_POINTS;
-
   return {
     uid: uuidV4(),
     factionType: null,
@@ -47,8 +46,8 @@ const createNewUnitState = () => {
     location: null,
     destinations: [],
     destinationIndex: 0,
-    maxHitPoints,
-    hitPoints: maxHitPoints,
+    hitPoints: parameters.maxHitPoints.min,
+    fixedMaxHitPoints: null,
     movingSpeed: 0,
     actionPoints: 0,
     maxActionPoints: 20,  // TODO: Temporary setting
@@ -102,6 +101,53 @@ const getIconId = (unit) => {
   return getJob(unit).iconId;
 };
 
+const getMaxHitPoints = (unit) => {
+  // TODO
+  return unit.fixedMaxHitPoints || 10;
+};
+
+const calculateUpdateHitPoints = (unit, nextHp) => {
+  return clamp(nextHp, 0, getMaxHitPoints(unit));
+};
+
+const calculateHealing = (unit, points) => {
+  const actualPoints = Math.max(0, points);
+
+  return {
+    hitPoints: calculateUpdateHitPoints(unit, unit.hitPoints + actualPoints),
+    healingPoints: actualPoints,
+  };
+};
+
+const calculateHealingByRate = (unit, rate) => {
+  return calculateHealing(unit, Math.ceil(getMaxHitPoints(unit) * rate));
+};
+
+const calculateDamage = (unit, points) => {
+  const actualPoints = Math.max(0, points);
+
+  return {
+    hitPoints: calculateUpdateHitPoints(unit, unit.hitPoints - actualPoints),
+    damagePoints: actualPoints,
+  };
+};
+
+const calculateDamageByRate = (unit, rate) => {
+  return calculateDamage(unit, Math.ceil(getMaxHitPoints(unit) * rate));
+};
+
+const isFullHitPoints = (unit) => {
+  return unit.hitPoints === getMaxHitPoints(unit);
+}
+
+const isDead = (unit) => {
+  return unit.hitPoints === 0;
+}
+
+const isAlive = (unit) => {
+  return !isDead(unit);
+}
+
 const canSortieAsAlly = (ally) => {
   if (!isAlly(ally)) {
     throw new Error(`It is not a ally`);
@@ -193,14 +239,22 @@ module.exports = {
   calculateActionPointsConsumption,
   calculateActionPointsRecovery,
   calculateMovementResults,
+  calculateDamage,
+  calculateDamageByRate,
+  calculateHealing,
+  calculateHealingByRate,
   canDoAct,
   canRetreatAsAlly,
   canSortieAsAlly,
   createNewAllyState,
   createNewEnemyState,
   createNewUnitState,
   determineFriendship,
+  isAlive,
   isAlly,
+  isDead,
+  isFullHitPoints,
   getAct,
   getIconId,
+  getMaxHitPoints,
 };

test/reducers/allies.js

@@ -32,16 +32,16 @@ describe('reducers/allies', () => {
 
     it('can update the specified ally', () => {
       const newFirstAlly = Object.assign({}, state[0], {
-        maxHitPoints: 100,
+        hitPoints: 100,
       });
 
       const newState = reduceAllies(state, {
         type: ACTION_TYPES.UPDATE_ALLY,
         ally: newFirstAlly,
       });
 
-      assert.strictEqual(state[0].maxHitPoints, 1);
-      assert.strictEqual(newState[0].maxHitPoints, 100);
+      assert.strictEqual(state[0].hitPoints, 1);
+      assert.strictEqual(newState[0].hitPoints, 100);
     });
 
     it('should throw a error if the specified ally does not exist', () => {

test/state-models/unit.js

@@ -4,11 +4,19 @@ const { FACTION_TYPES } = require('../../src/immutable/constants');
 const locationMethods = require('../../src/state-models/location');
 const {
   calculateActionPointsRecovery,
+  calculateDamage,
+  calculateDamageByRate,
+  calculateHealing,
+  calculateHealingByRate,
   calculateMovementResults,
   createNewAllyState,
   createNewEnemyState,
   createNewUnitState,
   determineFriendship,
+  getMaxHitPoints,
+  isAlive,
+  isDead,
+  isFullHitPoints,
 } = require('../../src/state-models/unit');
 
 
@@ -93,4 +101,153 @@ describe('state-models/unit', () => {
       );
     });
   });
+
+  describe('parameters', () => {
+    it('getMaxHitPoints', () => {
+      assert(getMaxHitPoints(unit) > 0);
+
+      unit.fixedMaxHitPoints = 5;
+      assert.strictEqual(getMaxHitPoints(unit), 5);
+    });
+
+    it('calculateHealing', () => {
+      unit.fixedMaxHitPoints = 10;
+      unit.hitPoints = 1;
+
+      assert.deepStrictEqual(calculateHealing(unit, 0), {
+        hitPoints: 1,
+        healingPoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateHealing(unit, -1), {
+        hitPoints: 1,
+        healingPoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateHealing(unit, 1), {
+        hitPoints: 2,
+        healingPoints: 1,
+      });
+
+      assert.deepStrictEqual(calculateHealing(unit, 9), {
+        hitPoints: 10,
+        healingPoints: 9,
+      });
+
+      assert.deepStrictEqual(calculateHealing(unit, 10), {
+        hitPoints: 10,
+        healingPoints: 10,
+      });
+    });
+
+    it('calculateHealingByRate', () => {
+      unit.fixedMaxHitPoints = 10;
+      unit.hitPoints = 1;
+
+      assert.deepStrictEqual(calculateHealingByRate(unit, 0.0), {
+        hitPoints: 1,
+        healingPoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateHealingByRate(unit, -1.0), {
+        hitPoints: 1,
+        healingPoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateHealingByRate(unit, 0.1), {
+        hitPoints: 2,
+        healingPoints: 1,
+      });
+
+      assert.deepStrictEqual(calculateHealingByRate(unit, 1.0), {
+        hitPoints: 10,
+        healingPoints: 10,
+      });
+
+      assert.deepStrictEqual(calculateHealingByRate(unit, 2.0), {
+        hitPoints: 10,
+        healingPoints: 20,
+      });
+    });
+
+    it('calculateDamage', () => {
+      unit.fixedMaxHitPoints = 10;
+      unit.hitPoints = 10;
+
+      assert.deepStrictEqual(calculateDamage(unit, 0), {
+        hitPoints: 10,
+        damagePoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateDamage(unit, -1), {
+        hitPoints: 10,
+        damagePoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateDamage(unit, 1), {
+        hitPoints: 9,
+        damagePoints: 1,
+      });
+
+      assert.deepStrictEqual(calculateDamage(unit, 10), {
+        hitPoints: 0,
+        damagePoints: 10,
+      });
+
+      assert.deepStrictEqual(calculateDamage(unit, 11), {
+        hitPoints: 0,
+        damagePoints: 11,
+      });
+    });
+
+    it('calculateDamageByRate', () => {
+      unit.fixedMaxHitPoints = 10;
+      unit.hitPoints = 10;
+
+      assert.deepStrictEqual(calculateDamageByRate(unit, 0.0), {
+        hitPoints: 10,
+        damagePoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateDamageByRate(unit, -1.0), {
+        hitPoints: 10,
+        damagePoints: 0,
+      });
+
+      assert.deepStrictEqual(calculateDamageByRate(unit, 0.1), {
+        hitPoints: 9,
+        damagePoints: 1,
+      });
+
+      assert.deepStrictEqual(calculateDamageByRate(unit, 1.0), {
+        hitPoints: 0,
+        damagePoints: 10,
+      });
+
+      assert.deepStrictEqual(calculateDamageByRate(unit, 2.0), {
+        hitPoints: 0,
+        damagePoints: 20,
+      });
+    });
+
+    it('isFullHitPoints', () => {
+      unit.fixedMaxHitPoints = 10;
+      unit.hitPoints = 10;
+      assert.strictEqual(isFullHitPoints(unit), true);
+
+      unit.hitPoints = 9;
+      assert.strictEqual(isFullHitPoints(unit), false);
+    });
+
+    it('isDead / isAlive', () => {
+      unit.fixedMaxHitPoints = 10;
+      unit.hitPoints = 0;
+      assert.strictEqual(isDead(unit), true);
+      assert.strictEqual(isAlive(unit), false);
+
+      unit.hitPoints = 1;
+      assert.strictEqual(isDead(unit), false);
+      assert.strictEqual(isAlive(unit), true);
+    });
+  });
 });