Fixes MattGibney#5 proficiency points

Author: Rihoj

apps/api/db/migrations/20241206041052_proficiency_points.js

@@ -0,0 +1,17 @@
+exports.up = function(knex) {
+  return knex.schema.alterTable('players', function (table) {
+    table.jsonb('proficiencyPoints').defaultTo({
+      strength: 0,
+      constitution: 0,
+      wealth: 0,
+      dexterity: 0,
+      charisma: 0,
+    });
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.alterTable('players', function (table) { 
+    table.dropColumn('proficiencyPoints');
+  });
+}

apps/api/src/controllers/player.ts

@@ -128,4 +128,30 @@ export default {
     );
     res.status(200).json(await player.serialise());
   }),
+
+  POST_proficiencyPoints: protectPrivateAPI(
+    async (req: Request, res: Response) => {
+      // body is { playerID: string, points: number }
+      console.log('req.body', req.body);
+      const { playerID, points } = req.body;
+      const player = await req.ctx.modelFactory.player.fetchByID(
+        req.ctx,
+        playerID,
+      );
+      if (!player) {
+        res.status(404).json({
+          errors: [
+            {
+              code: 'player_not_found',
+              title: 'Player not found',
+            },
+          ],
+        });
+        return;
+      }
+
+      await player.upgradeProficiencyPoints(points);
+      res.status(200).json(await player.serialise());
+    },
+  ),
 };

apps/api/src/controllers/structures.ts

@@ -2,6 +2,7 @@ import { Request, Response } from 'express';
 import { APIError } from '@darkthrone/client-library';
 import { protectPrivateAPI } from '../middleware/protectAuthenticatedRoutes';
 import { structureUpgrades } from '@darkthrone/game-data';
