208 lines
7.2 KiB
TypeScript
208 lines
7.2 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import {
|
|
chooseTrainerMove,
|
|
validateTrainerAI,
|
|
type TrainerAIInput,
|
|
type TrainerAISide,
|
|
} from "../src/game/battle/ai";
|
|
import { C } from "../src/game/battle/constants";
|
|
import { SYMBOLS } from "../src/game/rom/profile";
|
|
import type { MoveData } from "../src/game/rom/pokemon";
|
|
|
|
const move = (
|
|
id: number,
|
|
effect = C.EFFECT_NORMAL_HIT,
|
|
power = 40,
|
|
type = 0,
|
|
): MoveData => ({ id, effect, power, type, accuracy: 255, pp: 30, chance: 0 });
|
|
const side = (): TrainerAISide => ({
|
|
mon: {
|
|
moves: [1, 2, 0, 0],
|
|
pp: [30, 30, 0, 0],
|
|
status: 0,
|
|
hp: 20,
|
|
maxHp: 20,
|
|
types: [0, 0],
|
|
species: 1,
|
|
dvs: 0x8888,
|
|
},
|
|
sub: [0, 0, 0, 0, 0, 0],
|
|
screens: 0,
|
|
turnsTaken: 0,
|
|
disableCount: 0,
|
|
disabledMove: 0,
|
|
});
|
|
function fixture(moves = [move(1), move(2)], bytes = [0]): TrainerAIInput {
|
|
let cursor = 0;
|
|
return {
|
|
weights: 0,
|
|
player: side(),
|
|
enemy: side(),
|
|
weather: 0,
|
|
random: () => {
|
|
if (cursor >= bytes.length)
|
|
throw new Error("Unexpected extra random call");
|
|
return bytes[cursor++];
|
|
},
|
|
data: {
|
|
move: (id) => moves.find((m) => m.id === id)!,
|
|
baseData: () => {
|
|
throw new Error("Unexpected base data lookup");
|
|
},
|
|
},
|
|
battleData: {
|
|
byteList: (address) =>
|
|
address === SYMBOLS.statusOnlyEffects
|
|
? [C.EFFECT_SLEEP, C.EFFECT_TOXIC, C.EFFECT_POISON, C.EFFECT_PARALYZE]
|
|
: [1, 2],
|
|
typeMatchups: () => [],
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("trainer AI native scoring", () => {
|
|
it("rejects untranslated layers, including Rival1, before consuming randomness", () => {
|
|
for (const weights of [16, 32, 64, 512, 0x3d3, -1, 65536])
|
|
expect(() => validateTrainerAI(weights)).toThrow(/not translated/);
|
|
expect(() => validateTrainerAI(0xfd8f)).not.toThrow();
|
|
});
|
|
it("uses masked random slots and retries blanks without first-slot tie bias", () => {
|
|
const input = fixture(undefined, [3, 6, 253]);
|
|
expect(chooseTrainerMove(input)).toEqual({
|
|
move: 2,
|
|
index: 1,
|
|
scores: [20, 20, 80, 80],
|
|
});
|
|
});
|
|
it("refuses a random source that never produces a candidate", () => {
|
|
const input = fixture();
|
|
input.random = () => 3;
|
|
expect(() => chooseTrainerMove(input)).toThrow(/random source/);
|
|
});
|
|
it("masks PP Ups and discourages disabled/exhausted moves", () => {
|
|
const input = fixture([move(1), move(2), move(3)], [0, 1, 2]);
|
|
input.enemy.mon.moves = [1, 2, 3, 0];
|
|
input.enemy.mon.pp = [30, 0xc0, 0xc1, 0];
|
|
input.enemy.disabledMove = 1;
|
|
expect(chooseTrainerMove(input)).toEqual({
|
|
move: 3,
|
|
index: 2,
|
|
scores: [80, 80, 20, 80],
|
|
});
|
|
});
|
|
it("still scores exhausted moves and consumes randomness before Struggle", () => {
|
|
const input = fixture(
|
|
[move(1, C.EFFECT_ATTACK_UP, 0), move(2)],
|
|
[128, 3, 0],
|
|
);
|
|
input.weights = 2;
|
|
input.enemy.mon.pp.fill(0);
|
|
expect(chooseTrainerMove(input)).toEqual({
|
|
move: 1,
|
|
index: 0,
|
|
scores: [78, 80, 80, 80],
|
|
});
|
|
});
|
|
it("still selects when the only move is disabled", () => {
|
|
const input = fixture([move(1)], [3, 0]);
|
|
input.enemy.mon.moves = [1, 0, 0, 0];
|
|
input.enemy.disabledMove = 1;
|
|
expect(chooseTrainerMove(input)).toEqual({
|
|
move: 1,
|
|
index: 0,
|
|
scores: [80, 20, 80, 80],
|
|
});
|
|
});
|
|
it("refuses empty move lists instead of the cartridge's infinite loop", () => {
|
|
const input = fixture();
|
|
input.enemy.mon.moves.fill(0);
|
|
expect(() => chooseTrainerMove(input)).toThrow(/nonzero move/);
|
|
});
|
|
it("Basic discourages status on a statused or safeguarded target exactly once", () => {
|
|
const input = fixture([move(1, C.EFFECT_SLEEP, 0), move(2)], [1]);
|
|
input.weights = 1;
|
|
input.player.mon.status = 8;
|
|
input.player.screens = 1 << C.SCREENS_SAFEGUARD;
|
|
expect(chooseTrainerMove(input).scores).toEqual([30, 20, 80, 80]);
|
|
});
|
|
it("Basic preserves Nightmare and Future Sight's cartridge redundancy bugs", () => {
|
|
const input = fixture(
|
|
[move(1, C.EFFECT_NIGHTMARE, 0), move(2, C.EFFECT_FUTURE_SIGHT)],
|
|
[0],
|
|
);
|
|
input.weights = 1;
|
|
input.player.mon.status = 8;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([20, 20]);
|
|
input.random = () => 1;
|
|
input.enemy.screens = 1 << C.SCREENS_UNUSED;
|
|
input.player.mon.status = 0;
|
|
input.random = () => 0;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([30, 30]);
|
|
});
|
|
it("Setup uses each side's first turn and exact 128/30 byte thresholds", () => {
|
|
const input = fixture(
|
|
[move(1, C.EFFECT_ATTACK_UP, 0), move(2, C.EFFECT_ATTACK_DOWN, 0)],
|
|
[128, 30, 0],
|
|
);
|
|
input.weights = 2;
|
|
input.player.turnsTaken = 1;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([18, 22]);
|
|
input.random = (() => {
|
|
const bytes = [127, 29, 1];
|
|
return () => bytes.shift()!;
|
|
})();
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([20, 20]);
|
|
});
|
|
it("Types discourages resistance only when another damaging type exists", () => {
|
|
const input = fixture([move(1, 0, 40, 20), move(2, 0, 0, 21)], [0]);
|
|
input.weights = 4;
|
|
input.battleData.typeMatchups = () => [
|
|
{ attacker: 20, defender: 0, multiplier: 5 },
|
|
];
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([20, 20]);
|
|
input.data.move = (id) =>
|
|
id === 1 ? move(1, 0, 40, 20) : move(2, 0, 40, 21);
|
|
input.random = () => 1;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([21, 20]);
|
|
});
|
|
it("Types encourages damaging super-effective moves and respects Foresight", () => {
|
|
const input = fixture([move(1, 0, 40, 0), move(2, 0, 40, 20)], [1]);
|
|
input.weights = 4;
|
|
input.player.mon.types = [8, 8];
|
|
input.battleData.typeMatchups = () => [
|
|
{ attacker: 20, defender: 8, multiplier: 20 },
|
|
{ attacker: 0xfe, defender: 0, multiplier: 0 },
|
|
{ attacker: 0, defender: 8, multiplier: 0 },
|
|
];
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([30, 19]);
|
|
input.player.sub = [0, 1 << C.SUBSTATUS_IDENTIFIED, 0, 0, 0, 0];
|
|
input.random = () => 1;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([20, 19]);
|
|
});
|
|
it("Status discourages poison against Poison and damaging immunities", () => {
|
|
const input = fixture([move(1, C.EFFECT_POISON, 0), move(2)], [0]);
|
|
input.weights = 256;
|
|
input.player.mon.types = [3, 3];
|
|
input.battleData.typeMatchups = () => [
|
|
{ attacker: 0, defender: 3, multiplier: 0 },
|
|
];
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([30, 30]);
|
|
});
|
|
it("Cautious stops the entire layer on its first failed random check", () => {
|
|
const input = fixture(undefined, [230, 1]);
|
|
input.weights = 128;
|
|
input.enemy.turnsTaken = 1;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([20, 20]);
|
|
input.random = (() => {
|
|
const bytes = [229, 230, 1];
|
|
return () => bytes.shift()!;
|
|
})();
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([21, 20]);
|
|
});
|
|
it("Offensive penalizes non-damaging moves by two", () => {
|
|
const input = fixture([move(1, C.EFFECT_ATTACK_DOWN, 0), move(2)], [1]);
|
|
input.weights = 8;
|
|
expect(chooseTrainerMove(input).scores.slice(0, 2)).toEqual([22, 20]);
|
|
});
|
|
});
|