diff --git a/src/@types/arena-tags.ts b/src/@types/arena-tags.ts index 4ac7abf6f3d..390d95a7daa 100644 --- a/src/@types/arena-tags.ts +++ b/src/@types/arena-tags.ts @@ -2,6 +2,7 @@ import type { ArenaTagTypeMap } from "#data/arena-tag"; import type { ArenaTagType } from "#enums/arena-tag-type"; // biome-ignore lint/correctness/noUnusedImports: TSDocs import type { SessionSaveData } from "#system/game-data"; +import type { ObjectValues } from "#types/type-helpers"; /** Subset of {@linkcode ArenaTagType}s that apply some negative effect to pokemon that switch in ({@link https://bulbapedia.bulbagarden.net/wiki/List_of_moves_that_cause_entry_hazards#List_of_traps | entry hazards} and Imprison. */ export type EntryHazardTagType = @@ -24,22 +25,32 @@ export type TurnProtectArenaTagType = /** Subset of {@linkcode ArenaTagType}s that create Trick Room-like effects which are removed upon overlap. */ export type RoomArenaTagType = ArenaTagType.TRICK_ROOM; -/** Subset of {@linkcode ArenaTagType}s that cannot persist across turns, and thus should not be serialized in {@linkcode SessionSaveData}. */ +/** Subset of {@linkcode ArenaTagType}s that are **not** able to persist across turns, and should therefore not be serialized in {@linkcode SessionSaveData}. */ export type NonSerializableArenaTagType = ArenaTagType.NONE | TurnProtectArenaTagType | ArenaTagType.ION_DELUGE; /** Subset of {@linkcode ArenaTagType}s that may persist across turns, and thus must be serialized in {@linkcode SessionSaveData}. */ export type SerializableArenaTagType = Exclude; /** - * Type-safe representation of an arbitrary, serialized Arena Tag + * Utility type containing all entries of {@linkcode ArenaTagTypeMap} corresponding to serializable tags. */ -export type ArenaTagTypeData = Parameters< - ArenaTagTypeMap[keyof { - [K in keyof ArenaTagTypeMap as K extends SerializableArenaTagType ? K : never]: ArenaTagTypeMap[K]; - }]["loadTag"] ->[0]; +type SerializableArenaTagTypeMap = Pick; -/** Dummy, typescript-only declaration to ensure that +/** + * Type mapping all `ArenaTag`s to type-safe representations of their serialized forms. + * @interface + */ +export type ArenaTagDataMap = { + [k in keyof SerializableArenaTagTypeMap]: Parameters[0]; +}; + +/** + * Type-safe representation of an arbitrary, serialized `ArenaTag`. + */ +export type ArenaTagData = ObjectValues; + +/** + * Dummy, typescript-only declaration to ensure that * {@linkcode ArenaTagTypeMap} has a map for all ArenaTagTypes. * * If an arena tag is missing from the map, typescript will throw an error on this statement. diff --git a/src/@types/battler-tags.ts b/src/@types/battler-tags.ts index 211eb25113d..8e34108958e 100644 --- a/src/@types/battler-tags.ts +++ b/src/@types/battler-tags.ts @@ -1,8 +1,11 @@ // biome-ignore-start lint/correctness/noUnusedImports: Used in a TSDoc comment import type { AbilityBattlerTag, BattlerTagTypeMap, SerializableBattlerTag, TypeBoostTag } from "#data/battler-tags"; import type { AbilityId } from "#enums/ability-id"; -// biome-ignore-end lint/correctness/noUnusedImports: end +import type { SessionSaveData } from "#system/game-data"; +// biome-ignore-end lint/correctness/noUnusedImports: Used in a TSDoc comment + import type { BattlerTagType } from "#enums/battler-tag-type"; +import type { InferKeys, ObjectValues } from "#types/type-helpers"; /** * Subset of {@linkcode BattlerTagType}s that restrict the use of moves. @@ -103,28 +106,35 @@ export type RemovedTypeTagType = BattlerTagType.DOUBLE_SHOCKED | BattlerTagType. export type HighestStatBoostTagType = | BattlerTagType.QUARK_DRIVE // formatting | BattlerTagType.PROTOSYNTHESIS; -/** - * Subset of {@linkcode BattlerTagType}s that are able to persist between turns and should therefore be serialized - */ -export type SerializableBattlerTagType = keyof { - [K in keyof BattlerTagTypeMap as BattlerTagTypeMap[K] extends SerializableBattlerTag - ? K - : never]: BattlerTagTypeMap[K]; -}; /** - * Subset of {@linkcode BattlerTagType}s that are not able to persist across waves and should therefore not be serialized + * Subset of {@linkcode BattlerTagType}s that are able to persist between turns, and should therefore be serialized. + */ +export type SerializableBattlerTagType = InferKeys; + +/** + * Subset of {@linkcode BattlerTagType}s that are **not** able to persist between turns, + * and should therefore not be serialized in {@linkcode SessionSaveData}. */ export type NonSerializableBattlerTagType = Exclude; /** - * Type-safe representation of an arbitrary, serialized Battler Tag + * Utility type containing all entries of {@linkcode BattlerTagTypeMap} corresponding to serializable tags. */ -export type BattlerTagTypeData = Parameters< - BattlerTagTypeMap[keyof { - [K in keyof BattlerTagTypeMap as K extends SerializableBattlerTagType ? K : never]: BattlerTagTypeMap[K]; - }]["loadTag"] ->[0]; +type SerializableBattlerTagTypeMap = Pick; + +/** + * Type mapping all `BattlerTag`s to type-safe representations of their serialized forms. + * @interface + */ +export type BattlerTagDataMap = { + [k in keyof SerializableBattlerTagTypeMap]: Parameters[0]; +}; + +/** + * Type-safe representation of an arbitrary, serialized `BattlerTag`. + */ +export type BattlerTagData = ObjectValues; /** * Dummy, typescript-only declaration to ensure that diff --git a/src/@types/helpers/type-helpers.ts b/src/@types/helpers/type-helpers.ts index 0be391aa3c4..048a86ab489 100644 --- a/src/@types/helpers/type-helpers.ts +++ b/src/@types/helpers/type-helpers.ts @@ -36,15 +36,18 @@ export type Mutable = { /** * Type helper to obtain the keys associated with a given value inside an object. + * Acts similar to {@linkcode Pick}, except checking the object's values instead of its keys. * @typeParam O - The type of the object - * @typeParam V - The type of one of O's values + * @typeParam V - The type of one of O's values. */ -export type InferKeys> = { - [K in keyof O]: O[K] extends V ? K : never; -}[keyof O]; +export type InferKeys = V extends ObjectValues + ? { + [K in keyof O]: O[K] extends V ? K : never; + }[keyof O] + : never; /** - * Utility type to obtain the values of a given object. \ + * Utility type to obtain a union of the values of a given object. \ * Functions similar to `keyof E`, except producing the values instead of the keys. * @remarks * This can be used to convert an `enum` interface produced by `typeof Enum` into the union type representing its members. diff --git a/src/data/arena-tag.ts b/src/data/arena-tag.ts index 1952db7867b..70e8697179e 100644 --- a/src/data/arena-tag.ts +++ b/src/data/arena-tag.ts @@ -23,7 +23,7 @@ import type { Arena } from "#field/arena"; import type { Pokemon } from "#field/pokemon"; import type { ArenaScreenTagType, - ArenaTagTypeData, + ArenaTagData, EntryHazardTagType, RoomArenaTagType, SerializableArenaTagType, @@ -1663,7 +1663,7 @@ export function getArenaTag( * @param source - An arena tag * @returns The valid arena tag */ -export function loadArenaTag(source: ArenaTag | ArenaTagTypeData | { tagType: ArenaTagType.NONE }): ArenaTag { +export function loadArenaTag(source: ArenaTag | ArenaTagData | { tagType: ArenaTagType.NONE }): ArenaTag { if (source.tagType === ArenaTagType.NONE) { return new NoneTag(); } diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts index 24e1e6f12cd..5484eba7271 100644 --- a/src/data/battler-tags.ts +++ b/src/data/battler-tags.ts @@ -34,7 +34,7 @@ import type { StatStageChangeCallback } from "#phases/stat-stage-change-phase"; import i18next from "#plugins/i18n"; import type { AbilityBattlerTagType, - BattlerTagTypeData, + BattlerTagData, ContactSetStatusProtectedTagType, ContactStatStageChangeProtectedTagType, CritStageBoostTagType, @@ -3843,7 +3843,7 @@ export function getBattlerTag( * @param source - An object containing the data necessary to reconstruct the BattlerTag. * @returns The valid battler tag */ -export function loadBattlerTag(source: BattlerTag | BattlerTagTypeData): BattlerTag { +export function loadBattlerTag(source: BattlerTag | BattlerTagData): BattlerTag { // TODO: Remove this bang by fixing the signature of `getBattlerTag` // to allow undefined sourceIds and sourceMoves (with appropriate fallback for tags that require it) const tag = getBattlerTag(source.tagType, source.turnCount, source.sourceMove!, source.sourceId!); diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 1bb9a3f6e92..266362a468b 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -8903,7 +8903,9 @@ export function initMoves() { .attr(AddArenaTagAttr, ArenaTagType.REFLECT, 5, true) .target(MoveTarget.USER_SIDE), new SelfStatusMove(MoveId.FOCUS_ENERGY, PokemonType.NORMAL, -1, 30, -1, 0, 1) - .attr(AddBattlerTagAttr, BattlerTagType.CRIT_BOOST, true, true), + .attr(AddBattlerTagAttr, BattlerTagType.CRIT_BOOST, true, true) + // TODO: Remove once dragon cheer & focus energy are merged into 1 tag + .condition((_user, target) => !target.getTag(BattlerTagType.DRAGON_CHEER)), new AttackMove(MoveId.BIDE, PokemonType.NORMAL, MoveCategory.PHYSICAL, -1, -1, 10, -1, 1, 1) .target(MoveTarget.USER) .unimplemented(), @@ -11601,6 +11603,8 @@ export function initMoves() { .attr(OpponentHighHpPowerAttr, 100), new StatusMove(MoveId.DRAGON_CHEER, PokemonType.DRAGON, -1, 15, -1, 0, 9) .attr(AddBattlerTagAttr, BattlerTagType.DRAGON_CHEER, false, true) + // TODO: Remove once dragon cheer & focus energy are merged into 1 tag + .condition((_user, target) => !target.getTag(BattlerTagType.CRIT_BOOST)) .target(MoveTarget.NEAR_ALLY), new AttackMove(MoveId.ALLURING_VOICE, PokemonType.FAIRY, MoveCategory.SPECIAL, 80, 100, 10, 100, 0, 9) .attr(AddBattlerTagIfBoostedAttr, BattlerTagType.CONFUSED) diff --git a/src/system/arena-data.ts b/src/system/arena-data.ts index b2a04f96a55..18620e15223 100644 --- a/src/system/arena-data.ts +++ b/src/system/arena-data.ts @@ -5,14 +5,14 @@ import { Terrain } from "#data/terrain"; import { Weather } from "#data/weather"; import type { BiomeId } from "#enums/biome-id"; import { Arena } from "#field/arena"; -import type { ArenaTagTypeData } from "#types/arena-tags"; +import type { ArenaTagData } from "#types/arena-tags"; import type { NonFunctionProperties } from "#types/type-helpers"; export interface SerializedArenaData { biome: BiomeId; weather: NonFunctionProperties | null; terrain: NonFunctionProperties | null; - tags?: ArenaTagTypeData[]; + tags?: ArenaTagData[]; positionalTags: SerializedPositionalTag[]; playerTerasUsed?: number; } @@ -31,7 +31,7 @@ export class ArenaData { // is not yet an instance of `ArenaTag` this.tags = source.tags - ?.map((t: ArenaTag | ArenaTagTypeData) => loadArenaTag(t)) + ?.map((t: ArenaTag | ArenaTagData) => loadArenaTag(t)) ?.filter((tag): tag is SerializableArenaTag => tag instanceof SerializableArenaTag) ?? []; this.playerTerasUsed = source.playerTerasUsed ?? 0; diff --git a/test/@types/vitest.d.ts b/test/@types/vitest.d.ts index aa7666c0880..f0bbdf37932 100644 --- a/test/@types/vitest.d.ts +++ b/test/@types/vitest.d.ts @@ -4,6 +4,7 @@ import type { Phase } from "#app/phase"; import type Overrides from "#app/overrides"; import type { ArenaTag } from "#data/arena-tag"; import type { TerrainType } from "#data/terrain"; +import type { BattlerTag } from "#data/battler-tags"; import type { PositionalTag } from "#data/positional-tags/positional-tag"; import type { AbilityId } from "#enums/ability-id"; import type { ArenaTagSide } from "#enums/arena-tag-side"; @@ -28,6 +29,7 @@ import type { TurnMove } from "#types/turn-move"; import type { AtLeastOne } from "#types/type-helpers"; import type { toDmgValue } from "utils/common"; import type { expect } from "vitest"; +import { toHaveBattlerTagOptions } from "#test/test-utils/matchers/to-have-battler-tag"; declare module "vitest" { interface Assertion { @@ -133,10 +135,15 @@ declare module "vitest" { toHaveStatStage(stat: BattleStat, expectedStage: number): void; /** - * Check whether a {@linkcode Pokemon} has a specific {@linkcode BattlerTagType}. - * @param expectedBattlerTagType - The expected {@linkcode BattlerTagType} + * Check whether a {@linkcode Pokemon} has the given {@linkcode BattlerTag}. + * @param expectedTag - A partially-filled {@linkcode BattlerTag} containing the desired properties */ - toHaveBattlerTag(expectedBattlerTagType: BattlerTagType): void; + toHaveBattlerTag(expectedTag: toHaveBattlerTagOptions): void; + /** + * Check whether a {@linkcode Pokemon} has the given {@linkcode BattlerTag}. + * @param expectedType - The expected {@linkcode BattlerTagType} + */ + toHaveBattlerTag(expectedType: BattlerTagType): void; /** * Check whether a {@linkcode Pokemon} has applied a specific {@linkcode AbilityId}. diff --git a/test/moves/dragon-cheer.test.ts b/test/moves/dragon-cheer.test.ts index 614dd9ab6ab..50880e067d9 100644 --- a/test/moves/dragon-cheer.test.ts +++ b/test/moves/dragon-cheer.test.ts @@ -1,15 +1,18 @@ import { AbilityId } from "#enums/ability-id"; import { BattlerIndex } from "#enums/battler-index"; +import { BattlerTagType } from "#enums/battler-tag-type"; import { MoveId } from "#enums/move-id"; +import { MoveResult } from "#enums/move-result"; import { PokemonType } from "#enums/pokemon-type"; import { SpeciesId } from "#enums/species-id"; import { GameManager } from "#test/test-utils/game-manager"; import Phaser from "phaser"; import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; -describe("Moves - Dragon Cheer", () => { +describe("Move - Dragon Cheer", () => { let phaserGame: Phaser.Game; let game: GameManager; + beforeAll(() => { phaserGame = new Phaser.Game({ type: Phaser.HEADLESS, @@ -24,75 +27,81 @@ describe("Moves - Dragon Cheer", () => { game = new GameManager(phaserGame); game.override .battleStyle("double") + .ability(AbilityId.BALL_FETCH) .enemyAbility(AbilityId.BALL_FETCH) .enemyMoveset(MoveId.SPLASH) - .enemyLevel(20) - .moveset([MoveId.DRAGON_CHEER, MoveId.TACKLE, MoveId.SPLASH]); + .enemyLevel(20); }); - it("increases the user's allies' critical hit ratio by one stage", async () => { + it("should increase non-Dragon type allies' crit ratios by 1 stage", async () => { await game.classicMode.startBattle([SpeciesId.DRAGONAIR, SpeciesId.MAGIKARP]); - const enemy = game.scene.getEnemyField()[0]; - + const enemy = game.field.getEnemyPokemon(); vi.spyOn(enemy, "getCritStage"); - game.move.select(MoveId.DRAGON_CHEER, 0); - game.move.select(MoveId.TACKLE, 1, BattlerIndex.ENEMY); - + game.move.use(MoveId.DRAGON_CHEER, BattlerIndex.PLAYER); + game.move.use(MoveId.TACKLE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY); await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]); + await game.toEndOfTurn(); - // After Tackle - await game.phaseInterceptor.to("TurnEndPhase"); + const [dragonair, magikarp] = game.scene.getPlayerField(); + expect(dragonair).not.toHaveBattlerTag(BattlerTagType.DRAGON_CHEER); + expect(magikarp).toHaveBattlerTag({ tagType: BattlerTagType.DRAGON_CHEER, critStages: 1 }); expect(enemy.getCritStage).toHaveReturnedWith(1); // getCritStage is called on defender }); - it("increases the user's Dragon-type allies' critical hit ratio by two stages", async () => { + it("should increase Dragon-type allies' crit ratios by 2 stages", async () => { await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.DRAGONAIR]); - const enemy = game.scene.getEnemyField()[0]; - + const enemy = game.field.getEnemyPokemon(); vi.spyOn(enemy, "getCritStage"); - game.move.select(MoveId.DRAGON_CHEER, 0); - game.move.select(MoveId.TACKLE, 1, BattlerIndex.ENEMY); - + game.move.use(MoveId.DRAGON_CHEER, BattlerIndex.PLAYER); + game.move.use(MoveId.TACKLE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY); await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]); + await game.toEndOfTurn(); - // After Tackle - await game.phaseInterceptor.to("TurnEndPhase"); + const [magikarp, dragonair] = game.scene.getPlayerField(); + expect(magikarp).not.toHaveBattlerTag(BattlerTagType.DRAGON_CHEER); + expect(dragonair).toHaveBattlerTag({ tagType: BattlerTagType.DRAGON_CHEER, critStages: 2 }); expect(enemy.getCritStage).toHaveReturnedWith(2); // getCritStage is called on defender }); - it("applies the effect based on the allies' type upon use of the move, and do not change if the allies' type changes later in battle", async () => { + it("should maintain crit boost amount even if user's type is changed", async () => { await game.classicMode.startBattle([SpeciesId.DRAGONAIR, SpeciesId.MAGIKARP]); - const magikarp = game.scene.getPlayerField()[1]; - const enemy = game.scene.getEnemyField()[0]; - - vi.spyOn(enemy, "getCritStage"); - - game.move.select(MoveId.DRAGON_CHEER, 0); - game.move.select(MoveId.TACKLE, 1, BattlerIndex.ENEMY); - + // Use Reflect Type to become Dragon-type mid-turn + game.move.use(MoveId.DRAGON_CHEER, BattlerIndex.PLAYER); + game.move.use(MoveId.REFLECT_TYPE, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER); await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]); - - // After Tackle - await game.phaseInterceptor.to("TurnEndPhase"); - expect(enemy.getCritStage).toHaveReturnedWith(1); // getCritStage is called on defender - - await game.toNextTurn(); - - // Change Magikarp's type to Dragon - vi.spyOn(magikarp, "getTypes").mockReturnValue([PokemonType.DRAGON]); - expect(magikarp.getTypes()).toEqual([PokemonType.DRAGON]); - - game.move.select(MoveId.SPLASH, 0); - game.move.select(MoveId.TACKLE, 1, BattlerIndex.ENEMY); - - await game.setTurnOrder([BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]); - await game.phaseInterceptor.to("MoveEndPhase"); - expect(enemy.getCritStage).toHaveReturnedWith(1); // getCritStage is called on defender + + // Dragon cheer added +1 stages + const magikarp = game.scene.getPlayerField()[1]; + expect(magikarp).toHaveBattlerTag({ tagType: BattlerTagType.DRAGON_CHEER, critStages: 1 }); + expect(magikarp).toHaveTypes([PokemonType.WATER]); + + await game.toEndOfTurn(); + + // Should be dragon type, but still with a +1 stage boost + expect(magikarp).toHaveTypes([PokemonType.DRAGON]); + expect(magikarp).toHaveBattlerTag({ tagType: BattlerTagType.DRAGON_CHEER, critStages: 1 }); + }); + + it.each([ + { name: "Focus Energy", tagType: BattlerTagType.CRIT_BOOST }, + { name: "Dragon Cheer", tagType: BattlerTagType.DRAGON_CHEER }, + ])("should fail if $name is already present", async ({ tagType }) => { + await game.classicMode.startBattle([SpeciesId.DRAGONAIR, SpeciesId.MAGIKARP]); + + const [dragonair, magikarp] = game.scene.getPlayerField(); + magikarp.addTag(tagType); + + game.move.use(MoveId.DRAGON_CHEER, BattlerIndex.PLAYER); + game.move.use(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.toEndOfTurn(); + + expect(dragonair).toHaveUsedMove({ move: MoveId.DRAGON_CHEER, result: MoveResult.FAIL }); + expect(magikarp).toHaveBattlerTag(tagType); }); }); diff --git a/test/moves/focus-energy.test.ts b/test/moves/focus-energy.test.ts new file mode 100644 index 00000000000..3c2882f5bf3 --- /dev/null +++ b/test/moves/focus-energy.test.ts @@ -0,0 +1,69 @@ +import { AbilityId } from "#enums/ability-id"; +import { BattlerTagType } from "#enums/battler-tag-type"; +import { MoveId } from "#enums/move-id"; +import { MoveResult } from "#enums/move-result"; +import { SpeciesId } from "#enums/species-id"; +import { GameManager } from "#test/test-utils/game-manager"; +import Phaser from "phaser"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; + +describe("Move - Focus Energy", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + game.override + .ability(AbilityId.BALL_FETCH) + .battleStyle("single") + .criticalHits(false) + .enemySpecies(SpeciesId.MAGIKARP) + .enemyAbility(AbilityId.BALL_FETCH) + .enemyMoveset(MoveId.SPLASH) + .startingLevel(100) + .enemyLevel(100); + }); + + it("should increase the user's crit ratio by 2 stages", async () => { + await game.classicMode.startBattle([SpeciesId.FEEBAS]); + + game.move.use(MoveId.FOCUS_ENERGY); + await game.toNextTurn(); + + const feebas = game.field.getPlayerPokemon(); + expect(feebas).toHaveBattlerTag({ tagType: BattlerTagType.CRIT_BOOST, critStages: 2 }); + + const enemy = game.field.getEnemyPokemon(); + vi.spyOn(enemy, "getCritStage"); + + game.move.use(MoveId.TACKLE); + await game.toEndOfTurn(); + + expect(enemy.getCritStage).toHaveReturnedWith(2); + }); + + it.each([ + { name: "Focus Energy", tagType: BattlerTagType.CRIT_BOOST }, + { name: "Dragon Cheer", tagType: BattlerTagType.DRAGON_CHEER }, + ])("should fail if $name is already present", async ({ tagType }) => { + await game.classicMode.startBattle([SpeciesId.FEEBAS]); + + const feebas = game.field.getPlayerPokemon(); + feebas.addTag(tagType); + + game.move.use(MoveId.FOCUS_ENERGY); + await game.toEndOfTurn(); + + expect(feebas).toHaveUsedMove({ move: MoveId.FOCUS_ENERGY, result: MoveResult.FAIL }); + }); +}); diff --git a/test/test-utils/matchers/to-have-arena-tag.ts b/test/test-utils/matchers/to-have-arena-tag.ts index e2a4a71ffd5..a9d619686d1 100644 --- a/test/test-utils/matchers/to-have-arena-tag.ts +++ b/test/test-utils/matchers/to-have-arena-tag.ts @@ -6,11 +6,21 @@ import type { OneOther } from "#test/@types/test-helpers"; import type { GameManager } from "#test/test-utils/game-manager"; import { getOnelineDiffStr } from "#test/test-utils/string-utils"; import { isGameManagerInstance, receivedStr } from "#test/test-utils/test-utils"; +import type { ArenaTagDataMap, SerializableArenaTagType } from "#types/arena-tags"; import type { MatcherState, SyncExpectationResult } from "@vitest/expect"; -// intersection required to preserve T for inferences -export type toHaveArenaTagOptions = OneOther & { - tagType: T; +/** + * Options type for {@linkcode toHaveArenaTag}. + * @typeParam A - The {@linkcode ArenaTagType} being checked + * @remarks + * If A corresponds to a serializable `ArenaTag`, only properties allowed to be serialized + * (i.e. can change across instances) will be present and able to be checked. + */ +export type toHaveArenaTagOptions = OneOther< + A extends SerializableArenaTagType ? ArenaTagDataMap[A] : ArenaTagTypeMap[A], + "tagType" | "side" +> & { + tagType: A; }; /** @@ -22,10 +32,10 @@ export type toHaveArenaTagOptions = OneOther( +export function toHaveArenaTag( this: MatcherState, received: unknown, - expectedTag: T | toHaveArenaTagOptions, + expectedTag: A | toHaveArenaTagOptions, side: ArenaTagSide = ArenaTagSide.BOTH, ): SyncExpectationResult { if (!isGameManagerInstance(received)) { diff --git a/test/test-utils/matchers/to-have-battler-tag.ts b/test/test-utils/matchers/to-have-battler-tag.ts index af405d7da39..ba6679b2af4 100644 --- a/test/test-utils/matchers/to-have-battler-tag.ts +++ b/test/test-utils/matchers/to-have-battler-tag.ts @@ -3,21 +3,39 @@ import type { Pokemon } from "#field/pokemon"; /* biome-ignore-end lint/correctness/noUnusedImports: tsdoc imports */ import { getPokemonNameWithAffix } from "#app/messages"; +import type { BattlerTagTypeMap } from "#data/battler-tags"; import { BattlerTagType } from "#enums/battler-tag-type"; -import { getEnumStr } from "#test/test-utils/string-utils"; +import type { OneOther } from "#test/@types/test-helpers"; +import { getEnumStr, getOnelineDiffStr } from "#test/test-utils/string-utils"; import { isPokemonInstance, receivedStr } from "#test/test-utils/test-utils"; +import type { BattlerTagDataMap, SerializableBattlerTagType } from "#types/battler-tags"; import type { MatcherState, SyncExpectationResult } from "@vitest/expect"; +// intersection required to preserve T for inferences /** - * Matcher that checks if a {@linkcode Pokemon} has a specific {@linkcode BattlerTagType}. + * Options type for {@linkcode toHaveBattlerTag}. + * @typeParam B - The {@linkcode BattlerTagType} being checked + * @remarks + * If B corresponds to a serializable `BattlerTag`, only properties allowed to be serialized + * (i.e. can change across instances) will be present and able to be checked. + */ +export type toHaveBattlerTagOptions = (B extends SerializableBattlerTagType + ? OneOther + : OneOther) & { + tagType: B; +}; + +/** + * Matcher that checks if a {@linkcode Pokemon} has a specific {@linkcode BattlerTag}. * @param received - The object to check. Should be a {@linkcode Pokemon} - * @param expectedBattlerTagType - The {@linkcode BattlerTagType} to check for + * @param expectedTag - The `BattlerTagType` of the desired tag, or a partially-filled object + * containing the desired properties * @returns Whether the matcher passed */ -export function toHaveBattlerTag( +export function toHaveBattlerTag( this: MatcherState, received: unknown, - expectedBattlerTagType: BattlerTagType, + expectedTag: B | toHaveBattlerTagOptions, ): SyncExpectationResult { if (!isPokemonInstance(received)) { return { @@ -26,18 +44,44 @@ export function toHaveBattlerTag( }; } - const pass = !!received.getTag(expectedBattlerTagType); const pkmName = getPokemonNameWithAffix(received); - // "BattlerTagType.SEEDED (=1)" - const expectedTagStr = getEnumStr(BattlerTagType, expectedBattlerTagType, { prefix: "BattlerTagType." }); + // Coerce lone `tagType`s into objects + const etag = typeof expectedTag === "object" ? expectedTag : { tagType: expectedTag }; + const gotTag = received.getTag(etag.tagType); + + // If checking exclusively tag type OR no tags were found, break out early. + if (typeof expectedTag !== "object" || !gotTag) { + const pass = !!gotTag; + // "BattlerTagType.SEEDED (=1)" + const expectedTagStr = getEnumStr(BattlerTagType, etag.tagType, { prefix: "BattlerTagType." }); + + return { + pass, + message: () => + pass + ? `Expected ${pkmName} to NOT have a tag of type ${expectedTagStr}, but it did!` + : `Expected ${pkmName} to have a tag of type ${expectedTagStr}, but it didn't!`, + expected: expectedTag, + actual: received.summonData.tags.map(t => t.tagType), + }; + } + + // Check for equality with the provided tag + const pass = this.equals(gotTag, etag, [ + ...this.customTesters, + this.utils.subsetEquality, + this.utils.iterableEquality, + ]); + + const expectedStr = getOnelineDiffStr.call(this, expectedTag); return { pass, message: () => pass - ? `Expected ${pkmName} to NOT have ${expectedTagStr}, but it did!` - : `Expected ${pkmName} to have ${expectedTagStr}, but it didn't!`, - expected: expectedBattlerTagType, - actual: received.summonData.tags.map(t => t.tagType), + ? `Expected ${pkmName} to NOT have a tag matching ${expectedStr}, but it did!` + : `Expected ${pkmName} to have a tag matching ${expectedStr}, but it didn't!`, + expected: expectedTag, + actual: gotTag, }; } diff --git a/test/test-utils/string-utils.ts b/test/test-utils/string-utils.ts index 6c29c04c107..e19224f4571 100644 --- a/test/test-utils/string-utils.ts +++ b/test/test-utils/string-utils.ts @@ -183,5 +183,5 @@ export function getOnelineDiffStr(this: MatcherState, obj: unknown): string { return this.utils .stringify(obj, undefined, { maxLength: 35, indent: 0, printBasicPrototype: false }) .replace(/\n/g, " ") // Replace newlines with spaces - .replace(/,(\s*)}$/g, "$1}"); // Trim trailing commas + .replace(/,(\s*)\}$/g, "$1}"); // Trim trailing commas }