+import { applyBonuses, getCostModifier } from '../lib/bonusHelper';
 
 export default {
   POST_upgradeStructure: protectPrivateAPI(
@@ -49,7 +50,9 @@ export default {
         }
       }
 
-      if (req.ctx.authedPlayer.gold < nextStructureUpgrade.cost) {
+      const bonus = getCostModifier(req.ctx.authedPlayer);
+      const cost = applyBonuses(false, nextStructureUpgrade.cost, bonus);
+      if (req.ctx.authedPlayer.gold < Math.floor(cost)) {
         res.status(400).send({
           errors: [
             {

apps/api/src/daos/player.ts

@@ -22,6 +22,13 @@ export type PlayerRow = {
     fortification: number;
     housing: number;
   };
+  proficiencyPoints: {
+    strength: number;
+    constitution: number;
+    wealth: number;
+    dexterity: number;
+    charisma: number;
+  };
 };
 
 export default class PlayerDao {

apps/api/src/lib/bonusHelper.ts

@@ -0,0 +1,52 @@
+import { classBonuses, raceBonuses } from '@darkthrone/game-data';
+import PlayerModel from '../models/player';
+
+export function getAttackModifier(player: PlayerModel): number {
+  let bonus = 0;
+  bonus += raceBonuses[player.race]?.offense || 0;
+  bonus += classBonuses[player.class]?.offense || 0;
+  bonus += player.proficiencyPoints.strength;
+  return bonus;
+}
+
+export function getIncomeModifier(player: PlayerModel): number {
+  let bonus = 0;
+  bonus += raceBonuses[player.race]?.income || 0;
+  bonus += classBonuses[player.class]?.income || 0;
+  bonus += player.proficiencyPoints.wealth;
+  return bonus;
+}
+
+export function getCostModifier(player: PlayerModel): number {
+  let bonus = 0;
+  bonus += player.proficiencyPoints.charisma;
+  return bonus;
+}
+
+export function getDefenseModifier(player: PlayerModel): number {
+  let bonus = 0;
+  bonus += raceBonuses[player.race]?.defense || 0;
+  bonus += classBonuses[player.class]?.defense || 0;
+  bonus += player.fortification.defenseBonusPercentage;
+  bonus += player.proficiencyPoints.constitution;
+  return bonus;
+}
+
+export function calculateIntBonus(
+  isAdditive: boolean,
+  ...bonuses: number[]
+): number {
+  let total = 0;
+  bonuses.reduce((_acc, bonus) => (total += bonus), 0);
+  isAdditive ? (total = 100 + total) : (total = 100 - total);
+  return total;
+}
+
+export function applyBonuses(
+  isAdditive: boolean,
+  stat: number,
+  ...bonus: number[]
+): number {
+  const bonusInt = calculateIntBonus(isAdditive, ...bonus);
+  return Math.floor(stat * bonusInt) / 100;
+}

apps/api/src/models/player.ts

@@ -23,6 +23,13 @@ import {
 } from '@darkthrone/game-data';
 import { getRandomNumber } from '../utils';
 import { Paginator } from '../lib/paginator';
+import {
+  getAttackModifier,
+  getDefenseModifier as getDefenseModifier,
+  getIncomeModifier,
+  getCostModifier,
+  applyBonuses,
+} from '../lib/bonusHelper';
 
 export default class PlayerModel {
   private ctx: Context;
@@ -44,14 +51,20 @@ export default class PlayerModel {
     fortification: number;
     housing: number;
   };
+  public proficiencyPoints: {
+    strength: number;
+    constitution: number;
+    wealth: number;
+    dexterity: number;
+    charisma: number;
+  };
 
   public units: PlayerUnitsModel[];
 
   constructor(ctx: Context, data: PlayerRow, units: PlayerUnitsModel[]) {
     this.ctx = ctx;
-
-    this.populateFromRow(data);
     this.units = units;
+    this.populateFromRow(data);
   }
 
   async serialise(): Promise<PlayerObject | AuthedPlayerObject> {
@@ -74,14 +87,14 @@ export default class PlayerModel {
     if (!isAuthed) return playerObject;
 
     const attackStrength = await this.calculateAttackStrength();
-    const defenceStrength = await this.calculateDefenceStrength();
+    const defenseStrength = await this.calculateDefenseStrength();
 
     const date24HoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
     const depositHistory = await this.fetchBankHistory(date24HoursAgo);
 
     const authedPlayerObject: AuthedPlayerObject = Object.assign(playerObject, {
       attackStrength: attackStrength,
-      defenceStrength: defenceStrength,
+      defenseStrength: defenseStrength,
       attackTurns: this.attackTurns,
       experience: this.experience,
       goldInBank: this.goldInBank,
@@ -96,6 +109,8 @@ export default class PlayerModel {
         quantity: unit.quantity,
       })),
       structureUpgrades: this.structureUpgrades,
+      proficiencyPoints: this.proficiencyPoints,
+      remainingProficiencyPoints: this.proficiencyPointsRemaining,
     });
 
     return authedPlayerObject;
@@ -151,13 +166,50 @@ export default class PlayerModel {
     return fortificationUpgrades[this.structureUpgrades.fortification];
   }
 
+  get proficiencyPointsTotal(): number {
+    return Object.values(this.proficiencyPoints).reduce(
+      (acc, points) => acc + points,
+      0,
+    );
+  }
+
+  get proficiencyPointsRemaining(): number {
+    // The player gets 1 proficiency point per level
+    // Since the player starts at level 1, we subtract 1 from the level
+    return this.level - 1 - this.proficiencyPointsTotal;
+  }
+
+  async upgradeProficiencyPoints(points: {
+    strength: number;
+    constitution: number;
+    wealth: number;
+    dexterity: number;
+    charisma: number;
+  }) {
+    this.ctx.logger.debug({ points }, 'Upgrading proficiency points');
+    const totalPoints = Object.values(points).reduce(
+      (acc, point) => acc + point,
+      0,
+    );
+
+    if (totalPoints > this.proficiencyPointsRemaining) {
+      throw new Error('Not enough proficiency points');
+    }
+
+    this.proficiencyPoints = points;
+    console.log('this.proficiencyPoints', this.proficiencyPoints);
+    await this.save();
+    console.log('this.proficiencyPoints', this.proficiencyPoints);
+  }
+
   async upgradeStructure(
     type: keyof typeof structureUpgrades,
     desiredUpgrade: StructureUpgrade,
   ) {
     this.ctx.logger.debug({ type }, 'Upgrading structure');
-
-    this.gold -= desiredUpgrade.cost;
+    const bonus = getCostModifier(this);
+    const cost = applyBonuses(false, desiredUpgrade.cost, bonus);
+    this.gold -= Math.floor(cost);
     this.structureUpgrades[type] += 1;
 
     this.save();
@@ -168,47 +220,29 @@ export default class PlayerModel {
       (acc, unit) => acc + unit.calculateAttackStrength(),
       0,
     );
-    if (this.race === 'human' || this.race === 'undead') {
-      // Humans and Undead get a 5% bonus to attack strength
-      offense *= 1.05;
-    }
-    if (this.class === 'fighter') {
-      // Fighters get a 5% bonus to attack strength
-      offense *= 1.05;
-    }
+    const bonus = getAttackModifier(this);
+    offense = applyBonuses(true, offense, bonus);
     return Math.floor(offense);
   }
 
-  async calculateDefenceStrength(): Promise<number> {
-    let defence = this.units.reduce(
-      (acc, unit) => acc + unit.calculateDefenceStrength(),
+  async calculateDefenseStrength(): Promise<number> {
+    let defense = this.units.reduce(
+      (acc, unit) => acc + unit.calculateDefenseStrength(),
       0,
     );
-    if (this.race === 'elf' || this.race === 'goblin') {
-      // Elves and Goblins get a 5% bonus to defence strength
-      defence *= 1.05;
-    }
-    if (this.class === 'cleric') {
-      // Clerics get a 5% bonus to defence strength
-      defence *= 1.05;
-    }
-
-    const fortificationBonus = this.fortification.defenceBonusPercentage;
-    defence *= 1 + fortificationBonus / 100;
-
-    return Math.floor(defence);
+    const bonus = getDefenseModifier(this);
+    defense = applyBonuses(true, defense, bonus);
+    return Math.floor(defense);
   }
 
   async calculateGoldPerTurn(): Promise<number> {
     let goldPerTurn = this.units.reduce(
       (acc, unit) => acc + unit.calculateGoldPerTurn(),
       0,
     );
-    if (this.class === 'thief') {
-      // Thieves get a 5% bonus to gold per turn
-      goldPerTurn *= 1.05;
-    }
 
+    const bonus = getIncomeModifier(this);
+    goldPerTurn = applyBonuses(true, goldPerTurn, bonus);
     const fortificationGoldPerTurn = this.fortification.goldPerTurn;
     goldPerTurn += fortificationGoldPerTurn;
 
@@ -233,12 +267,12 @@ export default class PlayerModel {
     const warHistoryID = `WRH-${ulid()}`;
 
     const playerAttackStrength = await this.calculateAttackStrength();
-    const targetPlayerDefenceStrength =
-      await targetPlayer.calculateDefenceStrength();
+    const targetPlayerDefenseStrength =
+      await targetPlayer.calculateDefenseStrength();
 
     const isVictor = this.determineIsVictor(
       playerAttackStrength,
-      targetPlayerDefenceStrength,
+      targetPlayerDefenseStrength,
     );
 
     // Calculate XP
@@ -259,7 +293,7 @@ export default class PlayerModel {
         attack_turns_used: attackTurns,
         is_attacker_victor: false,
         attacker_strength: playerAttackStrength,
-        defender_strength: targetPlayerDefenceStrength,
+        defender_strength: targetPlayerDefenseStrength,
         gold_stolen: 0,
         created_at: new Date(),
         attacker_experience: 0,
@@ -291,7 +325,7 @@ export default class PlayerModel {
       attack_turns_used: attackTurns,
       is_attacker_victor: true,
       attacker_strength: playerAttackStrength,
-      defender_strength: targetPlayerDefenceStrength,
+      defender_strength: targetPlayerDefenseStrength,
       gold_stolen: winnings,
       created_at: new Date(),
       attacker_experience: victorExperience,
@@ -311,6 +345,7 @@ export default class PlayerModel {
         experience: this.experience,
         overall_rank: this.overallRank,
         structureUpgrades: this.structureUpgrades,
+        proficiencyPoints: this.proficiencyPoints,
       },
     );
 
@@ -335,6 +370,13 @@ export default class PlayerModel {
       fortification: row.structureUpgrades?.fortification || 0,
       housing: row.structureUpgrades?.housing || 0,
     };
+    this.proficiencyPoints = {
+      strength: row.proficiencyPoints?.strength || 0,
+      constitution: row.proficiencyPoints?.constitution || 0,
+      wealth: row.proficiencyPoints?.wealth || 0,
+      dexterity: row.proficiencyPoints?.dexterity || 0,
+      charisma: row.proficiencyPoints?.charisma || 0,
+    };
   }
 
   static async fetchAllForUser(ctx: Context, user: UserModel) {

apps/api/src/models/playerUnits.ts

@@ -32,8 +32,8 @@ export default class PlayerUnitsModel {
     return UnitTypes[this.unitType].attack * this.quantity;
   }
 
-  calculateDefenceStrength(): number {
-    return UnitTypes[this.unitType].defence * this.quantity;
+  calculateDefenseStrength(): number {
+    return UnitTypes[this.unitType].defense * this.quantity;
   }
 
   calculateGoldPerTurn(): number {

apps/api/src/router.ts

@@ -68,4 +68,7 @@ router.post('/bank/withdraw', BankingController.POST_withdraw);
 // Structures
 router.post('/structures/upgrade', StructuresController.POST_upgradeStructure);
 
+// ProficiencyPoints
+router.post('/proficiency-points', PlayersController.POST_proficiencyPoints);
+
 export default router;