@rpgjs/server 5.0.0-alpha.27 → 5.0.0-alpha.29

package/tests/skill.spec.ts

@@ -0,0 +1,658 @@
+import { beforeEach, test, expect, afterEach, describe, vi } from "vitest";
+import { testing, TestingFixture } from "@rpgjs/testing";
+import { defineModule, createModule } from "@rpgjs/common";
+import { RpgPlayer, MAXSP, ATK, PDEF } from "../src";
+import { Effect } from "../src/Player/EffectManager";
+import type { SkillObject } from "../src/Player/SkillManager";
+
+/**
+ * Test skill object for basic skill tests
+ */
+const FireSkill = {
+  id: "fire",
+  name: "Fire",
+  description: "A basic fire spell",
+  spCost: 10,
+  hitRate: 1,
+  power: 50,
+  coefficient: { [ATK]: 0, [PDEF]: 0 },
+  _type: "skill" as const,
+};
+
+/**
+ * Test skill with high SP cost
+ */
+const UltimateSkill = {
+  id: "ultimate",
+  name: "Ultimate Strike",
+  description: "A powerful ultimate skill",
+  spCost: 100,
+  hitRate: 1,
+  power: 200,
+  coefficient: { [ATK]: 0, [PDEF]: 0 },
+  _type: "skill" as const,
+};
+
+/**
+ * Test skill with low hit rate (50% chance)
+ */
+const LowHitRateSkill = {
+  id: "low-hit-rate",
+  name: "Risky Attack",
+  description: "A skill with low success rate",
+  spCost: 5,
+  hitRate: 0.5,
+  power: 100,
+  coefficient: { [ATK]: 0, [PDEF]: 0 },
+  _type: "skill" as const,
+};
+
+/**
+ * Test skill with 0% hit rate (always fails)
+ */
+const AlwaysFailSkill = {
+  id: "always-fail",
+  name: "Always Fail",
+  description: "A skill that always fails",
+  spCost: 5,
+  hitRate: 0,
+  power: 50,
+  coefficient: { [ATK]: 0, [PDEF]: 0 },
+  _type: "skill" as const,
+};
+
+/**
+ * Test healing skill (no damage, heals target)
+ */
+const HealSkill = {
+  id: "heal",
+  name: "Heal",
+  description: "Restores HP to target",
+  spCost: 15,
+  hitRate: 1,
+  hpValue: 50,
+  power: 0,
+  coefficient: { [ATK]: 0, [PDEF]: 0 },
+  _type: "skill" as const,
+};
+
+/**
+ * Test free skill (no SP cost)
+ */
+const FreeSkill = {
+  id: "free-skill",
+  name: "Free Skill",
+  description: "A skill with no cost",
+  spCost: 0,
+  hitRate: 1,
+  power: 10,
+  coefficient: { [ATK]: 0, [PDEF]: 0 },
+  _type: "skill" as const,
+};
+
+let player: RpgPlayer;
+let fixture: TestingFixture;
+
+// Define server module with skills in database
+const serverModule = defineModule({
+  maps: [
+    {
+      id: "test-map",
+      file: "",
+    },
+  ],
+  database: {
+    fire: FireSkill,
+    ultimate: UltimateSkill,
+    "low-hit-rate": LowHitRateSkill,
+    "always-fail": AlwaysFailSkill,
+    heal: HealSkill,
+    "free-skill": FreeSkill,
+  },
+  player: {
+    async onConnected(player) {
+      await player.changeMap("test-map", { x: 100, y: 100 });
+    },
+  },
+});
+
+// Define client module
+const clientModule = defineModule({
+  // Client-side logic
+});
+
+beforeEach(async () => {
+  const myModule = createModule("TestModule", [
+    {
+      server: serverModule,
+      client: clientModule,
+    },
+  ]);
+
+  fixture = await testing(myModule);
+  const clientTesting = await fixture.createClient();
+  player = await clientTesting.waitForMapChange("test-map");
+
+  // Initialize player SP for skill tests
+  player.sp = 100;
+  player.param[MAXSP] = 100;
+});
+
+afterEach(async () => {
+  await fixture.clear();
+});
+
+describe("Skill Management - Learning Skills", () => {
+  test("should learn a skill using string ID", () => {
+    const skill = player.learnSkill("fire");
+    expect(skill).toBeDefined();
+    expect(skill.id).toBe("fire");
+    expect(skill.name).toBe("Fire");
+  });
+
+  test("should learn a skill using object", () => {
+    const customSkill: SkillObject = {
+      id: "custom-skill",
+      name: "Custom Skill",
+      spCost: 20,
+      hitRate: 1,
+      power: 30,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+    };
+    const skill = player.learnSkill(customSkill);
+    expect(skill).toBeDefined();
+    expect(skill.id).toBe("custom-skill");
+    expect(skill.name).toBe("Custom Skill");
+  });
+
+  test("should auto-generate ID for skill object without ID", () => {
+    const customSkill: SkillObject = {
+      name: "Auto ID Skill",
+      spCost: 5,
+      hitRate: 1,
+    };
+    const skill = player.learnSkill(customSkill);
+    expect(skill).toBeDefined();
+    expect(skill.id).toMatch(/^skill-\d+$/);
+    expect(skill.name).toBe("Auto ID Skill");
+  });
+
+  test("should throw error when learning already learned skill", () => {
+    player.learnSkill("fire");
+    expect(() => {
+      player.learnSkill("fire");
+    }).toThrow();
+  });
+
+  test("should throw error when learning already learned skill using object", () => {
+    player.learnSkill("fire");
+    const duplicateSkill: SkillObject = {
+      id: "fire",
+      name: "Duplicate Fire",
+    };
+    expect(() => {
+      player.learnSkill(duplicateSkill);
+    }).toThrow();
+  });
+
+  test("should learn multiple different skills", () => {
+    player.learnSkill("fire");
+    player.learnSkill("heal");
+    player.learnSkill("free-skill");
+
+    expect(player.getSkill("fire")).toBeDefined();
+    expect(player.getSkill("heal")).toBeDefined();
+    expect(player.getSkill("free-skill")).toBeDefined();
+    expect(player.skills().length).toBe(3);
+  });
+
+  test("should learn skill with object and use it", () => {
+    const customSkill: SkillObject = {
+      id: "direct-skill",
+      name: "Direct Skill",
+      spCost: 5,
+      hitRate: 1,
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+    };
+    player.learnSkill(customSkill);
+    const initialSp = player.sp;
+    const skill = player.useSkill("direct-skill");
+    expect(skill).toBeDefined();
+    expect(player.sp).toBe(initialSp - 5);
+  });
+});
+
+describe("Skill Management - Getting Skills", () => {
+  test("should get learned skill by string ID", () => {
+    player.learnSkill("fire");
+    const skill = player.getSkill("fire");
+    expect(skill).toBeDefined();
+    expect(skill.id).toBe("fire");
+  });
+
+  test("should get learned skill by object", () => {
+    const customSkill: SkillObject = {
+      id: "get-test-skill",
+      name: "Get Test Skill",
+      spCost: 10,
+    };
+    player.learnSkill(customSkill);
+    const skill = player.getSkill({ id: "get-test-skill" });
+    expect(skill).toBeDefined();
+    expect(skill.id).toBe("get-test-skill");
+  });
+
+  test("should return null for non-learned skill", () => {
+    const skill = player.getSkill("fire");
+    expect(skill).toBeNull();
+  });
+});
+
+describe("Skill Management - Forgetting Skills", () => {
+  test("should forget a learned skill using string ID", () => {
+    player.learnSkill("fire");
+    const forgottenSkill = player.forgetSkill("fire");
+    expect(forgottenSkill).toBeDefined();
+    expect(player.getSkill("fire")).toBeNull();
+  });
+
+  test("should forget a learned skill using object", () => {
+    const customSkill: SkillObject = {
+      id: "forget-test-skill",
+      name: "Forget Test Skill",
+      spCost: 10,
+    };
+    player.learnSkill(customSkill);
+    const forgottenSkill = player.forgetSkill({ id: "forget-test-skill" });
+    expect(forgottenSkill).toBeDefined();
+    expect(player.getSkill("forget-test-skill")).toBeNull();
+  });
+
+  test("should throw error when forgetting non-learned skill", () => {
+    expect(() => {
+      player.forgetSkill("fire");
+    }).toThrow();
+  });
+
+  test("should be able to relearn forgotten skill", () => {
+    player.learnSkill("fire");
+    player.forgetSkill("fire");
+    const skill = player.learnSkill("fire");
+    expect(skill).toBeDefined();
+    expect(player.getSkill("fire")).toBeDefined();
+  });
+
+  test("should maintain skill list integrity after operations", () => {
+    player.learnSkill("fire");
+    player.learnSkill("heal");
+    player.learnSkill("free-skill");
+
+    expect(player.skills().length).toBe(3);
+
+    player.forgetSkill("heal");
+    expect(player.skills().length).toBe(2);
+    expect(player.getSkill("fire")).toBeDefined();
+    expect(player.getSkill("heal")).toBeNull();
+    expect(player.getSkill("free-skill")).toBeDefined();
+  });
+});
+
+describe("Skill Management - Using Skills", () => {
+  test("should use skill and consume SP", () => {
+    player.learnSkill("fire");
+    const initialSp = player.sp;
+    const skill = player.useSkill("fire");
+    expect(skill).toBeDefined();
+    expect(player.sp).toBe(initialSp - FireSkill.spCost);
+  });
+
+  test("should use free skill without consuming SP", () => {
+    player.learnSkill("free-skill");
+    const initialSp = player.sp;
+    player.useSkill("free-skill");
+    expect(player.sp).toBe(initialSp);
+  });
+
+  test("should throw error when using non-learned skill", () => {
+    expect(() => {
+      player.useSkill("fire");
+    }).toThrow();
+  });
+
+  test("should throw error when not enough SP", () => {
+    player.sp = 5; // Not enough for FireSkill (costs 10)
+    player.learnSkill("fire");
+    expect(() => {
+      player.useSkill("fire");
+    }).toThrow();
+  });
+
+  test("should throw error when SP is exactly 0", () => {
+    player.sp = 0;
+    player.learnSkill("fire");
+    expect(() => {
+      player.useSkill("fire");
+    }).toThrow();
+  });
+
+  test("should use skill with exact SP amount", () => {
+    player.sp = FireSkill.spCost; // Exactly enough
+    player.learnSkill("fire");
+    const skill = player.useSkill("fire");
+    expect(skill).toBeDefined();
+    expect(player.sp).toBe(0);
+  });
+});
+
+describe("Skill Management - Hit Rate", () => {
+  test("should use skill successfully when hitRate passes", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.3); // 0.3 < 0.5 (hitRate)
+
+    player.learnSkill("low-hit-rate");
+    const skill = player.useSkill("low-hit-rate");
+    expect(skill).toBeDefined();
+
+    Math.random = originalRandom;
+  });
+
+  test("should fail when hitRate check fails", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.9); // 0.9 > 0.5 (hitRate)
+
+    player.learnSkill("low-hit-rate");
+    expect(() => {
+      player.useSkill("low-hit-rate");
+    }).toThrow();
+
+    Math.random = originalRandom;
+  });
+
+  test("should always fail with 0 hitRate", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.001); // Even very small number > 0
+
+    player.learnSkill("always-fail");
+    expect(() => {
+      player.useSkill("always-fail");
+    }).toThrow();
+
+    Math.random = originalRandom;
+  });
+
+  test("should still consume SP even when hitRate fails", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.9); // Will fail
+
+    player.learnSkill("low-hit-rate");
+    const initialSp = player.sp;
+
+    try {
+      player.useSkill("low-hit-rate");
+    } catch {
+      // Expected to throw
+    }
+
+    // SP should be consumed even on failure
+    expect(player.sp).toBe(initialSp - LowHitRateSkill.spCost);
+
+    Math.random = originalRandom;
+  });
+
+  test("should always succeed with hitRate of 1", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.99);
+
+    player.learnSkill("fire"); // hitRate: 1
+    const skill = player.useSkill("fire");
+    expect(skill).toBeDefined();
+
+    Math.random = originalRandom;
+  });
+});
+
+describe("Skill Management - Effects and Restrictions", () => {
+  test("should throw error when player has CAN_NOT_SKILL effect", () => {
+    player.learnSkill("fire");
+    player.effects = [Effect.CAN_NOT_SKILL];
+    expect(() => {
+      player.useSkill("fire");
+    }).toThrow();
+  });
+
+  test("should use half SP cost with HALF_SP_COST effect", () => {
+    player.learnSkill("fire");
+    player.effects = [Effect.HALF_SP_COST];
+    const initialSp = player.sp;
+
+    player.useSkill("fire");
+    expect(player.sp).toBe(initialSp - FireSkill.spCost / 2);
+  });
+
+  test("should use half SP cost rounded correctly", () => {
+    player.learnSkill("low-hit-rate"); // spCost: 5
+
+    // Mock random to pass
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.1);
+
+    player.effects = [Effect.HALF_SP_COST];
+    const initialSp = player.sp;
+
+    player.useSkill("low-hit-rate");
+    expect(player.sp).toBe(initialSp - LowHitRateSkill.spCost / 2);
+
+    Math.random = originalRandom;
+  });
+});
+
+describe("Skill Management - Using Skills on Targets", () => {
+  let targetPlayer: RpgPlayer;
+
+  beforeEach(async () => {
+    const clientTesting2 = await fixture.createClient();
+    targetPlayer = await clientTesting2.waitForMapChange("test-map");
+    targetPlayer.sp = 100;
+    targetPlayer.param[MAXSP] = 100;
+  });
+
+  test("should use skill on single target", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.1);
+
+    player.learnSkill("fire");
+    const skill = player.useSkill("fire", targetPlayer);
+    expect(skill).toBeDefined();
+
+    Math.random = originalRandom;
+  });
+
+  test("should use skill on multiple targets", () => {
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.1);
+
+    player.learnSkill("fire");
+    const skill = player.useSkill("fire", [targetPlayer]);
+    expect(skill).toBeDefined();
+
+    Math.random = originalRandom;
+  });
+
+  test("should use healing skill on target", () => {
+    player.learnSkill("heal");
+    const skill = player.useSkill("heal", targetPlayer);
+    expect(skill).toBeDefined();
+  });
+});
+
+describe("Skill Management - Hooks", () => {
+  test("should call onLearn hook when learning skill", () => {
+    const onLearnSpy = vi.fn();
+    const customSkill: SkillObject = {
+      id: "learn-hook-skill",
+      name: "Learn Hook Skill",
+      spCost: 10,
+      hitRate: 1,
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+      onLearn: onLearnSpy,
+    };
+
+    player.learnSkill(customSkill);
+    expect(onLearnSpy).toHaveBeenCalledWith(player);
+  });
+
+  test("should call onForget hook when forgetting skill", () => {
+    const onForgetSpy = vi.fn();
+    const customSkill: SkillObject = {
+      id: "forget-hook-skill",
+      name: "Forget Hook Skill",
+      spCost: 10,
+      hitRate: 1,
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+      onForget: onForgetSpy,
+    };
+
+    player.learnSkill(customSkill);
+    player.forgetSkill("forget-hook-skill");
+    expect(onForgetSpy).toHaveBeenCalledWith(player);
+  });
+
+  test("should call onUse hook when using skill successfully", () => {
+    const onUseSpy = vi.fn();
+    const customSkill: SkillObject = {
+      id: "use-hook-skill",
+      name: "Use Hook Skill",
+      spCost: 10,
+      hitRate: 1,
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+      onUse: onUseSpy,
+    };
+
+    player.learnSkill(customSkill);
+    player.useSkill("use-hook-skill");
+    expect(onUseSpy).toHaveBeenCalledWith(player, undefined);
+  });
+
+  test("should call onUse hook with target when provided", async () => {
+    const onUseSpy = vi.fn();
+    const customSkill: SkillObject = {
+      id: "use-hook-target-skill",
+      name: "Use Hook Target Skill",
+      spCost: 10,
+      hitRate: 1,
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+      onUse: onUseSpy,
+    };
+
+    const clientTesting2 = await fixture.createClient();
+    const targetPlayer = await clientTesting2.waitForMapChange("test-map");
+
+    player.learnSkill(customSkill);
+    player.useSkill("use-hook-target-skill", targetPlayer);
+    expect(onUseSpy).toHaveBeenCalledWith(player, targetPlayer);
+  });
+
+  test("should call onUseFailed hook when hitRate fails", () => {
+    const onUseFailedSpy = vi.fn();
+    const customSkill: SkillObject = {
+      id: "use-failed-hook-skill",
+      name: "Use Failed Hook Skill",
+      spCost: 5,
+      hitRate: 0.1, // 10% chance
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+      onUseFailed: onUseFailedSpy,
+    };
+
+    const originalRandom = Math.random;
+    Math.random = vi.fn(() => 0.9); // Will fail
+
+    player.learnSkill(customSkill);
+    try {
+      player.useSkill("use-failed-hook-skill");
+    } catch {
+      // Expected to throw
+    }
+    expect(onUseFailedSpy).toHaveBeenCalledWith(player, undefined);
+
+    Math.random = originalRandom;
+  });
+});
+
+describe("Skill Management - Edge Cases", () => {
+  test("should handle skill with default hitRate (1)", () => {
+    const skillWithoutHitRate: SkillObject = {
+      id: "no-hitrate-skill",
+      name: "No HitRate Skill",
+      spCost: 10,
+      power: 0,
+      coefficient: { [ATK]: 0, [PDEF]: 0 },
+      _type: "skill",
+      // No hitRate specified, should default to 1
+    };
+
+    player.learnSkill(skillWithoutHitRate);
+    const skill = player.useSkill("no-hitrate-skill");
+    expect(skill).toBeDefined();
+  });
+
+  test("should handle skill with 0 SP cost", () => {
+    player.sp = 0;
+    player.learnSkill("free-skill");
+    const skill = player.useSkill("free-skill");
+    expect(skill).toBeDefined();
+    expect(player.sp).toBe(0);
+  });
+
+  test("should handle multiple skill usages in sequence", () => {
+    player.sp = 50;
+    player.learnSkill("fire"); // costs 10
+
+    player.useSkill("fire");
+    expect(player.sp).toBe(40);
+
+    player.useSkill("fire");
+    expect(player.sp).toBe(30);
+
+    player.useSkill("fire");
+    expect(player.sp).toBe(20);
+  });
+
+  test("should handle learning and forgetting same skill multiple times", () => {
+    player.learnSkill("fire");
+    player.forgetSkill("fire");
+    player.learnSkill("fire");
+    player.forgetSkill("fire");
+    player.learnSkill("fire");
+
+    expect(player.getSkill("fire")).toBeDefined();
+    expect(player.skills().length).toBe(1);
+  });
+
+  test("should merge object properties when skill already in database", () => {
+    // First, learn fire from database
+    player.learnSkill("fire");
+    player.forgetSkill("fire");
+
+    // Now learn with modified properties
+    const modifiedFire: SkillObject = {
+      id: "fire",
+      name: "Modified Fire",
+      spCost: 5, // Changed from 10
+    };
+    const skill = player.learnSkill(modifiedFire);
+    expect(skill.name).toBe("Modified Fire");
+    expect(skill.spCost).toBe(5);
+  });
+});