Merge branch 'pagefaultgames:beta' into midturnab

public/images/pokemon/back/658.json

@@ -1,19 +1,19 @@
 { "frames": [
    {
     "filename": "0001.png",
-    "frame": { "x": 0, "y": 0, "w": 77, "h": 77 },
+    "frame": { "x": 0, "y": 0, "w": 77, "h": 65 },
     "rotated": false,
     "trimmed": false,
-    "spriteSourceSize": { "x": 0, "y": 0, "w": 77, "h": 77 },
-    "sourceSize": { "w": 77, "h": 77 },
+    "spriteSourceSize": { "x": 0, "y": 0, "w": 77, "h": 65 },
+    "sourceSize": { "w": 77, "h": 65 },
     "duration": 100
    }
  ],
  "meta": {
   "app": "https://www.aseprite.org/",
-  "version": "1.3.7-x64",
+  "version": "1.3.9.2-x64",
   "format": "I8",
-  "size": { "w": 77, "h": 77 },
+  "size": { "w": 77, "h": 65 },
   "scale": "1"
  }
 }

public/images/pokemon/back/shiny/658.json

@@ -1,11 +1,11 @@
 { "frames": [
    {
     "filename": "0001.png",
-    "frame": { "x": 0, "y": 0, "w": 77, "h": 77 },
+    "frame": { "x": 0, "y": 0, "w": 77, "h": 65 },
     "rotated": false,
     "trimmed": false,
-    "spriteSourceSize": { "x": 0, "y": 0, "w": 77, "h": 77 },
-    "sourceSize": { "w": 77, "h": 77 },
+    "spriteSourceSize": { "x": 0, "y": 0, "w": 77, "h": 65 },
+    "sourceSize": { "w": 77, "h": 65 },
     "duration": 100
    }
  ],
@@ -13,7 +13,7 @@
   "app": "https://www.aseprite.org/",
   "version": "1.3.7-x64",
   "format": "I8",
-  "size": { "w": 77, "h": 77 },
+  "size": { "w": 77, "h": 65 },
   "scale": "1"
  }
 }

src/data/battler-tags.ts

