[Ability] Implement ability illusion

src/battle-scene.ts

@@ -836,7 +836,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

@@ -1833,6 +1833,12 @@ export class PostSummonRemoveArenaTagAbAttr extends PostSummonAbAttr {
   }
 }
 
+export class PreSummonAbAttr extends AbAttr {
+  applyPreSummon(pokemon: Pokemon, passive: boolean, party: Pokemon[], args: any[]): boolean {
+    return false;
+  }
+}
+
 export class PostSummonMessageAbAttr extends PostSummonAbAttr {
   private messageFunc: (pokemon: Pokemon) => string;
 
@@ -1845,6 +1851,11 @@ export class PostSummonMessageAbAttr extends PostSummonAbAttr {
   applyPostSummon(pokemon: Pokemon, passive: boolean, args: any[]): boolean {
     pokemon.scene.queueMessage(this.messageFunc(pokemon));
 
+    pokemon.scene.getField(true).map(pokemon => {
+      if (pokemon.breakIllusion()) {
+        pokemon.scene.queueMessage(i18next.t("abilityTriggers:illusionBreak", { pokemonName: getPokemonNameWithAffix(pokemon) }));
+      }
+    });
     return true;
   }
 }
@@ -2166,6 +2177,10 @@ export class PostSummonTransformAbAttr extends PostSummonAbAttr {
       target = targets[0];
     }
 
+    if (target.illusion.active) {
+      return false;
+    }
+
     pokemon.summonData.speciesForm = target.getSpeciesForm();
     pokemon.summonData.fusionSpeciesForm = target.getFusionSpeciesForm();
     pokemon.summonData.ability = target.getAbility().id;
@@ -3387,11 +3402,11 @@ export class MaxMultiHitAbAttr extends AbAttr {
 }
 
 export class PostBattleAbAttr extends AbAttr {
-  constructor() {
-    super(true);
+  constructor(showAbility: boolean = true) {
+    super(showAbility);
   }
 
-  applyPostBattle(pokemon: Pokemon, passive: boolean, args: any[]): boolean {
+  applyPostBattle(pokemon: Pokemon, passive: boolean, party: Pokemon[], args: any[]): boolean {
     return false;
   }
 }
@@ -3874,6 +3889,93 @@ export class IceFaceBlockPhysicalAbAttr extends ReceivedMoveDamageMultiplierAbAt
   }
 }
 
+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 {Pokemon[]} party - The party of the trainer's pokemon.
+   * @param {...any} args - N/A
+   * @returns {boolean} - Whether the illusion was applied.
+   */
+  applyPreSummon(pokemon: Pokemon, passive: boolean, party: Pokemon[], args: any[]): boolean {
+
+    let suppressed = false;
+    pokemon.scene.getField(true).filter(p => p !== pokemon).map(p => {
+      if (p.getAbility().hasAttr(SuppressFieldAbilitiesAbAttr) && p.canApplyAbility()) {
+        suppressed = true;
+      }
+      if (p.getPassiveAbility().hasAttr(SuppressFieldAbilitiesAbAttr) && p.canApplyAbility(true)) {
+        suppressed = true;
+      }
+    });
+
+    if (pokemon.illusion.available && !suppressed) {
+      return pokemon.generateIllusion(party);
+    } 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, attacker: Pokemon, move: Move, hitResult: HitResult, args: any[]): boolean | Promise<boolean> {
+
+    //[HitResult.EFFECTIVE, HitResult.SUPER_EFFECTIVE, HitResult.NOT_VERY_EFFECTIVE, HitResult.ONE_HIT_KO]
+    if (hitResult > 4) {
+      return false;
+    }
+    pokemon.breakIllusion();
+    pokemon.scene.queueMessage(i18next.t("abilityTriggers:illusionBreak", { pokemonName: getPokemonNameWithAffix(pokemon) }));
+    return true;
+  }
+}
+
+export class IllusionAfterBattle 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 {Pokemon[]} party - The party of the trainer's pokemon.
+   * @param {...any} args - N/A
+   * @returns {boolean} - Whether the illusion was applied.
+   */
+  applyPostBattle(pokemon: Pokemon, passive: boolean, party: Pokemon[], args: any[]): boolean {
+    pokemon.breakIllusion();
+    pokemon.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, args: any[]): boolean | Promise<boolean> {
+    pokemon.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).
  *
