Merge branch 'beta' into admin-panel-unlink-update

public/images/items.json

@@ -3416,12 +3416,12 @@
  "rotated": false,
  "trimmed": true,
  "sourceSize": {
- "w": 24,
- "h": 24
+ "w": 32,
+ "h": 32
  },
  "spriteSourceSize": {
- "x": 1,
- "y": 2,
+ "x": 5,
+ "y": 7,
  "w": 22,
  "h": 19
  },
@@ -8415,6 +8415,6 @@
  "meta": {
  "app": "https://www.codeandweb.com/texturepacker",
  "version": "3.0",
- "smartupdate": "$TexturePacker:SmartUpdate:934ea4080bad980d4fea720cc771f133:ed564bc47b79b15a763de57045178e88:110e074689c9edd2c54833ce2e4d9270$"
+ "smartupdate": "$TexturePacker:SmartUpdate:9ef21166268f7487fc9ff8d0f9b996e4:82658ac7bdd4c2b417e1f59168179262:110e074689c9edd2c54833ce2e4d9270$"
  }
 }

src/battle-scene.ts

@@ -86,7 +86,7 @@ import { ToggleDoublePositionPhase } from "#app/phases/toggle-double-position-ph
 import { TurnInitPhase } from "#app/phases/turn-init-phase";
 import { ShopCursorTarget } from "#app/enums/shop-cursor-target";
 import MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
-import { allMysteryEncounters, ANTI_VARIANCE_WEIGHT_MODIFIER, AVERAGE_ENCOUNTERS_PER_RUN_TARGET, BASE_MYSTERY_ENCOUNTER_SPAWN_WEIGHT, MYSTERY_ENCOUNTER_SPAWN_MAX_WEIGHT, mysteryEncountersByBiome, WEIGHT_INCREMENT_ON_SPAWN_MISS } from "#app/data/mystery-encounters/mystery-encounters";
+import { allMysteryEncounters, ANTI_VARIANCE_WEIGHT_MODIFIER, AVERAGE_ENCOUNTERS_PER_RUN_TARGET, BASE_MYSTERY_ENCOUNTER_SPAWN_WEIGHT, MYSTERY_ENCOUNTER_SPAWN_MAX_WEIGHT, mysteryEncountersByBiome } from "#app/data/mystery-encounters/mystery-encounters";
 import { MysteryEncounterSaveData } from "#app/data/mystery-encounters/mystery-encounter-save-data";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
