feat: migrate JavaScript files to TypeScript, enhancing type safety and maintainability across the codebase

src/systems/StealthSystem.ts

@@ -0,0 +1,86 @@
+import { System } from '../core/System.ts';
+import { SystemName, ComponentType } from '../core/Constants.ts';
+import type { Entity } from '../core/Entity.ts';
+import type { Stealth } from '../components/Stealth.ts';
+import type { Velocity } from '../components/Velocity.ts';
+import type { Combat } from '../components/Combat.ts';
+import type { Evolution } from '../components/Evolution.ts';
+import type { InputSystem } from './InputSystem.ts';
+import type { PlayerControllerSystem } from './PlayerControllerSystem.ts';
+
+/**
+ * System responsible for managing stealth mechanics, including visibility updates based on form, movement, and combat.
+ */
+export class StealthSystem extends System {
+  constructor() {
+    super(SystemName.STEALTH);
+    this.requiredComponents = [ComponentType.STEALTH];
+    this.priority = 12;
+  }
+
+  /**
+   * Update stealth state for entities, handling toggle input and form-specific visibility changes.
+   * @param deltaTime - Time elapsed since last frame in seconds
+   * @param entities - Entities matching active required components
+   */
+  process(deltaTime: number, entities: Entity[]): void {
+    const inputSystem = this.engine.systems.find((s) => s.name === SystemName.INPUT) as
+      | InputSystem
+      | undefined;
+    const playerController = this.engine.systems.find(
+      (s) => s.name === SystemName.PLAYER_CONTROLLER
+    ) as PlayerControllerSystem | undefined;
+    const player = playerController ? playerController.getPlayerEntity() : null;
+
+    entities.forEach((entity) => {
+      const stealth = entity.getComponent<Stealth>(ComponentType.STEALTH);
+      const velocity = entity.getComponent<Velocity>(ComponentType.VELOCITY);
+      const combat = entity.getComponent<Combat>(ComponentType.COMBAT);
+      const evolution = entity.getComponent<Evolution>(ComponentType.EVOLUTION);
+
+      if (!stealth) return;
+
+      if (evolution) {
+        const form = evolution.getDominantForm();
+        stealth.stealthType = form;
+      }
+
+      if (entity === player && inputSystem) {
+        const shiftPress = inputSystem.isKeyJustPressed('shift');
+        if (shiftPress) {
+          if (stealth.isStealthed) {
+            stealth.exitStealth();
+          } else {
+            stealth.enterStealth(stealth.stealthType);
+          }
+        }
+      }
+
+      const isMoving = velocity && (Math.abs(velocity.vx) > 1 || Math.abs(velocity.vy) > 1);
+      const isInCombat = combat && combat.isAttacking;
+
+      stealth.updateStealth(isMoving || false, isInCombat || false);
+
+      if (stealth.isStealthed) {
+        switch (stealth.stealthType) {
+          case 'slime':
+            if (!isMoving) {
+              stealth.visibility = Math.max(0.05, stealth.visibility - deltaTime * 0.2);
+            }
+            break;
+          case 'beast':
+            if (isMoving && velocity) {
+              const speed = Math.sqrt(velocity.vx * velocity.vx + velocity.vy * velocity.vy);
+              if (speed < 50) {
+                stealth.visibility = Math.max(0.1, stealth.visibility - deltaTime * 0.1);
+              }
+            }
+            break;
+          case 'human':
+            stealth.visibility = Math.max(0.2, stealth.visibility - deltaTime * 0.05);
+            break;
+        }
+      }
+    });
+  }
+}