Add ship experience

core/archetypes/facility.ts

@@ -87,7 +87,8 @@ export function createFacility(sim: Sim, initial: InitialFacilityInput) {
     .addComponent({ name: "journal", entries: [] })
     .addComponent({
       name: "hitpoints",
-      hp: { max: 100000, regen: 0, value: 100000 },
+      hp: { base: 100000, max: 100000, regen: 0, value: 100000, modifiers: {} },
+      hitBy: {},
     })
     .addComponent({
       name: "name",

core/archetypes/ship.ts

@@ -28,6 +28,7 @@ export const shipComponents = [
   "journal",
   "model",
   "subordinates",
+  "experience",
 ] as const;
 
 export type ShipComponent = (typeof shipComponents)[number];
@@ -118,20 +119,28 @@ export function createShip(sim: Sim, initial: InitialShipInput): Ship {
     .addComponent({
       name: "hitpoints",
       hp: {
+        base: initial.hitpoints.hp.value,
         max: initial.hitpoints.hp.value,
         regen: initial.hitpoints.hp.regen,
         value: initial.hitpoints.hp.value,
+        modifiers: {},
       },
       shield: {
         max: initial.hitpoints.shield.value,
         regen: initial.hitpoints.shield.regen,
         value: initial.hitpoints.shield.value,
       },
+      hitBy: {},
     })
     .addComponent({
       ...initial.damage,
       name: "damage",
       targetId: null,
+      output: {
+        base: initial.damage.value,
+        current: initial.damage.value,
+      },
+      modifiers: {},
     })
     .addComponent({
       name: "model",
@@ -143,6 +152,11 @@ export function createShip(sim: Sim, initial: InitialShipInput): Ship {
       value: createShipName(entity.requireComponents(["model"])),
     })
     .addComponent({ name: "subordinates", ids: [] })
+    .addComponent({
+      name: "experience",
+      rank: 1,
+      amount: 0,
+    })
     .addTag("selection")
     .addTag("ship")
     .addTag(`role:${initial.role}`);

core/components/component.ts

@@ -45,6 +45,7 @@ import type { CrewRequirement } from "./crewRequirement";
 import type { Movable } from "./movable";
 import type { StorageTransfer } from "./storageTransfer";
 import type { Policies } from "./policies";
+import type { Experience } from "./experience";
 
 export interface CoreComponents {
   ai: Ai;
@@ -67,6 +68,7 @@ export interface CoreComponents {
   dockable: Dockable;
   docks: Docks;
   drive: Drive;
+  experience: Experience;
   facilityModuleBonus: FacilityModuleBonus;
   facilityModuleQueue: FacilityModuleQueue;
   hecsPosition: HECSPosition;

core/components/damage.ts

@@ -4,6 +4,19 @@ export interface Damage extends BaseComponent<"damage"> {
   cooldown: number;
   targetId: number | null;
   range: number;
-  value: number;
   angle: number;
+  modifiers: Record<string, number>;
+  output: {
+    base: number;
+    current: number;
+  };
+}
+
+export function recalculate(cp: Damage): void {
+  let multiplier = 1;
+  for (const mod of Object.values(cp.modifiers)) {
+    multiplier += mod;
+  }
+
+  cp.output.current = cp.output.base * multiplier;
 }

core/components/experience.ts

@@ -0,0 +1,32 @@
+import type { RequireComponent } from "@core/tsHelpers";
+import type { BaseComponent } from "./component";
+
+export interface Experience extends BaseComponent<"experience"> {
+  amount: number;
+  rank: number;
+}
+
+export const ranks = [200, 600, 1400, 3000, 6200, Infinity];
+
+export function getRank(exp: number): number {
+  return ranks.findIndex((threshold) => exp < threshold);
+}
+
+export function addExperience(
+  entity: RequireComponent<"experience">,
+  value: number
+): void {
+  entity.cp.experience.amount += value;
+  const newRank = getRank(entity.cp.experience.amount);
+  if (newRank > entity.cp.experience.rank) {
+    entity.cp.experience.rank = newRank;
+
+    if (entity.hasComponents(["damage"])) {
+      entity.cp.damage.modifiers.rank = 0.1 * entity.cp.experience.rank;
+    }
+    if (entity.hasComponents(["hitpoints"])) {
+      entity.cp.hitpoints.hp.modifiers.rank = 0.1 * entity.cp.experience.rank;
+    }
+    entity.addTag("recalculate:modifiers");
+  }
+}

core/components/hitpoints.ts

@@ -3,19 +3,21 @@ import type { BaseComponent } from "./component";
 
 export interface HitPoints extends BaseComponent<"hitpoints"> {
   hp: {
+    base: number;
     max: number;
     value: number;
     regen: number;
+    modifiers: Record<string, number>;
   };
   shield?: {
     max: number;
     value: number;
     regen: number;
   };
-  hit?: boolean;
+  hitBy: Record<number, number>; // entityId: timestamp
 }
 
-export function changeHp(
+export function subtractHp(
   entity: RequireComponent<"hitpoints">,
   value: number
 ): void {
@@ -25,9 +27,30 @@ export function changeHp(
       0,
       entity.cp.hitpoints.shield.value - delta
     );
-    delta -= Math.min(entity.cp.hitpoints.shield.value, value);
+    delta += Math.min(entity.cp.hitpoints.shield.value, value);
   }
 
   entity.cp.hitpoints.hp.value -= delta;
-  entity.cp.hitpoints.hit = true;
+}
+
+export function dealDamageToEntity(
+  entity: RequireComponent<"hitpoints">,
+  value: number,
+  attackerId: number
+): void {
+  subtractHp(entity, value);
+  entity.cp.hitpoints.hitBy[attackerId] = entity.sim.getTime();
+}
+
+export function recalculate(cp: HitPoints): void {
+  let multiplier = 1;
+  for (const mod of Object.values(cp.hp.modifiers)) {
+    multiplier += mod;
+  }
+
+  const diff = cp.hp.base * multiplier - cp.hp.max;
+  cp.hp.max = cp.hp.base * multiplier;
+  if (multiplier > 1) {
+    cp.hp.value += diff;
+  }
 }

core/components/masks.ts

@@ -55,6 +55,7 @@ export const componentList = [
   "movable",
   "storageTransfer",
   "policies",
+  "experience",
 ];
 export const componentMask: Record<keyof CoreComponents, bigint> =
   componentList.reduce(

core/sim/baseConfig.ts

@@ -32,6 +32,7 @@ import { fogOfWarUpdatingSystem } from "@core/systems/fogOfWarUpdating";
 import { storageTransferringSystem } from "@core/systems/storageTransferring";
 import { sectorClaimingSystem } from "@core/systems/sectorClaiming";
 import { NavigatingSystem } from "@core/systems/navigating";
+import { modifierRecalculatingSystem } from "@core/systems/modifierRecalculating";
 import type { SimConfig } from "./Sim";
 
 export const bootstrapSystems = [
@@ -56,6 +57,7 @@ export const bootstrapSystems = [
   disposableUnregisteringSystem,
   crewGrowingSystem,
   storageTransferringSystem,
+  modifierRecalculatingSystem,
 ];
 
 export const createBaseConfig = async (): Promise<SimConfig> => {

core/systems/attacking.ts

@@ -1,4 +1,4 @@
-import { changeHp } from "@core/components/hitpoints";
+import { dealDamageToEntity } from "@core/components/hitpoints";
 import settings from "@core/settings";
 import type { Sim } from "@core/sim";
 import type { RequireComponent } from "@core/tsHelpers";
@@ -142,7 +142,7 @@ export class AttackingSystem extends System {
         transport3D.hooks.shoot.notify(
           entity.requireComponents(["position", "damage"])
         );
-        changeHp(target, entity.cp.damage.value);
+        dealDamageToEntity(target, entity.cp.damage.output.current, entity.id);
         const parentEntity = entityOrParent;
 
         if (target.hasComponents(["drive", "movable"])) {

core/systems/deadUnregistering.ts

@@ -2,9 +2,18 @@ import type { Sim } from "@core/sim";
 import { dumpCargo } from "@core/components/storage";
 import type { Faction } from "@core/archetypes/faction";
 import { entityIndexer } from "@core/entityIndexer/entityIndexer";
+import type { DockSize } from "@core/components/dockable";
+import { addExperience } from "@core/components/experience";
 import { System } from "./system";
 import { transport3D } from "./transport3d";
 
+const expValues: Record<DockSize, number> = {
+  large: 200,
+  medium: 50,
+  small: 20,
+};
+const timestampThreshold = 120; // 2 minutes
+
 export class DeadUnregisteringSystem extends System {
   apply = (sim: Sim) => {
     super.apply(sim);
@@ -27,8 +36,29 @@ export class DeadUnregisteringSystem extends System {
             time: this.sim.getTime(),
           });
         }
+
         if (entity.hasComponents(["position"]))
           transport3D.hooks.explode.notify(entity);
+
+        const attackers: number[] = [];
+
+        for (const [attackerId, timestamp] of Object.entries(
+          entity.cp.hitpoints.hitBy
+        )) {
+          if (timestamp + timestampThreshold > this.sim.getTime()) {
+            attackers.push(Number(attackerId));
+          }
+        }
+
+        const exp =
+          expValues[entity.cp.dockable?.size || "small"] / attackers.length;
+        for (const attackerId of attackers) {
+          const attacker = this.sim.get(attackerId);
+          if (attacker?.hasComponents(["experience"])) {
+            addExperience(attacker, exp);
+          }
+        }
+
         entity.unregister("dead");
       }
     }

core/systems/hitpointsRegenerating.ts

@@ -29,8 +29,6 @@ export class HitpointsRegeneratingSystem extends System<"exec"> {
           entity.cp.hitpoints.shield.max
         );
       }
-
-      entity.cp.hitpoints.hit = true;
     }
   };
 }

core/systems/modifierRecalculating.ts

@@ -0,0 +1,29 @@
+import type { Sim } from "@core/sim";
+import { entityIndexer } from "@core/entityIndexer/entityIndexer";
+import { recalculate as recalculateDamage } from "@core/components/damage";
+import { recalculate as recalculateHitpoints } from "@core/components/hitpoints";
+import { System } from "./system";
+
+export class ModifierRecalculatingSystem extends System {
+  apply(sim: Sim) {
+    sim.hooks.phase.start.subscribe(
+      this.constructor.name,
+      this.recalculateModifiers.bind(this)
+    );
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  recalculateModifiers(): void {
+    for (const entity of entityIndexer.search([], ["recalculate:modifiers"])) {
+      if (entity.hasComponents(["damage"])) {
+        recalculateDamage(entity.cp.damage);
+      }
+      if (entity.hasComponents(["hitpoints"])) {
+        recalculateHitpoints(entity.cp.hitpoints);
+      }
+      entity.removeTag("recalculate:modifiers");
+    }
+  }
+}
+
+export const modifierRecalculatingSystem = new ModifierRecalculatingSystem();

core/tags.ts

@@ -20,7 +20,7 @@ const tags = [
   "ai:attack-force",
   "ai:spare",
   "ai:mission",
-  "ui:arrow",
+  "recalculate:modifiers",
   ...shipRoles.map<`role:${ShipRole}`>((role) => `role:${role}`),
   ...modules.map<`facilityModuleType:${FacilityModuleType}`>(
     ({ type: facilityModuleType }) =>

devtools/facilityModules/General.tsx

@@ -71,10 +71,10 @@ const FacilityModuleGeneralEditor: React.FC<{ index: number }> = ({
       <TableCell>
         {facilityModule.type === "military" && (
           <input
-            {...register(`facilityModules.${index}.damage.value`, {
+            {...register(`facilityModules.${index}.damage.output.current`, {
               valueAsNumber: true,
             })}
-            defaultValue={facilityModule.damage?.value}
+            defaultValue={facilityModule.damage?.output?.current}
           />
         )}
       </TableCell>

ui/components/ExperienceBar/ExperienceBar.tsx

@@ -0,0 +1,26 @@
+import { getRank, ranks } from "@core/components/experience";
+import React from "react";
+import styles from "./styles.scss";
+
+export interface ExperienceBarProps {
+  amount: number;
+}
+
+export const ExperienceBar: React.FC<ExperienceBarProps> = ({ amount }) => {
+  const rank = getRank(amount);
+  const progress = rank === 5 ? 0 : amount / ranks[rank];
+  const expLabel = rank === 5 ? "Max Rank" : `${amount}/${ranks[rank]}`;
+  const rankLabel = rank ? `Rank ${rank}` : "No Rank";
+
+  return (
+    <>
+      <div>{rankLabel}</div>
+      <div
+        className={styles.root}
+        style={{ "--percent": `${progress * 100}%` } as React.CSSProperties}
+      >
+        <span className={styles.label}>{expLabel}</span>
+      </div>
+    </>
+  );
+};