@@ -1191,10 +1191,7 @@ export default class BattleScene extends SceneBase {
  if (trainerConfigs[trainerType].doubleOnly) {
  doubleTrainer = true;
  } else if (trainerConfigs[trainerType].hasDouble) {
- const doubleChance = new Utils.IntegerHolder(newWaveIndex % 10 === 0 ? 32 : 8);
- this.applyModifiers(DoubleBattleChanceBoosterModifier, true, doubleChance);
- playerField.forEach(p => applyAbAttrs(DoubleBattleChanceAbAttr, p, null, false, doubleChance));
- doubleTrainer = !Utils.randSeedInt(doubleChance.value);
+ doubleTrainer = !Utils.randSeedInt(this.getDoubleBattleChance(newWaveIndex, playerField));
  // Add a check that special trainers can't be double except for tate and liza - they should use the normal double chance
  if (trainerConfigs[trainerType].trainerTypeDouble && ![ TrainerType.TATE, TrainerType.LIZA ].includes(trainerType)) {
  doubleTrainer = false;
@@ -1207,12 +1204,10 @@ export default class BattleScene extends SceneBase {
 
  // Check for mystery encounter
  // Can only occur in place of a standard (non-boss) wild battle, waves 10-180
- if (this.isWaveMysteryEncounter(newBattleType, newWaveIndex, mysteryEncounterType) || newBattleType === BattleType.MYSTERY_ENCOUNTER) {
+ if (this.isWaveMysteryEncounter(newBattleType, newWaveIndex) || newBattleType === BattleType.MYSTERY_ENCOUNTER) {
  newBattleType = BattleType.MYSTERY_ENCOUNTER;
- // Reset base spawn weight
+ // Reset to base spawn weight
  this.mysteryEncounterSaveData.encounterSpawnChance = BASE_MYSTERY_ENCOUNTER_SPAWN_WEIGHT;
- } else if (newBattleType === BattleType.WILD) {
- this.mysteryEncounterSaveData.encounterSpawnChance += WEIGHT_INCREMENT_ON_SPAWN_MISS;
  }
  }
 
@@ -2364,6 +2359,19 @@ export default class BattleScene extends SceneBase {
  return false;
  }
 
+ /**
+ * Will search for a specific phase in {@linkcode phaseQueuePrepend} via filter, and remove the first result if a match is found.
+ * @param phaseFilter filter function
+ */
+ tryRemoveUnshiftedPhase(phaseFilter: (phase: Phase) => boolean): boolean {
+ const phaseIndex = this.phaseQueuePrepend.findIndex(phaseFilter);
+ if (phaseIndex > -1) {
+ this.phaseQueuePrepend.splice(phaseIndex, 1);
+ return true;
+ }
+ return false;
+ }
+
  /**
  * Tries to add the input phase to index before target phase in the phaseQueue, else simply calls unshiftPhase()
  * @param phase {@linkcode Phase} the phase to be added
@@ -3125,18 +3133,26 @@ export default class BattleScene extends SceneBase {
  }
  }
 
+ /**
+ * Returns if a wave COULD spawn a {@linkcode MysteryEncounter}.
+ * Even if returns `true`, does not guarantee that a wave will actually be a ME.
+ * That check is made in {@linkcode BattleScene.isWaveMysteryEncounter} instead.
+ */
+ isMysteryEncounterValidForWave(battleType: BattleType, waveIndex: number): boolean {
+ const [ lowestMysteryEncounterWave, highestMysteryEncounterWave ] = this.gameMode.getMysteryEncounterLegalWaves();
+ return this.gameMode.hasMysteryEncounters && battleType === BattleType.WILD && !this.gameMode.isBoss(waveIndex) && waveIndex < highestMysteryEncounterWave && waveIndex > lowestMysteryEncounterWave;
+ }
+
  /**
  * Determines whether a wave should randomly generate a {@linkcode MysteryEncounter}.
  * Currently, the only modes that MEs are allowed in are Classic and Challenge.
  * Additionally, MEs cannot spawn outside of waves 10-180 in those modes
- *
  * @param newBattleType
  * @param waveIndex
- * @param sessionDataEncounterType
  */
- private isWaveMysteryEncounter(newBattleType: BattleType, waveIndex: number, sessionDataEncounterType?: MysteryEncounterType): boolean {
+ private isWaveMysteryEncounter(newBattleType: BattleType, waveIndex: number): boolean {
  const [ lowestMysteryEncounterWave, highestMysteryEncounterWave ] = this.gameMode.getMysteryEncounterLegalWaves();
- if (this.gameMode.hasMysteryEncounters && newBattleType === BattleType.WILD && !this.gameMode.isBoss(waveIndex) && waveIndex < highestMysteryEncounterWave && waveIndex > lowestMysteryEncounterWave) {
+ if (this.isMysteryEncounterValidForWave(newBattleType, waveIndex)) {
  // Base spawn weight is BASE_MYSTERY_ENCOUNTER_SPAWN_WEIGHT/256, and increases by WEIGHT_INCREMENT_ON_SPAWN_MISS/256 for each missed attempt at spawning an encounter on a valid floor
  const sessionEncounterRate = this.mysteryEncounterSaveData.encounterSpawnChance;
  const encounteredEvents = this.mysteryEncounterSaveData.encounteredEvents;

src/data/ability.ts

@@ -4200,6 +4200,11 @@ export class RedirectTypeMoveAbAttr extends RedirectMoveAbAttr {
 
 export class BlockRedirectAbAttr extends AbAttr { }
 
+/**
+ * Used by Early Bird, makes the pokemon wake up faster
+ * @param statusEffect - The {@linkcode StatusEffect} to check for
+ * @see {@linkcode apply}
+ */
 export class ReduceStatusEffectDurationAbAttr extends AbAttr {
  private statusEffect: StatusEffect;
 
@@ -4209,9 +4214,19 @@ export class ReduceStatusEffectDurationAbAttr extends AbAttr {
  this.statusEffect = statusEffect;
  }
 
- apply(pokemon: Pokemon, passive: boolean, simulated: boolean, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+ /**
+ * Reduces the number of sleep turns remaining by an extra 1 when applied
+ * @param args - The args passed to the `AbAttr`:
+ * - `[0]` - The {@linkcode StatusEffect} of the Pokemon
+ * - `[1]` - The number of turns remaining until the status is healed
+ * @returns `true` if the ability was applied
+ */
+ apply(_pokemon: Pokemon, _passive: boolean, _simulated: boolean, _cancelled: Utils.BooleanHolder, args: any[]): boolean {
+ if (!(args[1] instanceof Utils.NumberHolder)) {
+ return false;
+ }
  if (args[0] === this.statusEffect) {
- (args[1] as Utils.IntegerHolder).value = Utils.toDmgValue((args[1] as Utils.IntegerHolder).value / 2);
+ args[1].value -= 1;
  return true;
  }
 
@@ -4342,6 +4357,30 @@ export class AlwaysHitAbAttr extends AbAttr { }
 /** Attribute for abilities that allow moves that make contact to ignore protection (i.e. Unseen Fist) */
 export class IgnoreProtectOnContactAbAttr extends AbAttr { }
 
+/**
+ * Attribute implementing the effects of {@link https://bulbapedia.bulbagarden.net/wiki/Infiltrator_(Ability) | Infiltrator}.
+ * Allows the source's moves to bypass the effects of opposing Light Screen, Reflect, Aurora Veil, Safeguard, Mist, and Substitute.
+ */
+export class InfiltratorAbAttr extends AbAttr {
+ /**
+ * Sets a flag to bypass screens, Substitute, Safeguard, and Mist
+ * @param pokemon n/a
+ * @param passive n/a
+ * @param simulated n/a
+ * @param cancelled n/a
+ * @param args `[0]` a {@linkcode Utils.BooleanHolder | BooleanHolder} containing the flag
+ * @returns `true` if the bypass flag was successfully set; `false` otherwise.
+ */
+ override apply(pokemon: Pokemon, passive: boolean, simulated: boolean, cancelled: null, args: any[]): boolean {
+ const bypassed = args[0];
+ if (args[0] instanceof Utils.BooleanHolder) {
+ bypassed.value = true;
+ return true;
+ }
+ return false;
+ }
+}
+
 export class UncopiableAbilityAbAttr extends AbAttr {
  constructor() {
  super(false);
@@ -5321,7 +5360,8 @@ export function initAbilities() {
  .attr(PostSummonTransformAbAttr)
  .attr(UncopiableAbilityAbAttr),
  new Ability(Abilities.INFILTRATOR, 5)
- .unimplemented(),
+ .attr(InfiltratorAbAttr)
+ .partial(), // does not bypass Mist
  new Ability(Abilities.MUMMY, 5)
  .attr(PostDefendAbilityGiveAbAttr, Abilities.MUMMY)
  .bypassFaint(),

src/data/arena-tag.ts

@@ -7,7 +7,7 @@ import { getPokemonNameWithAffix } from "#app/messages";
 import Pokemon, { HitResult, PokemonMove } from "#app/field/pokemon";
 import { StatusEffect } from "#app/data/status-effect";
 import { BattlerIndex } from "#app/battle";
-import { BlockNonDirectDamageAbAttr, ChangeMovePriorityAbAttr, ProtectStatAbAttr, applyAbAttrs } from "#app/data/ability";
+import { BlockNonDirectDamageAbAttr, ChangeMovePriorityAbAttr, InfiltratorAbAttr, ProtectStatAbAttr, applyAbAttrs } from "#app/data/ability";
 import { Stat } from "#enums/stat";
 import { CommonAnim, CommonBattleAnim } from "#app/data/battle-anims";
 import i18next from "i18next";
@@ -130,7 +130,18 @@ export class MistTag extends ArenaTag {
  * to flag the stat reduction as cancelled
  * @returns `true` if a stat reduction was cancelled; `false` otherwise
  */
- override apply(arena: Arena, simulated: boolean, cancelled: BooleanHolder): boolean {
+ override apply(arena: Arena, simulated: boolean, attacker: Pokemon, cancelled: BooleanHolder): boolean {
+ // `StatStageChangePhase` currently doesn't have a reference to the source of stat drops,
+ // so this code currently has no effect on gameplay.
+ if (attacker) {
+ const bypassed = new BooleanHolder(false);
+ // TODO: Allow this to be simulated
+ applyAbAttrs(InfiltratorAbAttr, attacker, null, false, bypassed);
+ if (bypassed.value) {
+ return false;
+ }
+ }
+
  cancelled.value = true;
 
  if (!simulated) {
@@ -169,12 +180,18 @@ export class WeakenMoveScreenTag extends ArenaTag {
  *
  * @param arena the {@linkcode Arena} where the move is applied.
  * @param simulated n/a
+ * @param attacker the attacking {@linkcode Pokemon}
  * @param moveCategory the attacking move's {@linkcode MoveCategory}.
  * @param damageMultiplier A {@linkcode NumberHolder} containing the damage multiplier
  * @returns `true` if the attacking move was weakened; `false` otherwise.
  */
- override apply(arena: Arena, simulated: boolean, moveCategory: MoveCategory, damageMultiplier: NumberHolder): boolean {
+ override apply(arena: Arena, simulated: boolean, attacker: Pokemon, moveCategory: MoveCategory, damageMultiplier: NumberHolder): boolean {
  if (this.weakenedCategories.includes(moveCategory)) {
+ const bypassed = new BooleanHolder(false);
+ applyAbAttrs(InfiltratorAbAttr, attacker, null, false, bypassed);
+ if (bypassed.value) {
+ return false;
+ }
  damageMultiplier.value = arena.scene.currentBattle.double ? 2732 / 4096 : 0.5;
  return true;
  }
@@ -626,7 +643,7 @@ export class ArenaTrapTag extends ArenaTag {
  * @returns `true` if this hazard affects the given Pokemon; `false` otherwise.
  */
  override apply(arena: Arena, simulated: boolean, pokemon: Pokemon): boolean {
- if (this.sourceId === pokemon.id || (this.side === ArenaTagSide.PLAYER) !== pokemon.isPlayer()) {
+ if ((this.side === ArenaTagSide.PLAYER) !== pokemon.isPlayer()) {
  return false;
  }