@@ -4070,6 +4172,11 @@ export function applyPostSummonAbAttrs(attrType: Constructor<PostSummonAbAttr>,
   return applyAbAttrsInternal<PostSummonAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPostSummon(pokemon, passive, args), args);
 }
 
+export function applyPreSummonAbAttrs(attrType: Constructor<PreSummonAbAttr>,
+  pokemon: Pokemon, party: Pokemon[], ...args: any[]): Promise<void> {
+  return applyAbAttrsInternal<PreSummonAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPreSummon(pokemon, passive, party, args), args);
+}
+
 export function applyPreSwitchOutAbAttrs(attrType: Constructor<PreSwitchOutAbAttr>,
   pokemon: Pokemon, ...args: any[]): Promise<void> {
   return applyAbAttrsInternal<PreSwitchOutAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPreSwitchOut(pokemon, passive, args), args, false, true);
@@ -4126,9 +4233,9 @@ export function applyCheckTrappedAbAttrs(attrType: Constructor<CheckTrappedAbAtt
   return applyAbAttrsInternal<CheckTrappedAbAttr>(attrType, pokemon, (attr, passive) => attr.applyCheckTrapped(pokemon, passive, trapped, otherPokemon, args), args, true);
 }
 
-export function applyPostBattleAbAttrs(attrType: Constructor<PostBattleAbAttr>,
-  pokemon: Pokemon, ...args: any[]): Promise<void> {
-  return applyAbAttrsInternal<PostBattleAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPostBattle(pokemon, passive, args), args);
+export function applyPostBattleAbAttrs(attrType: { new(...args: any[]): PostBattleAbAttr },
+  pokemon: Pokemon, party: Pokemon[], ...args: any[]): Promise<void> {
+  return applyAbAttrsInternal<PostBattleAbAttr>(attrType, pokemon, (attr, passive) => attr.applyPostBattle(pokemon, passive, party, args), args);
 }
 
 export function applyPostFaintAbAttrs(attrType: Constructor<PostFaintAbAttr>,
@@ -4617,7 +4724,15 @@ export function initAbilities() {
     new Ability(Abilities.ILLUSION, 5)
       .attr(UncopiableAbilityAbAttr)
       .attr(UnswappableAbilityAbAttr)
-      .unimplemented(),
+      //The pokemon genrate an illusion if it's available
+      .conditionalAttr((pokemon) => pokemon.illusion.available, IllusionPreSummonAbAttr, false)
+      //Illusion is not available after summon
+      .attr(IllusionDisableAbAttr, false)
+      //The pokemon loses his illusion when he is damaged by a move
+      .conditionalAttr((pokemon) => pokemon.illusion.active, IllusionBreakAbAttr, true)
+      //Illusion is available again after a battle
+      .conditionalAttr((pokemon) => pokemon.isAllowedInBattle(), IllusionAfterBattle, false)
+      .bypassFaint(),
     new Ability(Abilities.IMPOSTER, 5)
       .attr(PostSummonTransformAbAttr)
       .attr(UncopiableAbilityAbAttr),

src/data/move.ts

@@ -5225,7 +5225,9 @@ export class AbilityChangeAttr extends MoveEffectAttr {
     }
 
     (this.selfTarget ? user : target).summonData.ability = this.ability;
-
+    if ((this.selfTarget ? user : target).breakIllusion()) {
+      (this.selfTarget ? user : target).scene.queueMessage(i18next.t("abilityTriggers:illusionBreak", { pokemonName: getPokemonNameWithAffix((this.selfTarget ? user : target)) }));
+    }
     user.scene.queueMessage("The " + getPokemonMessage((this.selfTarget ? user : target), ` acquired\n${allAbilities[this.ability].name}!`));
 
     return true;
@@ -5379,7 +5381,8 @@ export class SuppressAbilitiesIfActedAttr extends MoveEffectAttr {
 export class TransformAttr extends MoveEffectAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): Promise<boolean> {
     return new Promise(resolve => {
-      if (!super.apply(user, target, move, args)) {
+      if (!super.apply(user, target, move, args) || target.illusion.active || user.illusion.active) {
+        user.scene.queueMessage(i18next.t("battle:attackFailed"));
         return resolve(false);
       }