@@ -1752,7 +1752,7 @@ export class HighestStatBoostTag extends AbilityBattlerTag {
     super.onAdd(pokemon);
 
     let highestStat: EffectiveStat;
-    EFFECTIVE_STATS.map(s => pokemon.getEffectiveStat(s)).reduce((highestValue: number, value: number, i: number) => {
+    EFFECTIVE_STATS.map(s => pokemon.getEffectiveStat(s, undefined, undefined, undefined, undefined, undefined, undefined, true)).reduce((highestValue: number, value: number, i: number) => {
       if (value > highestValue) {
         highestStat = EFFECTIVE_STATS[i];
         return value;
@@ -1763,15 +1763,7 @@ export class HighestStatBoostTag extends AbilityBattlerTag {
     highestStat = highestStat!; // tell TS compiler it's defined!
     this.stat = highestStat;
 
-    switch (this.stat) {
-      case Stat.SPD:
-        this.multiplier = 1.5;
-        break;
-      default:
-        this.multiplier = 1.3;
-        break;
-    }
-
+    this.multiplier = this.stat === Stat.SPD ? 1.5 : 1.3;
     globalScene.queueMessage(i18next.t("battlerTags:highestStatBoostOnAdd", { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), statName: i18next.t(getStatKey(highestStat)) }), null, false, null, true);
   }
 

src/data/move.ts

@@ -4559,7 +4559,8 @@ export class TeraMoveCategoryAttr extends VariableMoveCategoryAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
     const category = (args[0] as Utils.NumberHolder);
 
-    if (user.isTerastallized() && user.getEffectiveStat(Stat.ATK, target, move) > user.getEffectiveStat(Stat.SPATK, target, move)) {
+    if (user.isTerastallized() && user.getEffectiveStat(Stat.ATK, target, move, true, true, false, false, true) >
+    user.getEffectiveStat(Stat.SPATK, target, move, true, true, false, false, true)) {
       category.value = MoveCategory.PHYSICAL;
       return true;
     }
@@ -10905,8 +10906,7 @@ export function initMoves() {
       .attr(TeraMoveCategoryAttr)
       .attr(TeraBlastTypeAttr)
       .attr(TeraBlastPowerAttr)
-      .attr(StatStageChangeAttr, [ Stat.ATK, Stat.SPATK ], -1, true, { condition: (user, target, move) => user.isTerastallized() && user.isOfType(Type.STELLAR) })
-      .partial(), /** Does not ignore abilities that affect stats, relevant in determining the move's category {@see TeraMoveCategoryAttr} */
+      .attr(StatStageChangeAttr, [ Stat.ATK, Stat.SPATK ], -1, true, { condition: (user, target, move) => user.isTerastallized() && user.isOfType(Type.STELLAR) }),
     new SelfStatusMove(Moves.SILK_TRAP, Type.BUG, -1, 10, -1, 4, 9)
       .attr(ProtectAttr, BattlerTagType.SILK_TRAP)
       .condition(failIfLastCondition),

src/data/mystery-encounters/encounters/fun-and-games-encounter.ts

@@ -41,8 +41,6 @@ export const FunAndGamesEncounter: MysteryEncounter =
     .withSceneWaveRangeRequirement(...CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES)
     .withSceneRequirement(new MoneyRequirement(0, 1.5)) // Cost equal to 1 Max Potion to play
     .withAutoHideIntroVisuals(false)
-    // Allows using move without a visible enemy pokemon
-    .withBattleAnimationsWithoutTargets(true)
     // The Wobbuffet won't use moves
     .withSkipEnemyBattleTurns(true)
     // Will skip COMMAND selection menu and go straight to FIGHT (move select) menu

src/field/pokemon.ts

@@ -947,11 +947,14 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    * @param ignoreOppAbility during an attack, determines whether the opposing Pokemon's abilities should be ignored during the stat calculation.
    * @param isCritical determines whether a critical hit has occurred or not (`false` by default)
    * @param simulated if `true`, nullifies any effects that produce any changes to game state from triggering
+   * @param ignoreHeldItems determines whether this Pokemon's held items should be ignored during the stat calculation, default `false`
    * @returns the final in-battle value of a stat
    */
-  getEffectiveStat(stat: EffectiveStat, opponent?: Pokemon, move?: Move, ignoreAbility: boolean = false, ignoreOppAbility: boolean = false, isCritical: boolean = false, simulated: boolean = true): number {
+  getEffectiveStat(stat: EffectiveStat, opponent?: Pokemon, move?: Move, ignoreAbility: boolean = false, ignoreOppAbility: boolean = false, isCritical: boolean = false, simulated: boolean = true, ignoreHeldItems: boolean = false): number {
     const statValue = new Utils.NumberHolder(this.getStat(stat, false));
-    globalScene.applyModifiers(StatBoosterModifier, this.isPlayer(), this, stat, statValue);
+    if (!ignoreHeldItems) {
+      globalScene.applyModifiers(StatBoosterModifier, this.isPlayer(), this, stat, statValue);
+    }
 
     // The Ruin abilities here are never ignored, but they reveal themselves on summon anyway
     const fieldApplied = new Utils.BooleanHolder(false);
@@ -965,7 +968,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       applyStatMultiplierAbAttrs(StatMultiplierAbAttr, this, stat, statValue, simulated);
     }
 
-    let ret = statValue.value * this.getStatStageMultiplier(stat, opponent, move, ignoreOppAbility, isCritical, simulated);
+    let ret = statValue.value * this.getStatStageMultiplier(stat, opponent, move, ignoreOppAbility, isCritical, simulated, ignoreHeldItems);
 
     switch (stat) {
       case Stat.ATK:
@@ -1063,6 +1066,8 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     globalScene.applyModifiers(PokemonBaseStatFlatModifier, this.isPlayer(), this, baseStats);
     if (this.isFusion()) {
       const fusionBaseStats = this.getFusionSpeciesForm(true).baseStats;
+      applyChallenges(globalScene.gameMode, ChallengeType.FLIP_STAT, this, fusionBaseStats);
+
       for (const s of PERMANENT_STATS) {
         baseStats[s] = Math.ceil((baseStats[s] + fusionBaseStats[s]) / 2);
       }
@@ -2499,9 +2504,10 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    * @param ignoreOppAbility determines whether the effects of the opponent's abilities (i.e. Unaware) should be ignored (`false` by default)
    * @param isCritical determines whether a critical hit has occurred or not (`false` by default)
    * @param simulated determines whether effects are applied without altering game state (`true` by default)
+   * @param ignoreHeldItems determines whether this Pokemon's held items should be ignored during the stat calculation, default `false`
    * @return the stat stage multiplier to be used for effective stat calculation
    */
-  getStatStageMultiplier(stat: EffectiveStat, opponent?: Pokemon, move?: Move, ignoreOppAbility: boolean = false, isCritical: boolean = false, simulated: boolean = true): number {
+  getStatStageMultiplier(stat: EffectiveStat, opponent?: Pokemon, move?: Move, ignoreOppAbility: boolean = false, isCritical: boolean = false, simulated: boolean = true, ignoreHeldItems: boolean = false): number {
     const statStage = new Utils.IntegerHolder(this.getStatStage(stat));
     const ignoreStatStage = new Utils.BooleanHolder(false);
 
@@ -2528,7 +2534,9 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
 
     if (!ignoreStatStage.value) {
       const statStageMultiplier = new Utils.NumberHolder(Math.max(2, 2 + statStage.value) / Math.max(2, 2 - statStage.value));
-      globalScene.applyModifiers(TempStatStageBoosterModifier, this.isPlayer(), stat, statStageMultiplier);
+      if (!ignoreHeldItems) {
+        globalScene.applyModifiers(TempStatStageBoosterModifier, this.isPlayer(), stat, statStageMultiplier);
+      }
       return Math.min(statStageMultiplier.value, 4);
     }
     return 1;

src/test/abilities/protosynthesis.test.ts

@@ -0,0 +1,66 @@
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Nature } from "#enums/nature";
+import { Species } from "#enums/species";
+import { Stat } from "#enums/stat";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { BattlerIndex } from "#app/battle";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Abilities - Protosynthesis", () => {
+  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
+      .moveset([ Moves.SPLASH, Moves.TACKLE ])
+      .ability(Abilities.PROTOSYNTHESIS)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("should not consider temporary items when determining which stat to boost", async() => {
+    // Mew has uniform base stats
+    game.override.startingModifier([{ name: "TEMP_STAT_STAGE_BOOSTER", type: Stat.DEF }])
+      .enemyMoveset(Moves.SUNNY_DAY)
+      .startingLevel(100)
+      .enemyLevel(100);
+    await game.classicMode.startBattle([ Species.MEW ]);
+    const mew = game.scene.getPlayerPokemon()!;
+    // Nature of starting mon is randomized. We need to fix it to a neutral nature for the automated test.
+    mew.setNature(Nature.HARDY);
+    const enemy = game.scene.getEnemyPokemon()!;
+    const def_before_boost = mew.getEffectiveStat(Stat.DEF, undefined, undefined, false, undefined, false, false, true);
+    const atk_before_boost = mew.getEffectiveStat(Stat.ATK, undefined, undefined, false, undefined, false, false, true);
+    const initialHp = enemy.hp;
+    game.move.select(Moves.TACKLE);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+    await game.toNextTurn();
+    const unboosted_dmg = initialHp - enemy.hp;
+    enemy.hp = initialHp;
+    const def_after_boost = mew.getEffectiveStat(Stat.DEF, undefined, undefined, false, undefined, false, false, true);
+    const atk_after_boost = mew.getEffectiveStat(Stat.ATK, undefined, undefined, false, undefined, false, false, true);
+    game.move.select(Moves.TACKLE);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+    await game.toNextTurn();
+    const boosted_dmg = initialHp - enemy.hp;
+    expect(boosted_dmg).toBeGreaterThan(unboosted_dmg);
+    expect(def_after_boost).toEqual(def_before_boost);
+    expect(atk_after_boost).toBeGreaterThan(atk_before_boost);
+  });
+});

src/test/moves/tera_blast.test.ts

@@ -1,6 +1,6 @@
 import { BattlerIndex } from "#app/battle";
 import { Stat } from "#enums/stat";
-import { allMoves } from "#app/data/move";
+import { allMoves, TeraMoveCategoryAttr } from "#app/data/move";
 import { Type } from "#enums/type";
 import { Abilities } from "#app/enums/abilities";
 import { HitResult } from "#app/field/pokemon";
@@ -14,6 +14,7 @@ describe("Moves - Tera Blast", () => {
   let phaserGame: Phaser.Game;
   let game: GameManager;
   const moveToCheck = allMoves[Moves.TERA_BLAST];
+  const teraBlastAttr = moveToCheck.getAttrs(TeraMoveCategoryAttr)[0];
 
   beforeAll(() => {
     phaserGame = new Phaser.Game({
@@ -86,19 +87,86 @@ describe("Moves - Tera Blast", () => {
     expect(enemyPokemon.apply).toHaveReturnedWith(HitResult.SUPER_EFFECTIVE);
   });
 
-  // Currently abilities are bugged and can't see when a move's category is changed
-  it.todo("uses the higher stat of the user's Atk and SpAtk for damage calculation", async () => {
-    game.override.enemyAbility(Abilities.TOXIC_DEBRIS);
+  it("uses the higher ATK for damage calculation", async () => {
     await game.startBattle();
 
     const playerPokemon = game.scene.getPlayerPokemon()!;
     playerPokemon.stats[Stat.ATK] = 100;
     playerPokemon.stats[Stat.SPATK] = 1;
 
+    vi.spyOn(teraBlastAttr, "apply");
+
     game.move.select(Moves.TERA_BLAST);
-    await game.phaseInterceptor.to("TurnEndPhase");
-    expect(game.scene.getEnemyPokemon()!.battleData.abilityRevealed).toBe(true);
-  }, 20000);
+    await game.toNextTurn();
+    expect(teraBlastAttr.apply).toHaveLastReturnedWith(true);
+  });
+
+  it("uses the higher SPATK for damage calculation", async () => {
+    await game.startBattle();
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+    playerPokemon.stats[Stat.ATK] = 1;
+    playerPokemon.stats[Stat.SPATK] = 100;
+
+    vi.spyOn(teraBlastAttr, "apply");
+
+    game.move.select(Moves.TERA_BLAST);
+    await game.toNextTurn();
+    expect(teraBlastAttr.apply).toHaveLastReturnedWith(false);
+  });
+
+  it("should stay as a special move if ATK turns lower than SPATK mid-turn", async () => {
+    game.override.enemyMoveset([ Moves.CHARM ]);
+    await game.startBattle();
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+    playerPokemon.stats[Stat.ATK] = 51;
+    playerPokemon.stats[Stat.SPATK] = 50;
+
+    vi.spyOn(teraBlastAttr, "apply");
+
+    game.move.select(Moves.TERA_BLAST);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+    expect(teraBlastAttr.apply).toHaveLastReturnedWith(false);
+  });
+
+  it("does not change its move category from stat changes due to held items", async () => {
+    game.override
+      .startingHeldItems([{ name: "SPECIES_STAT_BOOSTER", type: "THICK_CLUB" }])
+      .starterSpecies(Species.CUBONE);
+    await game.startBattle();
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+
+    playerPokemon.stats[Stat.ATK] = 50;
+    playerPokemon.stats[Stat.SPATK] = 51;
+
+    vi.spyOn(teraBlastAttr, "apply");
+
+    game.move.select(Moves.TERA_BLAST);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+
+    expect(teraBlastAttr.apply).toHaveLastReturnedWith(false);
+  });
+
+  it("does not change its move category from stat changes due to abilities", async () => {
+    game.override.ability(Abilities.HUGE_POWER);
+    await game.startBattle();
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+    playerPokemon.stats[Stat.ATK] = 50;
+    playerPokemon.stats[Stat.SPATK] = 51;
+
+    vi.spyOn(teraBlastAttr, "apply");
+
+    game.move.select(Moves.TERA_BLAST);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+    expect(teraBlastAttr.apply).toHaveLastReturnedWith(false);
+  });
+
 
   it("causes stat drops if user is Stellar tera type", async () => {
     game.override.startingHeldItems([{ name: "TERA_SHARD", type: Type.STELLAR }]);