[Ability] Implement Illusion

src/battle-scene.ts

@@ -957,7 +957,7 @@ export default class BattleScene extends SceneBase {
 
  container.add(icon);
 
- if (pokemon.isFusion()) {
+ if (pokemon.isFusion(true)) {
  const fusionIcon = this.add.sprite(0, 0, pokemon.getFusionIconAtlasKey(ignoreOverride));
  fusionIcon.setName("sprite-fusion-icon");
  fusionIcon.setOrigin(0.5, 0);

src/data/ability.ts

@@ -2024,7 +2024,6 @@ export class PostSummonRemoveArenaTagAbAttr extends PostSummonAbAttr {
  return true;
  }
 }
-
 export class PostSummonMessageAbAttr extends PostSummonAbAttr {
  private messageFunc: (pokemon: Pokemon) => string;
 
@@ -2043,6 +2042,18 @@ export class PostSummonMessageAbAttr extends PostSummonAbAttr {
  }
 }
 
+/**
+ * Removes illusions when a Pokemon is summoned.
+ */
+export class PostSummonRemoveIllusionAbAttr extends PostSummonAbAttr {
+ applyPostSummon(pokemon: Pokemon, passive: boolean, simulated: boolean, args: any[]): boolean {
+ pokemon.scene.getField(true).map(pokemon => {
+ pokemon.breakIllusion();
+ });
+ return true;
+ }
+}
+
 export class PostSummonUnnamedMessageAbAttr extends PostSummonAbAttr {
  //Attr doesn't force pokemon name on the message
  private message: string;
@@ -2429,13 +2440,16 @@ export class PostSummonTransformAbAttr extends PostSummonAbAttr {
  }
  const promises: Promise<void>[] = [];
 
- let target: Pokemon;
+ let target: Pokemon = targets[0];
  if (targets.length > 1) {
  pokemon.scene.executeWithSeedOffset(() => target = Utils.randSeedItem(targets), pokemon.scene.currentBattle.waveIndex);
  } else {
  target = targets[0];
  }
 
+ if (target.battleData.illusion.active) {
+ return false;
+ }
  target = target!;
  pokemon.summonData.speciesForm = target.getSpeciesForm();
  pokemon.summonData.fusionSpeciesForm = target.getFusionSpeciesForm();
@@ -4003,8 +4017,8 @@ export class MaxMultiHitAbAttr extends AbAttr {
 }
 
 export class PostBattleAbAttr extends AbAttr {
- constructor() {
- super(true);
+ constructor(showAbility: boolean = true) {
+ super(showAbility);
  }
 
  applyPostBattle(pokemon: Pokemon, passive: boolean, simulated: boolean, args: any[]): boolean {
@@ -4590,6 +4604,99 @@ export class FormBlockDamageAbAttr extends ReceivedMoveDamageMultiplierAbAttr {
  }
 }
 
+/**
+ * Base class for defining {@linkcode Ability} attributes before summon
+ * (should use {@linkcode PostSummonAbAttr} for most ability)
+ * @see {@linkcode applyPreSummon()}
+ */
+export class PreSummonAbAttr extends AbAttr {
+ applyPreSummon(pokemon: Pokemon, passive: boolean, args: any[]): boolean {
+ return false;
+ }
+}
+
+export class IllusionPreSummonAbAttr extends PreSummonAbAttr {
+ /**
+ * Apply a new illusion when summoning Zoroark if the illusion is available
+ *
+ * @param {Pokemon} pokemon - The Pokémon with the Illusion ability.
+ * @param {boolean} passive - N/A
+ * @param {...any} args - N/A
+ * @returns {boolean} - Whether the illusion was applied.
+ */
+ applyPreSummon(pokemon: Pokemon, passive: boolean, args: any[]): boolean {
+ let suppressed = false;
+ console.log("PRESUMMONILLUSION : ", pokemon.name);
+ pokemon.scene.getField(true).filter(p => p !== pokemon).map(p => {
+ if ((p.getAbility().hasAttr(SuppressFieldAbilitiesAbAttr) && p.canApplyAbility()) || (p.getPassiveAbility().hasAttr(SuppressFieldAbilitiesAbAttr) && p.canApplyAbility(true))) {
+ suppressed = true;
+ }
+ });
+
+ if (pokemon.battleData.illusion.available && !suppressed) {
+ return pokemon.generateIllusion();
+ } else {
+ return false;
+ }
+ }
+}
+
+export class IllusionBreakAbAttr extends PostDefendAbAttr {
+ /**
+ * Destroy illusion if attack move deals damage to zoroark
+ *
+ * @param {Pokemon} pokemon - The Pokémon with the Illusion ability.
+ * @param {boolean} passive - N/A
+ * @param {Pokemon} attacker - The attacking Pokémon.
+ * @param {PokemonMove} move - The move being used.
+ * @param {PokemonMove} hitResult - The type of hitResult the pokemon got
+ * @param {...any} args - N/A
+ * @returns {boolean} - Whether the illusion was destroyed.
+ */
+ applyPostDefend(pokemon: Pokemon, passive: boolean, simulated: boolean, attacker: Pokemon, move: Move, hitResult: HitResult, args: any[]): boolean {
+
+ const breakIllusion: HitResult[] = [ HitResult.EFFECTIVE, HitResult.SUPER_EFFECTIVE, HitResult.NOT_VERY_EFFECTIVE, HitResult.ONE_HIT_KO ];
+ if (!breakIllusion.includes(hitResult)) {
+ return false;
+ }
+ pokemon.breakIllusion();
+ return true;
+ }
+}
+
+export class IllusionPostBattleAbAttr extends PostBattleAbAttr {
+ /**
+ * Illusion will be available again after a battle and apply the illusion of the pokemon is already on field
+ *
+ * @param {Pokemon} pokemon - The Pokémon with the Illusion ability.
+ * @param {boolean} passive - N/A
+ * @param {...any} args - N/A
+ * @returns {boolean} - Whether the illusion was applied.
+ */
+ applyPostBattle(pokemon: Pokemon, passive: boolean, simulated:boolean, args: any[]): boolean {
+ pokemon.breakIllusion();
+ pokemon.battleData.illusion.available = true;
+ return true;
+ }
+}
+
+export class IllusionDisableAbAttr extends PostSummonAbAttr {
+ /**
+ * Illusion will be disabled if the pokemon is summoned with an illusion.
+ * So the pokemon can use 1 illusion per battle.
+ *
+ * @param {Pokemon} pokemon - The Pokémon with the Illusion ability.
+ * @param {boolean} passive - N/A
+ * @param {...any} args - N/A
+ * @returns {boolean}
+ */
+ applyPostSummon(pokemon: Pokemon, passive: boolean, simulated: boolean, args: any[]): boolean {
+ pokemon.battleData.illusion.available = false;
+ return true;
+ }
+}
+
+
 /**
  * If a Pokémon with this Ability selects a damaging move, it has a 30% chance of going first in its priority bracket. If the Ability activates, this is announced at the start of the turn (after move selection).
  *
@@ -4804,6 +4911,11 @@ export function applyPostSummonAbAttrs(attrType: Constructor<PostSummonAbAttr>,
  return applyAbAttrsInternal<PostSummonAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPostSummon(pokemon, passive, simulated, args), args, false, simulated);
 }
 
+export function applyPreSummonAbAttrs(attrType: Constructor<PreSummonAbAttr>,
+ pokemon: Pokemon, ...args: any[]) {
+ return applyAbAttrsInternal<PreSummonAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPreSummon(pokemon, passive, args), args);
+}
+
 export function applyPreSwitchOutAbAttrs(attrType: Constructor<PreSwitchOutAbAttr>,
  pokemon: Pokemon, simulated: boolean = false, ...args: any[]): Promise<void> {
  return applyAbAttrsInternal<PreSwitchOutAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPreSwitchOut(pokemon, passive, simulated, args), args, true, simulated);
@@ -5363,7 +5475,15 @@ export function initAbilities() {
  new Ability(Abilities.ILLUSION, 5)
  .attr(UncopiableAbilityAbAttr)
  .attr(UnswappableAbilityAbAttr)
- .unimplemented(),
+ //The pokemon generate an illusion if it's available
+ .conditionalAttr((pokemon) => pokemon.battleData.illusion.available, IllusionPreSummonAbAttr, false)
+ //The pokemon loses his illusion when he is damaged by a move
+ .conditionalAttr((pokemon) => pokemon.battleData.illusion.active, IllusionBreakAbAttr, true)
+ //Illusion is available again after a battle
+ .conditionalAttr((pokemon) => pokemon.isAllowedInBattle(), IllusionPostBattleAbAttr, false)
+ //Illusion is not available after summon
+ .attr(IllusionDisableAbAttr, false)
+ .bypassFaint(),
  new Ability(Abilities.IMPOSTER, 5)
  .attr(PostSummonTransformAbAttr)
  .attr(UncopiableAbilityAbAttr),
@@ -5759,6 +5879,7 @@ export function initAbilities() {
  .attr(UnswappableAbilityAbAttr)
  .attr(NoTransformAbilityAbAttr)
  .attr(PostSummonMessageAbAttr, (pokemon: Pokemon) => i18next.t("abilityTriggers:postSummonNeutralizingGas", { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon) }))
+ .attr(PostSummonRemoveIllusionAbAttr)
  .partial(), // A bunch of weird interactions with other abilities being suppressed then unsuppressed
  new Ability(Abilities.PASTEL_VEIL, 8)
  .attr(PostSummonUserFieldRemoveStatusEffectAbAttr, StatusEffect.POISON, StatusEffect.TOXIC)

src/data/move.ts

@@ -6483,12 +6483,13 @@ export class AbilityChangeAttr extends MoveEffectAttr {
  }
 
  const moveTarget = this.selfTarget ? user : target;
-
- moveTarget.summonData.ability = this.ability;
+ const pokemon: Pokemon = this.selfTarget ? user : target;
+ pokemon.summonData.ability = this.ability;
  user.scene.triggerPokemonFormChange(moveTarget, SpeciesFormChangeRevertWeatherFormTrigger);
-
- user.scene.queueMessage(i18next.t("moveTriggers:acquiredAbility", { pokemonName: getPokemonNameWithAffix((this.selfTarget ? user : target)), abilityName: allAbilities[this.ability].name }));
-
+ if (pokemon.breakIllusion()) {
+ pokemon.scene.queueMessage(i18next.t("abilityTriggers:illusionBreak", { pokemonName: getPokemonNameWithAffix(pokemon) }));
+ }
+ user.scene.queueMessage(i18next.t("moveTriggers:acquiredAbility", { pokemonName: getPokemonNameWithAffix(pokemon), abilityName: allAbilities[this.ability].name }));
  return true;
  }
 
@@ -6644,7 +6645,8 @@ export class SuppressAbilitiesIfActedAttr extends MoveEffectAttr {
 
 export class TransformAttr extends MoveEffectAttr {
  async apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): Promise<boolean> {
- if (!super.apply(user, target, move, args)) {
+ if (!super.apply(user, target, move, args) || target.battleData.illusion.active || user.battleData.illusion.active) {
+ user.scene.queueMessage(i18next.t("battle:attackFailed"));
  return false;
  }