Add more abilities and move contact flag

src/arena.ts

@@ -194,12 +194,13 @@ export class Arena {
   }
 
   isMoveWeatherCancelled(move: Move) {
-    return this.weather && this.weather.isMoveWeatherCancelled(move);
+    return this.weather && !this.weather.isEffectSuppressed(this.scene) && this.weather.isMoveWeatherCancelled(move);
   }
 
   getAttackTypeMultiplier(attackType: Type): number {
-    if (!this.weather)
+    if (!this.weather || this.weather.isEffectSuppressed(this.scene))
       return 1;
+
     return this.weather.getAttackTypeMultiplier(attackType);
   }
 

src/battle-phases.ts

@@ -25,7 +25,7 @@ import { Gender } from "./data/gender";
 import { Weather, WeatherType, getRandomWeatherType, getWeatherDamageMessage, getWeatherLapseMessage } from "./data/weather";
 import { TempBattleStat } from "./data/temp-battle-stat";
 import { ArenaTrapTag, TrickRoomTag } from "./data/arena-tag";
-import { ProtectStatAttr, applyPreStatChangeAbilityAttrs } from "./data/ability";
+import { PostWeatherLapseAbAttr, PreWeatherDamageAbAttr, ProtectStatAttr, SuppressWeatherEffectAbAttr, applyPostWeatherLapseAbAttrs, applyPreStatChangeAbAttrs, applyPreWeatherEffectAbAttrs } from "./data/ability";
 
 export class SelectStarterPhase extends BattlePhase {
   constructor(scene: BattleScene) {
@@ -456,7 +456,36 @@ export class SummonMissingPhase extends SummonPhase {
   }
 }
 
-export class CommandPhase extends BattlePhase {
+type PokemonFunc = (pokemon: Pokemon) => void;
+
+export abstract class FieldPhase extends BattlePhase {
+  isPlayerDelayed(): boolean {
+    const playerPokemon = this.scene.getPlayerPokemon();
+    const enemyPokemon = this.scene.getEnemyPokemon();
+
+    const playerSpeed = playerPokemon?.getBattleStat(Stat.SPD) || 0;
+    const enemySpeed = enemyPokemon?.getBattleStat(Stat.SPD) || 0;
+
+    const speedDelayed = new Utils.BooleanHolder(playerSpeed < enemySpeed);
+    this.scene.arena.applyTags(TrickRoomTag, speedDelayed);
+    
+    return speedDelayed.value || (playerSpeed === enemySpeed && Utils.randInt(2) === 1);
+  }
+
+  executeForBoth(func: PokemonFunc): void {
+    const playerPokemon = this.scene.getPlayerPokemon();
+    const enemyPokemon = this.scene.getEnemyPokemon();
+    const delayed = this.isPlayerDelayed();
+    if (!delayed && playerPokemon)
+      func(playerPokemon);
+    if (enemyPokemon)
+      func(enemyPokemon);
+    if (delayed && playerPokemon)
+      func(playerPokemon);
+  }
+}
+
+export class CommandPhase extends FieldPhase {
   constructor(scene: BattleScene) {
     super(scene)
   }
@@ -496,9 +525,6 @@ export class CommandPhase extends BattlePhase {
     const enemyPokemon = this.scene.getEnemyPokemon();
     let success: boolean;
 
-    const playerSpeed = playerPokemon.getBattleStat(Stat.SPD);
-    const enemySpeed = enemyPokemon.getBattleStat(Stat.SPD);
-
     let isDelayed = (command: Command, playerMove: PokemonMove, enemyMove: PokemonMove) => {
       switch (command) {
         case Command.FIGHT:
@@ -516,10 +542,7 @@ export class CommandPhase extends BattlePhase {
           return true;
       }
 
-      const speedDelayed = new Utils.BooleanHolder(playerSpeed < enemySpeed);
+      return this.isPlayerDelayed();
-      this.scene.arena.applyTags(TrickRoomTag, speedDelayed);
-      
-      return speedDelayed.value || (playerSpeed === enemySpeed && Utils.randInt(2) === 1);
     };
 
     let playerMove: PokemonMove;
@@ -573,7 +596,7 @@ export class CommandPhase extends BattlePhase {
 
     if (success) {
       if (this.scene.arena.weather)
-        this.scene.unshiftPhase(new WeatherEffectPhase(this.scene, this.scene.arena.weather, isDelayed(command, null, null)));
+        this.scene.unshiftPhase(new WeatherEffectPhase(this.scene, this.scene.arena.weather));
 
       const enemyMove = enemyPokemon.getNextMove();
       const enemyPhase = new EnemyMovePhase(this.scene, enemyPokemon, enemyMove);
@@ -608,7 +631,7 @@ export class CommandPhase extends BattlePhase {
   }
 }
 
-export class TurnEndPhase extends BattlePhase {
+export class TurnEndPhase extends FieldPhase {
   constructor(scene: BattleScene) {
     super(scene);
   }
@@ -618,9 +641,6 @@ export class TurnEndPhase extends BattlePhase {
 
     this.scene.currentBattle.incrementTurn();
     
-    const playerPokemon = this.scene.getPlayerPokemon();
-    const enemyPokemon = this.scene.getEnemyPokemon();
-    
     const handlePokemon = (pokemon: Pokemon) => {
       if (!pokemon || !pokemon.hp)
         return;
@@ -644,19 +664,7 @@ export class TurnEndPhase extends BattlePhase {
       pokemon.battleSummonData.turnCount++;
     };
 
-    const playerSpeed = playerPokemon?.getBattleStat(Stat.SPD) || 0;
+    this.executeForBoth(handlePokemon);
-    const enemySpeed = enemyPokemon?.getBattleStat(Stat.SPD) || 0;
-
-    const speedDelayed = new Utils.BooleanHolder(playerSpeed < enemySpeed);
-    this.scene.arena.applyTags(TrickRoomTag, speedDelayed);
-
-    const isDelayed = speedDelayed.value || (playerSpeed === enemySpeed && Utils.randInt(2) === 1);
-
-    if (!isDelayed)
-      handlePokemon(playerPokemon);
-    handlePokemon(enemyPokemon);
-    if (isDelayed)
-      handlePokemon(playerPokemon);
       
     this.scene.arena.lapseTags();
 
@@ -687,7 +695,7 @@ export class BattleEndPhase extends BattlePhase {
   }
 }
 
-export abstract class PokemonPhase extends BattlePhase {
+export abstract class PokemonPhase extends FieldPhase {
   protected player: boolean;
 
   constructor(scene: BattleScene, player: boolean) {
@@ -1079,6 +1087,18 @@ export class MoveAnimTestPhase extends BattlePhase {
   }
 }
 
+export class ShowAbilityPhase extends PokemonPhase {
+  constructor(scene: BattleScene, player: boolean) {
+    super(scene, player);
+  }
+
+  start() {
+    this.scene.abilityBar.showAbility(this.getPokemon());
+
+    this.end();
+  }
+}
+
 export class StatChangePhase extends PokemonPhase {
   private stats: BattleStat[];
   private selfTarget: boolean;
@@ -1088,6 +1108,7 @@ export class StatChangePhase extends PokemonPhase {
     super(scene, player);
 
     const allStats = Utils.getEnumValues(BattleStat);
+    this.selfTarget = selfTarget;
     this.stats = stats.map(s => s !== BattleStat.RAND ? s : allStats[Utils.randInt(BattleStat.SPD + 1)]);
     this.levels = levels;
   }
@@ -1099,7 +1120,7 @@ export class StatChangePhase extends PokemonPhase {
       const cancelled = new Utils.BooleanHolder(false);
 
       if (!this.selfTarget && this.levels < 0)
-        applyPreStatChangeAbilityAttrs(ProtectStatAttr, this.getPokemon(), stat, cancelled);
+        applyPreStatChangeAbAttrs(ProtectStatAttr, this.getPokemon(), stat, cancelled);
       
       return !cancelled.value;
     });
@@ -1170,37 +1191,46 @@ export class StatChangePhase extends PokemonPhase {
 
 export class WeatherEffectPhase extends CommonAnimPhase {
   private weather: Weather;
-  private playerDelayed: boolean;
 
-  constructor(scene: BattleScene, weather: Weather, playerDelayed: boolean) {
+  constructor(scene: BattleScene, weather: Weather) {
     super(scene, true, CommonAnim.SUNNY + (weather.weatherType - 1));
     this.weather = weather;
-    this.playerDelayed = playerDelayed;
   }
 
   start() {
     if (this.weather.isDamaging()) {
+      
+      const cancelled = new Utils.BooleanHolder(false);
+
+      this.executeForBoth((pokemon: Pokemon) => applyPreWeatherEffectAbAttrs(SuppressWeatherEffectAbAttr, pokemon, this.weather, cancelled));
+
+      if (!cancelled.value) {
         const inflictDamage = (pokemon: Pokemon) => {
+          const cancelled = new Utils.BooleanHolder(false);
+
+          applyPreWeatherEffectAbAttrs(PreWeatherDamageAbAttr, pokemon, this.weather, cancelled);
+
+          if (cancelled.value)
+            return;
+
           this.scene.queueMessage(getWeatherDamageMessage(this.weather.weatherType, pokemon));
           this.scene.unshiftPhase(new DamagePhase(this.scene, pokemon.isPlayer()));
           pokemon.damage(Math.ceil(pokemon.getMaxHp() / 16));
         };
 
-      const playerPokemon = this.scene.getPlayerPokemon();
+        this.executeForBoth((pokemon: Pokemon) => {
-      const enemyPokemon = this.scene.getEnemyPokemon();
+          const immune = !pokemon || !!pokemon.getTypes().filter(t => this.weather.isTypeDamageImmune(t)).length;
-
+          if (!immune)
-      const playerImmune = !playerPokemon || !!playerPokemon.getTypes().filter(t => this.weather.isTypeDamageImmune(t)).length;
+            inflictDamage(pokemon);
-      const enemyImmune = !enemyPokemon || !!enemyPokemon.getTypes().filter(t => this.weather.isTypeDamageImmune(t)).length;
+        });
-
+      }
-      if (!this.playerDelayed && !playerImmune)
-        inflictDamage(playerPokemon);
-      if (!enemyImmune)
-        inflictDamage(enemyPokemon);
-      if (this.playerDelayed && !playerImmune)
-        inflictDamage(playerPokemon);
     }
 
-    this.scene.ui.showText(getWeatherLapseMessage(this.weather.weatherType), null, () => super.start());
+    this.scene.ui.showText(getWeatherLapseMessage(this.weather.weatherType), null, () => {
+      this.executeForBoth((pokemon: Pokemon) => applyPostWeatherLapseAbAttrs(PostWeatherLapseAbAttr, pokemon, this.weather));
+
+      super.start();
+    });
   }
 }
 

src/battle-scene.ts

@@ -3,7 +3,7 @@ import { Biome } from './data/biome';
 import UI from './ui/ui';
 import { EncounterPhase, SummonPhase, CommandPhase, NextEncounterPhase, NewBiomeEncounterPhase, SelectBiomePhase, SelectStarterPhase, MessagePhase } from './battle-phases';
 import Pokemon, { PlayerPokemon, EnemyPokemon } from './pokemon';
-import PokemonSpecies, { allSpecies, getPokemonSpecies } from './data/pokemon-species';
+import PokemonSpecies, { allSpecies, getPokemonSpecies, initSpecies } from './data/pokemon-species';
 import * as Utils from './utils';
 import { Modifier, ModifierBar, ConsumablePokemonModifier, ConsumableModifier, PartyShareModifier, PokemonHpRestoreModifier, HealingBoosterModifier, PersistentModifier, PokemonHeldItemModifier, ModifierPredicate } from './modifier/modifier';
 import { PokeballType } from './data/pokeball';
@@ -17,9 +17,10 @@ import { Arena } from './arena';
 import { GameData } from './system/game-data';
 import StarterSelectUiHandler from './ui/starter-select-ui-handler';
 import { TextStyle, addTextObject } from './ui/text';
-import { Moves } from './data/move';
+import { Moves, initMoves } from './data/move';
 import { getDefaultModifierTypeForTier, getEnemyModifierTypesForWave } from './modifier/modifier-type';
 import AbilityBar from './ui/ability-bar';
+import { initAbilities } from './data/ability';
 
 const enableAuto = true;
 const quickStart = false;
@@ -58,6 +59,7 @@ export default class BattleScene extends Phaser.Scene {
 
 	private phaseQueue: BattlePhase[];
 	private phaseQueuePrepend: BattlePhase[];
+	private phaseQueuePrependSpliceIndex: integer;
 	private currentPhase: BattlePhase;
 	public field: Phaser.GameObjects.Container;
 	public fieldUI: Phaser.GameObjects.Container;
@@ -94,10 +96,15 @@ export default class BattleScene extends Phaser.Scene {
 	constructor() {
 		super('battle');
 
+		initSpecies();
+		initMoves();
+		initAbilities();
+
 		this.gameData = new GameData(this);
 		
 		this.phaseQueue = [];
 		this.phaseQueuePrepend = [];
+		this.phaseQueuePrependSpliceIndex = -1;
 	}
 
 	loadImage(key: string, folder: string, filename?: string) {
@@ -643,14 +650,27 @@ export default class BattleScene extends Phaser.Scene {
 	}
 
 	unshiftPhase(phase: BattlePhase): void {
+		if (this.phaseQueuePrependSpliceIndex === -1)
 			this.phaseQueuePrepend.push(phase);
+		else
+			this.phaseQueuePrepend.splice(this.phaseQueuePrependSpliceIndex, 0, phase);
 	}
 
 	clearPhaseQueue(): void {
 		this.phaseQueue.splice(0, this.phaseQueue.length);
 	}
 
+	setPhaseQueueSplice(): void {
+		this.phaseQueuePrependSpliceIndex = this.phaseQueuePrepend.length;
+	}
+
+	clearPhaseQueueSplice(): void {
+		this.phaseQueuePrependSpliceIndex = -1;
+	}
+
 	shiftPhase(): void {
+		if (this.phaseQueuePrependSpliceIndex > -1)
+			this.clearPhaseQueueSplice();
 		if (this.phaseQueuePrepend.length) {
 			while (this.phaseQueuePrepend.length)
 				this.phaseQueue.unshift(this.phaseQueuePrepend.pop());

src/data/ability.ts

@@ -2,15 +2,20 @@ import Pokemon, { PokemonMove } from "../pokemon";
 import { Type } from "./type";
 import * as Utils from "../utils";
 import { BattleStat, getBattleStatName } from "./battle-stat";
-import { StatChangePhase } from "../battle-phases";
+import { PokemonHealPhase, ShowAbilityPhase, StatChangePhase } from "../battle-phases";
 import { getPokemonMessage } from "../messages";
+import { Weather, WeatherType } from "./weather";
+import { BattlerTagType } from "./battler-tag";
+import { StatusEffect } from "./status-effect";
+import { Moves, RecoilAttr } from "./move";
 
 export class Ability {
   public id: Abilities;
   public name: string;
   public description: string;
   public generation: integer;
-  public attrs: AbilityAttr[];
+  public attrs: AbAttr[];
+  public conditions: AbAttrCondition[];
 
   constructor(id: Abilities, name: string, description: string, generation: integer) {
     this.id = id;
@@ -18,39 +23,70 @@ export class Ability {
     this.description = description;
     this.generation = generation;
     this.attrs = [];
+    this.conditions = [];
   }
 
-  getAttrs(attrType: { new(...args: any[]): AbilityAttr }): AbilityAttr[] {
+  getAttrs(attrType: { new(...args: any[]): AbAttr }): AbAttr[] {
     return this.attrs.filter(a => a instanceof attrType);
   }
 
-  attr<T extends new (...args: any[]) => AbilityAttr>(AttrType: T, ...args: ConstructorParameters<T>): Ability {
+  attr<T extends new (...args: any[]) => AbAttr>(AttrType: T, ...args: ConstructorParameters<T>): Ability {
     const attr = new AttrType(...args);
     this.attrs.push(attr);
 
     return this;
   }
+
+  condition(condition: AbAttrCondition): Ability {
+    this.conditions.push(condition);
+
+    return this;
+  }
 }
 
-export abstract class AbilityAttr {
+type AbAttrCondition = (pokemon: Pokemon) => boolean;
+
+export abstract class AbAttr {
+  apply(pokemon: Pokemon, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    return false;
+  }
+
   getTriggerMessage(pokemon: Pokemon, ...args: any[]) {
     return null;
   }
+
+  getCondition(): AbAttrCondition {
+    return null;
+  }
 }
 
-export class PreDefendAbilityAttr extends AbilityAttr {
+export class BlockRecoilDamageAttr extends AbAttr {
+  apply(pokemon: Pokemon, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    cancelled.value = true;
+
+    return true;
+  }
+
+  getTriggerMessage(pokemon: Pokemon, ...args: any[]) {
+    return getPokemonMessage(pokemon, `'s ${pokemon.getAbility().name}\nprotected it from recoil!`);
+  }
+}
+
+export class PreDefendAbAttr extends AbAttr {
   applyPreDefend(pokemon: Pokemon, attacker: Pokemon, move: PokemonMove, cancelled: Utils.BooleanHolder, args: any[]): boolean {
     return false;
   }
 }
 
-export class TypeImmunityAttr extends PreDefendAbilityAttr {
+export class TypeImmunityAbAttr extends PreDefendAbAttr {
   private immuneType: Type;
+  private condition: AbAttrCondition;
 
-  constructor(immuneType: Type) {
+  constructor(immuneType: Type, condition?: AbAttrCondition) {
     super();
 
     this.immuneType = immuneType;
+    this.condition = condition;
   }
 
   applyPreDefend(pokemon: Pokemon, attacker: Pokemon, move: PokemonMove, cancelled: Utils.BooleanHolder, args: any[]): boolean {
@@ -61,14 +97,18 @@ export class TypeImmunityAttr extends PreDefendAbilityAttr {
 
     return false;
   }
+
+  getCondition(): AbAttrCondition {
+    return this.condition;
+  }
 }
 
-class TypeImmunityStatChangeAttr extends TypeImmunityAttr {
+class TypeImmunityStatChangeAbAttr extends TypeImmunityAbAttr {
   private stat: BattleStat;
   private levels: integer;
 
-  constructor(immuneType: Type, stat: BattleStat, levels: integer) {
+  constructor(immuneType: Type, stat: BattleStat, levels: integer, condition?: AbAttrCondition) {
-    super(immuneType);
+    super(immuneType, condition);
 
     this.stat = stat;
     this.levels = levels;
@@ -86,13 +126,85 @@ class TypeImmunityStatChangeAttr extends TypeImmunityAttr {
   }
 }
 
-export class PreStatChangeAbilityAttr extends AbilityAttr {
+class TypeImmunityAddBattlerTagAbAttr extends TypeImmunityAbAttr {
+  private tagType: BattlerTagType;
+  private turnCount: integer;
+
+  constructor(immuneType: Type, tagType: BattlerTagType, turnCount: integer, condition?: AbAttrCondition) {
+    super(immuneType, condition);
+
+    this.tagType = tagType;
+    this.turnCount = turnCount;
+  }
+
+  applyPreDefend(pokemon: Pokemon, attacker: Pokemon, move: PokemonMove, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    const ret = super.applyPreDefend(pokemon, attacker, move, cancelled, args);
+
+    if (ret) {
+      cancelled.value = true;
+      pokemon.addTag(this.tagType, this.turnCount, undefined, pokemon.id);
+    }
+    
+    return ret;
+  }
+}
+
+export class PreAttackAbAttr extends AbAttr {
+  applyPreAttack(pokemon: Pokemon, defender: Pokemon, move: PokemonMove, args: any[]): boolean {
+    return false;
+  }
+}
+
+export class VariableMovePowerAbAttr extends PreAttackAbAttr {
+  applyPreAttack(pokemon: Pokemon, defender: Pokemon, move: PokemonMove, args: any[]): boolean {
+    //const power = args[0] as Utils.NumberHolder;
+    return false; 
+  }
+}
+
+export class LowHpMoveTypePowerBoostAbAttr extends VariableMovePowerAbAttr {
+  private boostedType: Type;
+
+  constructor(boostedType: Type) {
+    super();
+
+    this.boostedType = boostedType;
+  }
+
+  applyPreAttack(pokemon: Pokemon, defender: Pokemon, move: PokemonMove, args: any[]): boolean {
+    if (move.getMove().type === this.boostedType) {
+      (args[0] as Utils.NumberHolder).value *= 1.5;
+
+      return true;
+    }
+
+    return false;
+  }
+
+  getCondition(): AbAttrCondition {
+    return (pokemon) => pokemon.getHpRatio() <= 0.33;
+  }
+}
+
+export class RecoilMovePowerBoostAbAttr extends VariableMovePowerAbAttr {
+  applyPreAttack(pokemon: Pokemon, defender: Pokemon, move: PokemonMove, args: any[]): boolean {
+    if (move.getMove().getAttrs(RecoilAttr).length && move.moveId !== Moves.STRUGGLE) {
+      (args[0] as Utils.NumberHolder).value *= 1.2;
+
+      return true;
+    }
+
+    return false;
+  }
+}
+
+export class PreStatChangeAbAttr extends AbAttr {
   applyPreStatChange(pokemon: Pokemon, stat: BattleStat, cancelled: Utils.BooleanHolder, args: any[]): boolean {
     return false;
   }
 }
 
-export class ProtectStatAttr extends PreStatChangeAbilityAttr {
+export class ProtectStatAttr extends PreStatChangeAbAttr {
   private protectedStat: BattleStat;
 
   constructor(protectedStat?: BattleStat) {
@@ -115,32 +227,213 @@ export class ProtectStatAttr extends PreStatChangeAbilityAttr {
   }
 }
 
-export function applyPreDefendAbilityAttrs(attrType: { new(...args: any[]): PreDefendAbilityAttr },
+export class PreWeatherEffectAbAttr extends AbAttr {
-  pokemon: Pokemon, attacker: Pokemon, move: PokemonMove, cancelled: Utils.BooleanHolder, ...args: any[]): void {
+  applyPreWeatherEffect(pokemon: Pokemon, weather: Weather, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    return false;
+  }
+}
+
+export class PreWeatherDamageAbAttr extends PreWeatherEffectAbAttr { }
+
+export class BlockWeatherDamageAttr extends PreWeatherDamageAbAttr {
+  applyPreWeatherEffect(pokemon: Pokemon, weather: Weather, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    cancelled.value = true;
+
+    return true;
+  }
+}
+
+export class SuppressWeatherEffectAbAttr extends PreWeatherEffectAbAttr {
+  private affectsImmutable: boolean;
+
+  constructor(affectsImmutable?: boolean) {
+    super();
+
+    this.affectsImmutable = affectsImmutable;
+  }
+
+  applyPreWeatherEffect(pokemon: Pokemon, weather: Weather, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    if (this.affectsImmutable || weather.isImmutable()) {
+      cancelled.value = true;
+      return true;
+    }
+
+    return false;
+  }
+}
+
+export class PostWeatherLapseAbAttr extends AbAttr {
+  applyPostWeatherLapse(pokemon: Pokemon, weather: Weather, args: any[]): boolean {
+    return false;
+  }
+}
+
+export class WeatherHealAbAttr extends PostWeatherLapseAbAttr {
+  private weatherTypes: WeatherType[];
+
+  constructor(...weatherTypes: WeatherType[]) {
+    super();
+
+    this.weatherTypes = weatherTypes;
+  }
+
+  applyPostWeatherLapse(pokemon: Pokemon, weather: Weather, args: any[]): boolean {
+    if (this.weatherTypes.indexOf(weather.weatherType) > -1 && pokemon.getHpRatio() < 1) {
+      const scene = pokemon.scene;
+      scene.unshiftPhase(new PokemonHealPhase(scene, pokemon.isPlayer(), Math.max(Math.floor(pokemon.getMaxHp() / 16), 1), getPokemonMessage(pokemon, `'s ${pokemon.getAbility().name}\nrestored its HP a little!`), true));
+      return true;
+    }
+
+    return false;
+  }
+}
+
+export function applyAbAttrs(attrType: { new(...args: any[]): AbAttr }, pokemon: Pokemon, cancelled: Utils.BooleanHolder, ...args: any[]): void {
+  if (!pokemon.canApplyAbility())
+    return;
+
   const ability = pokemon.getAbility();
-  const attrs = ability.getAttrs(attrType) as PreDefendAbilityAttr[];
+  const attrs = ability.getAttrs(attrType) as AbAttr[];
+  console.log(attrs, ability);
   for (let attr of attrs) {
+    if (!canApplyAttr(pokemon, attr))
+      continue;
+    pokemon.scene.setPhaseQueueSplice();
+    if (attr.apply(pokemon, cancelled, args)) {
+      queueShowAbility(pokemon);
+      const message = attr.getTriggerMessage(pokemon);
+      if (message)
+        pokemon.scene.queueMessage(message);
+    }
+  }
+
+  pokemon.scene.clearPhaseQueueSplice();
+}
+
+export function applyPreDefendAbAttrs(attrType: { new(...args: any[]): PreDefendAbAttr },
+  pokemon: Pokemon, attacker: Pokemon, move: PokemonMove, cancelled: Utils.BooleanHolder, ...args: any[]): void {
+  if (!pokemon.canApplyAbility())
+    return;
+
+  const ability = pokemon.getAbility();
+  const attrs = ability.getAttrs(attrType) as PreDefendAbAttr[];
+  for (let attr of attrs) {
+    if (!canApplyAttr(pokemon, attr))
+      continue;
+    pokemon.scene.setPhaseQueueSplice();
     if (attr.applyPreDefend(pokemon, attacker, move, cancelled, args)) {
-      pokemon.scene.abilityBar.showAbility(pokemon);
+      queueShowAbility(pokemon);
       const message = attr.getTriggerMessage(pokemon, attacker, move);
       if (message)
         pokemon.scene.queueMessage(message);
     }
   }
+
+  pokemon.scene.clearPhaseQueueSplice();
 }
 
-export function applyPreStatChangeAbilityAttrs(attrType: { new(...args: any[]): PreStatChangeAbilityAttr },
+export function applyPreAttackAbAttrs(attrType: { new(...args: any[]): PreAttackAbAttr },
-  pokemon: Pokemon, stat: BattleStat, cancelled: Utils.BooleanHolder, ...args: any[]) {
+  pokemon: Pokemon, defender: Pokemon, move: PokemonMove, ...args: any[]): void {
+  if (!pokemon.canApplyAbility())
+    return;
+
   const ability = pokemon.getAbility();
-    const attrs = ability.getAttrs(attrType) as PreStatChangeAbilityAttr[];
+  const attrs = ability.getAttrs(attrType) as PreAttackAbAttr[];
   for (let attr of attrs) {
+    if (!canApplyAttr(pokemon, attr))
+      continue;
+    pokemon.scene.setPhaseQueueSplice();
+    if (attr.applyPreAttack(pokemon, defender, move, args)) {
+      queueShowAbility(pokemon);
+      const message = attr.getTriggerMessage(pokemon, defender, move);
+      if (message)
+        pokemon.scene.queueMessage(message);
+    }
+  }
+
+  pokemon.scene.clearPhaseQueueSplice();
+}
+
+export function applyPreStatChangeAbAttrs(attrType: { new(...args: any[]): PreStatChangeAbAttr },
+  pokemon: Pokemon, stat: BattleStat, cancelled: Utils.BooleanHolder, ...args: any[]): void {
+  if (!pokemon.canApplyAbility())
+    return;
+
+  const ability = pokemon.getAbility();
+  const attrs = ability.getAttrs(attrType) as PreStatChangeAbAttr[];
+  for (let attr of attrs) {
+    if (!canApplyAttr(pokemon, attr))
+      continue;
+    pokemon.scene.setPhaseQueueSplice();
     if (attr.applyPreStatChange(pokemon, stat, cancelled, args)) {
-        pokemon.scene.abilityBar.showAbility(pokemon);
+      queueShowAbility(pokemon);
       const message = attr.getTriggerMessage(pokemon, stat);
       if (message)
         pokemon.scene.queueMessage(message);
     }
   }
+
+  pokemon.scene.clearPhaseQueueSplice();
+}
+
+export function applyPreWeatherEffectAbAttrs(attrType: { new(...args: any[]): PreWeatherEffectAbAttr },
+  pokemon: Pokemon, weather: Weather, cancelled: Utils.BooleanHolder, silent?: boolean, ...args: any[]): void {
+  if (!pokemon.canApplyAbility())
+    return;
+
+  const ability = pokemon.getAbility();
+  const attrs = ability.getAttrs(attrType) as PreWeatherEffectAbAttr[];
+  for (let attr of attrs) {
+    if (!canApplyAttr(pokemon, attr))
+      continue;
+    pokemon.scene.setPhaseQueueSplice();
+    if (attr.applyPreWeatherEffect(pokemon, weather, cancelled, args)) {
+      if (!silent) {
+        pokemon.scene.abilityBar.showAbility(pokemon);
+        const message = attr.getTriggerMessage(pokemon, weather);
+        if (message)
+          pokemon.scene.queueMessage(message);
+      }
+    }
+  }
+
+  pokemon.scene.clearPhaseQueueSplice();
+}
+
+export function applyPostWeatherLapseAbAttrs(attrType: { new(...args: any[]): PostWeatherLapseAbAttr },
+  pokemon: Pokemon, weather: Weather, ...args: any[]): void {
+  if (!pokemon.canApplyAbility())
+    return;
+
+  if (weather.isEffectSuppressed(pokemon.scene))
+    return;
+
+  const ability = pokemon.getAbility();
+
+  const attrs = ability.getAttrs(attrType) as PostWeatherLapseAbAttr[];
+  for (let attr of attrs) {
+    if (!canApplyAttr(pokemon, attr))
+      continue;
+    pokemon.scene.setPhaseQueueSplice();
+    if (attr.applyPostWeatherLapse(pokemon, weather, args)) {
+      queueShowAbility(pokemon);
+      const message = attr.getTriggerMessage(pokemon, weather);
+      if (message)
+        pokemon.scene.queueMessage(message);
+    }
+  }
+
+  pokemon.scene.clearPhaseQueueSplice();
+}
+
+function canApplyAttr(pokemon: Pokemon, attr: AbAttr): boolean {
+  const condition = attr.getCondition();
+  return !condition || condition(pokemon);
+}
+
+function queueShowAbility(pokemon: Pokemon): void {
+  pokemon.scene.unshiftPhase(new ShowAbilityPhase(pokemon.scene, pokemon.isPlayer()));
+  pokemon.scene.clearPhaseQueueSplice();
 }
 
 export enum Abilities {
@@ -317,16 +610,21 @@ export enum Abilities {
   NEUTRALIZING_GAS
 }
 
-export const abilities = [
+export const abilities = [ new Ability(Abilities.NONE, "-", "", 3) ];
-  new Ability(Abilities.NONE, "- (N)", "", 3),
+
-  new Ability(Abilities.AIR_LOCK, "Air Lock (N)", "Eliminates the effects of weather.", 3),
+export function initAbilities() {
+  abilities.push(
+    new Ability(Abilities.AIR_LOCK, "Air Lock", "Eliminates the effects of all weather.", 3)
+      .attr(SuppressWeatherEffectAbAttr, true),
     new Ability(Abilities.ARENA_TRAP, "Arena Trap (N)", "Prevents the foe from fleeing.", 3),
     new Ability(Abilities.BATTLE_ARMOR, "Battle Armor (N)", "The POKéMON is protected against critical hits.", 3),
-  new Ability(Abilities.BLAZE, "Blaze (N)", "Powers up FIRE-type moves in a pinch.", 3),
+    new Ability(Abilities.BLAZE, "Blaze", "Powers up FIRE-type moves in a pinch.", 3)
+      .attr(LowHpMoveTypePowerBoostAbAttr, Type.FIRE),
     new Ability(Abilities.CHLOROPHYLL, "Chlorophyll (N)", "Boosts the POKéMON's SPEED in sunshine.", 3),
     new Ability(Abilities.CLEAR_BODY, "Clear Body", "Prevents other POKéMON from lowering its stats.", 3)
       .attr(ProtectStatAttr),
-  new Ability(Abilities.CLOUD_NINE, "Cloud Nine (N)", "Eliminates the effects of weather.", 3),
+    new Ability(Abilities.CLOUD_NINE, "Cloud Nine", "Eliminates the effects of non-severe weather.", 3)
+      .attr(SuppressWeatherEffectAbAttr),
     new Ability(Abilities.COLOR_CHANGE, "Color Change (N)", "Changes the POKéMON's type to the foe's move.", 3),
     new Ability(Abilities.COMPOUND_EYES, "Compound Eyes (N)", "The POKéMON's accuracy is boosted.", 3),
     new Ability(Abilities.CUTE_CHARM, "Cute Charm (N)", "Contact with the POKéMON may cause infatuation.", 3),
@@ -336,7 +634,8 @@ export const abilities = [
     new Ability(Abilities.EARLY_BIRD, "Early Bird (N)", "The POKéMON awakens quickly from sleep.", 3),
     new Ability(Abilities.EFFECT_SPORE, "Effect Spore (N)", "Contact may poison or cause paralysis or sleep.", 3),
     new Ability(Abilities.FLAME_BODY, "Flame Body (N)", "Contact with the POKéMON may burn the attacker.", 3),
-  new Ability(Abilities.FLASH_FIRE, "Flash Fire (N)", "It powers up FIRE-type moves if it's hit by one.", 3),
+    new Ability(Abilities.FLASH_FIRE, "Flash Fire", "It powers up FIRE-type moves if it's hit by one.", 3)
+      .attr(TypeImmunityAddBattlerTagAbAttr, Type.FIRE, 1, BattlerTagType.FIRE_BOOST, (pokemon: Pokemon) => !pokemon.status || pokemon.status.effect !== StatusEffect.FREEZE),
     new Ability(Abilities.FORECAST, "Forecast (N)", "Castform transforms with the weather.", 3),
     new Ability(Abilities.GUTS, "Guts (N)", "Boosts ATTACK if there is a status problem.", 3),
     new Ability(Abilities.HUGE_POWER, "Huge Power (N)", "Raises the POKéMON's ATTACK stat.", 3),
@@ -351,9 +650,9 @@ export const abilities = [
     new Ability(Abilities.KEEN_EYE, "Keen Eye", "Prevents other POKéMON from lowering accuracy.", 3)
       .attr(ProtectStatAttr, BattleStat.ACC),
     new Ability(Abilities.LEVITATE, "Levitate", "Gives immunity to GROUND-type moves.", 3)
-    .attr(TypeImmunityAttr, Type.FLYING),
+      .attr(TypeImmunityAbAttr, Type.FLYING, (pokemon: Pokemon) => !pokemon.getTag(BattlerTagType.IGNORE_FLYING)),
     new Ability(Abilities.LIGHTNING_ROD, "Lightning Rod", "Draws in all ELECTRIC-type moves to up SP. ATK.", 3)
-    .attr(TypeImmunityStatChangeAttr, Type.ELECTRIC, BattleStat.SPATK, 1),
+      .attr(TypeImmunityStatChangeAbAttr, Type.ELECTRIC, BattleStat.SPATK, 1),
     new Ability(Abilities.LIMBER, "Limber (N)", "The POKéMON is protected from paralysis.", 3),
     new Ability(Abilities.LIQUID_OOZE, "Liquid Ooze (N)", "Damages attackers using any draining move.", 3),
     new Ability(Abilities.MAGMA_ARMOR, "Magma Armor (N)", "Prevents the POKéMON from becoming frozen.", 3),
@@ -362,15 +661,18 @@ export const abilities = [
     new Ability(Abilities.MINUS, "Minus (N)", "Ups SP. ATK if another POKéMON has PLUS or MINUS.", 3),
     new Ability(Abilities.NATURAL_CURE, "Natural Cure (N)", "All status problems heal when it switches out.", 3),
     new Ability(Abilities.OBLIVIOUS, "Oblivious (N)", "Prevents it from becoming infatuated.", 3),
-  new Ability(Abilities.OVERGROW, "Overgrow (N)", "Powers up GRASS-type moves in a pinch.", 3),
+    new Ability(Abilities.OVERGROW, "Overgrow", "Powers up GRASS-type moves in a pinch.", 3)
+      .attr(LowHpMoveTypePowerBoostAbAttr, Type.GRASS),
     new Ability(Abilities.OWN_TEMPO, "Own Tempo (N)", "Prevents the POKéMON from becoming confused.", 3),
     new Ability(Abilities.PICKUP, "Pickup (N)", "The POKéMON may pick up items.", 3),
     new Ability(Abilities.PLUS, "Plus (N)", "Ups SP. ATK if another POKéMON has PLUS or MINUS.", 3),
     new Ability(Abilities.POISON_POINT, "Poison Point (N)", "Contact with the POKéMON may poison the attacker.", 3),
     new Ability(Abilities.PRESSURE, "Pressure (N)", "The POKéMON raises the foe's PP usage.", 3),
     new Ability(Abilities.PURE_POWER, "Pure Power (N)", "Raises the POKéMON's ATTACK stat.", 3),
-  new Ability(Abilities.RAIN_DISH, "Rain Dish (N)", "The POKéMON gradually regains HP in rain.", 3),
+    new Ability(Abilities.RAIN_DISH, "Rain Dish", "The POKéMON gradually regains HP in rain.", 3)
-  new Ability(Abilities.ROCK_HEAD, "Rock Head (N)", "Protects the POKéMON from recoil damage.", 3),
+      .attr(WeatherHealAbAttr, WeatherType.RAIN, WeatherType.HEAVY_RAIN),
+    new Ability(Abilities.ROCK_HEAD, "Rock Head", "Protects the POKéMON from recoil damage.", 3)
+      .attr(BlockRecoilDamageAttr),
     new Ability(Abilities.ROUGH_SKIN, "Rough Skin (N)", "Inflicts damage to the attacker on contact.", 3),
     new Ability(Abilities.RUN_AWAY, "Run Away (N)", "Enables a sure getaway from wild POKéMON.", 3),
     new Ability(Abilities.SAND_STREAM, "Sand Stream (N)", "The POKéMON summons a sandstorm in battle.", 3),
@@ -387,11 +689,13 @@ export const abilities = [
     new Ability(Abilities.STICKY_HOLD, "Sticky Hold (N)", "Protects the POKéMON from item theft.", 3),
     new Ability(Abilities.STURDY, "Sturdy (N)", "It cannot be knocked out with one hit.", 3),
     new Ability(Abilities.SUCTION_CUPS, "Suction Cups (N)", "Negates all moves that force switching out.", 3),
-  new Ability(Abilities.SWARM, "Swarm (N)", "Powers up BUG-type moves in a pinch.", 3),
+    new Ability(Abilities.SWARM, "Swarm", "Powers up BUG-type moves in a pinch.", 3)
+      .attr(LowHpMoveTypePowerBoostAbAttr, Type.BUG),
     new Ability(Abilities.SWIFT_SWIM, "Swift Swim (N)", "Boosts the POKéMON's SPEED in rain.", 3),
     new Ability(Abilities.SYNCHRONIZE, "Synchronize (N)", "Passes a burn, poison, or paralysis to the foe.", 3),
     new Ability(Abilities.THICK_FAT, "Thick Fat (N)", "Ups resistance to Fire- and ICE-type moves.", 3),
-  new Ability(Abilities.TORRENT, "Torrent (N)", "Powers up WATER-type moves in a pinch.", 3),
+    new Ability(Abilities.TORRENT, "Torrent", "Powers up WATER-type moves in a pinch.", 3)
+      .attr(LowHpMoveTypePowerBoostAbAttr, Type.WATER),
     new Ability(Abilities.TRACE, "Trace (N)", "The POKéMON copies a foe's Ability.", 3),
     new Ability(Abilities.TRUANT, "Truant (N)", "POKéMON can't attack on consecutive turns.", 3),
     new Ability(Abilities.VITAL_SPIRIT, "Vital Spirit (N)", "Prevents the POKéMON from falling asleep.", 3),
@@ -416,7 +720,8 @@ export const abilities = [
     new Ability(Abilities.HEATPROOF, "Heatproof (N)", "Weakens the power of FIRE-type moves.", 4),
     new Ability(Abilities.HONEY_GATHER, "Honey Gather (N)", "The POKéMON may gather Honey from somewhere.", 4),
     new Ability(Abilities.HYDRATION, "Hydration (N)", "Heals status problems if it is raining.", 4),
-  new Ability(Abilities.ICE_BODY, "Ice Body (N)", "The POKéMON gradually regains HP in a hailstorm.", 4),
+    new Ability(Abilities.ICE_BODY, "Ice Body", "The POKéMON gradually regains HP in a hailstorm.", 4)
+      .attr(WeatherHealAbAttr, WeatherType.HAIL),
     new Ability(Abilities.IRON_FIST, "Iron Fist (N)", "Boosts the power of punching moves.", 4),
     new Ability(Abilities.KLUTZ, "Klutz (N)", "The POKéMON can't use any held items.", 4),
     new Ability(Abilities.LEAF_GUARD, "Leaf Guard (N)", "Prevents problems with status in sunny weather.", 4),
@@ -428,7 +733,8 @@ export const abilities = [
     new Ability(Abilities.NORMALIZE, "Normalize (N)", "All the POKéMON's moves become the NORMAL type.", 4),
     new Ability(Abilities.POISON_HEAL, "Poison Heal (N)", "Restores HP if the POKéMON is poisoned.", 4),
     new Ability(Abilities.QUICK_FEET, "Quick Feet (N)", "Boosts SPEED if there is a status problem.", 4),
-  new Ability(Abilities.RECKLESS, "Reckless (N)", "Powers up moves that have recoil damage.", 4),
+    new Ability(Abilities.RECKLESS, "Reckless", "Powers up moves that have recoil damage.", 4)
+      .attr(RecoilMovePowerBoostAbAttr),
     new Ability(Abilities.RIVALRY, "Rivalry (N)", "Deals more damage to a POKéMON of same gender.", 4),
     new Ability(Abilities.SCRAPPY, "Scrappy (N)", "Enables moves to hit GHOST-type POKéMON.", 4),
     new Ability(Abilities.SIMPLE, "Simple (N)", "Doubles all stat changes.", 4),
@@ -442,7 +748,7 @@ export const abilities = [
     new Ability(Abilities.STALL, "Stall (N)", "The POKéMON moves after all other POKéMON do.", 4),
     new Ability(Abilities.STEADFAST, "Steadfast (N)", "Raises SPEED each time the POKéMON flinches.", 4),
     new Ability(Abilities.STORM_DRAIN, "Storm Drain", "Draws in all WATER-type moves to up SP. ATK.", 4)
-    .attr(TypeImmunityStatChangeAttr, Type.WATER, BattleStat.SPATK, 1),
+      .attr(TypeImmunityStatChangeAbAttr, Type.WATER, BattleStat.SPATK, 1),
     new Ability(Abilities.SUPER_LUCK, "Super Luck (N)", "Heightens the critical-hit ratios of moves.", 4),
     new Ability(Abilities.TANGLED_FEET, "Tangled Feet (N)", "Raises evasion if the POKéMON is confused.", 4),
     new Ability(Abilities.TECHNICIAN, "Technician (N)", "Powers up the POKéMON's weaker moves.", 4),
@@ -472,8 +778,9 @@ export const abilities = [
     new Ability(Abilities.MOXIE, "Moxie (N)", "Boosts ATTACK after knocking out any POKéMON.", 5),
     new Ability(Abilities.MULTISCALE, "Multiscale (N)", "Reduces damage when HP is full.", 5),
     new Ability(Abilities.MUMMY, "Mummy (N)", "Contact with this POKéMON spreads this Ability.", 5),
-  new Ability(Abilities.OVERCOAT, "Overcoat (N)", "Protects the POKéMON from weather damage.", 5),
+    new Ability(Abilities.OVERCOAT, "Overcoat", "Protects the POKéMON from weather damage.", 5)
-  new Ability(Abilities.PICKPOCKET, "Pickpocket (N)", "Steals an item when hit by another POKéMON.", 5),
+      .attr(BlockWeatherDamageAttr),
+    new Ability(Abilities.PICKPOCKET, "Pickpocket (N)", "Once per battle, steals an item when hit by another POKéMON.", 5),
     new Ability(Abilities.POISON_TOUCH, "Poison Touch (N)", "May poison targets when a POKéMON makes contact.", 5),
     new Ability(Abilities.PRANKSTER, "Prankster (N)", "Gives priority to a status move.", 5),
     new Ability(Abilities.RATTLED, "Rattled (N)", "BUG, GHOST or DARK type moves scare it and boost its SPEED.", 5),
@@ -497,4 +804,5 @@ export const abilities = [
     new Ability(Abilities.PROTEAN, "Protean (N)", "Changes the POKéMON's type to its last used move.", 6),
     new Ability(Abilities.SLUSH_RUSH, "Slush Rush (N)", "Boosts the POKéMON's SPEED stat in a hailstorm.", 7),
     new Ability(Abilities.NEUTRALIZING_GAS, "Neutralizing Gas (N)", "Neutralizes abilities of all POKéMON in battle.", 8)
-];
+  );
+}

src/data/battler-tag.ts

@@ -31,6 +31,7 @@ export enum BattlerTagType {
   FLYING,
   UNDERGROUND,
   HIDDEN,
+  FIRE_BOOST,
   CRIT_BOOST,
   NO_CRIT,
   BYPASS_SLEEP,
@@ -464,6 +465,20 @@ export class HideSpriteTag extends BattlerTag {
   }
 }
 
+export class TypeBoostTag extends BattlerTag {
+  public boostedType: Type;
+
+  constructor(tagType: BattlerTagType, sourceMove: Moves, boostedType: Type) {
+    super(tagType, BattlerTagLapseType.TURN_END, 1, sourceMove);
+
+    this.boostedType = boostedType;
+  }
+
+  lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {
+    return lapseType !== BattlerTagLapseType.CUSTOM || super.lapse(pokemon, lapseType);
+  }
+}
+
 export class CritBoostTag extends BattlerTag {
   constructor(tagType: BattlerTagType, sourceMove: Moves) {
     super(tagType, BattlerTagLapseType.TURN_END, 1, sourceMove);
@@ -526,6 +541,8 @@ export function getBattlerTag(tagType: BattlerTagType, turnCount: integer, sourc
     case BattlerTagType.UNDERGROUND:
     case BattlerTagType.HIDDEN:
       return new HideSpriteTag(tagType, turnCount, sourceMove);
+    case BattlerTagType.FIRE_BOOST:
+      return new TypeBoostTag(tagType, sourceMove, Type.FIRE);
     case BattlerTagType.CRIT_BOOST:
       return new CritBoostTag(tagType, sourceMove);
     case BattlerTagType.NO_CRIT:

src/data/move.ts

@@ -9,6 +9,7 @@ import { Type } from "./type";
 import * as Utils from "../utils";
 import { WeatherType } from "./weather";
 import { ArenaTagType, ArenaTrapTag } from "./arena-tag";
+import { BlockRecoilDamageAttr, applyAbAttrs } from "./ability";
 
 export enum MoveCategory {
   PHYSICAL,
@@ -17,7 +18,8 @@ export enum MoveCategory {
 }
 
 export enum MoveFlags {
-  IGNORE_PROTECT = 1
+  MAKES_CONTACT = 1,
+  IGNORE_PROTECT = 2
 }
 
 type MoveCondition = (user: Pokemon, target: Pokemon, move: Move) => boolean;
@@ -37,8 +39,8 @@ export default class Move {
   public priority: integer;
   public generation: integer;
   public attrs: MoveAttr[];
-  private flags: integer;
   private conditions: MoveCondition[];
+  private flags: integer;
 
   constructor(id: Moves, name: string, type: Type, category: MoveCategory, selfTarget: boolean, power: integer, accuracy: integer, pp: integer, tm: integer, effect: string, chance: integer, priority: integer, generation: integer) {
     this.id = id;
@@ -56,8 +58,13 @@ export default class Move {
     this.generation = generation;
 
     this.attrs = [];
-    this.flags = (this.selfTarget ? MoveFlags.IGNORE_PROTECT : 0);
     this.conditions = [];
+
+    this.flags = 0;
+    if (selfTarget)
+      this.setFlag(MoveFlags.IGNORE_PROTECT, true);
+    if (category === MoveCategory.PHYSICAL)
+      this.setFlag(MoveFlags.MAKES_CONTACT, true);
   }
 
   getAttrs(attrType: { new(...args: any[]): MoveAttr }): MoveAttr[] {
@@ -93,11 +100,20 @@ export default class Move {
     return this;
   }
 
-  ignoreProtect(ignoreProtect?: boolean): Move {
+  private setFlag(flag: MoveFlags, on: boolean): void {
-    if (ignoreProtect)
+    if (on)
-      this.flags |= MoveFlags.IGNORE_PROTECT;
+      this.flags |= flag;
     else
-      this.flags ^= MoveFlags.IGNORE_PROTECT;
+      this.flags ^= flag;
+  }
+
+  makesContact(makesContact?: boolean): Move {
+    this.setFlag(MoveFlags.MAKES_CONTACT, makesContact);
+    return this;
+  }
+
+  ignoresProtect(ignoresProtect?: boolean): Move {
+    this.setFlag(MoveFlags.IGNORE_PROTECT, ignoresProtect);
     return this;
   }
 
@@ -782,15 +798,26 @@ export class TargetHalfHpDamageAttr extends FixedDamageAttr {
 }
 
 export class RecoilAttr extends MoveEffectAttr {
-  constructor() {
+  private useHp: boolean;
+
+  constructor(useHp?: boolean) {
     super(true);
+
+    this.useHp = useHp;
   }
 
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
     if (!super.apply(user, target, move, args))
       return false;
 
-    const recoilDamage = Math.max(Math.floor(user.turnData.damageDealt / 4), 1);
+    const cancelled = new Utils.BooleanHolder(false);
+    applyAbAttrs(BlockRecoilDamageAttr, user, cancelled);
+    console.log('test?');
+
+    if (cancelled.value)
+      return false;
+
+    const recoilDamage = Math.max(Math.floor((!this.useHp ? user.turnData.damageDealt : user.getMaxHp()) / 4), 1);
     user.scene.unshiftPhase(new DamagePhase(user.scene, user.isPlayer(), MoveResult.OTHER));
     user.scene.queueMessage(getPokemonMessage(user, ' is hit\nwith recoil!'));
     user.damage(recoilDamage);
@@ -849,6 +876,7 @@ export class WeatherHealAttr extends HealAttr {
 
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
     let healRatio = 0.5;
+    if (!user.scene.arena.weather?.isEffectSuppressed(user.scene)) {
       const weatherType = user.scene.arena.weather?.weatherType || WeatherType.NONE;
       switch (weatherType) {
         case WeatherType.SUNNY:
@@ -862,6 +890,7 @@ export class WeatherHealAttr extends HealAttr {
           healRatio = 0.25;
           break;
       }
+    }
     this.addHealPhase(user, healRatio);
     return true;
   }
@@ -1068,7 +1097,7 @@ export class SolarBeamChargeAttr extends ChargeAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): Promise<boolean> {
     return new Promise(resolve => {
       const weatherType = user.scene.arena.weather?.weatherType;
-      if (weatherType === WeatherType.SUNNY || weatherType === WeatherType.HARSH_SUN)
+      if (!user.scene.arena.weather?.isEffectSuppressed(user.scene) && (weatherType === WeatherType.SUNNY || weatherType === WeatherType.HARSH_SUN))
         resolve(false);
       else
         super.apply(user, target, move, args).then(result => resolve(result));
@@ -1112,9 +1141,11 @@ export class GrowthStatChangeAttr extends StatChangeAttr {
   }
 
   getLevels(user: Pokemon): number {
+    if (!user.scene.arena.weather?.isEffectSuppressed(user.scene)) {
       const weatherType = user.scene.arena.weather?.weatherType;
       if (weatherType === WeatherType.SUNNY || weatherType === WeatherType.HARSH_SUN)
         return this.levels + 1;
+    }
     return this.levels;
   }
 }
@@ -1266,6 +1297,7 @@ export class TurnDamagedDoublePowerAttr extends VariablePowerAttr {
 
 export class SolarBeamPowerAttr extends VariablePowerAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
+    if (!user.scene.arena.weather?.isEffectSuppressed(user.scene)) {
       const power = args[0] as Utils.NumberHolder;
       const weatherType = user.scene.arena.weather?.weatherType || WeatherType.NONE;
       switch (weatherType) {
@@ -1276,6 +1308,7 @@ export class SolarBeamPowerAttr extends VariablePowerAttr {
           power.value *= 0.5;
           return true;
       }
+    }
 
     return false;
   }
@@ -1290,6 +1323,7 @@ export class VariableAccuracyAttr extends MoveAttr {
 
 export class ThunderAccuracyAttr extends VariableAccuracyAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
+    if (!user.scene.arena.weather?.isEffectSuppressed(user.scene)) {
       const accuracy = args[0] as Utils.NumberHolder;
       const weatherType = user.scene.arena.weather?.weatherType || WeatherType.NONE;
       switch (weatherType) {
@@ -1303,6 +1337,7 @@ export class ThunderAccuracyAttr extends VariableAccuracyAttr {
           accuracy.value = -1;
           return true;
       }
+    }
 
     return false;
   }
@@ -1310,12 +1345,14 @@ export class ThunderAccuracyAttr extends VariableAccuracyAttr {
 
 export class BlizzardAccuracyAttr extends VariableAccuracyAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
+    if (!user.scene.arena.weather?.isEffectSuppressed(user.scene)) {
       const accuracy = args[0] as Utils.NumberHolder;
       const weatherType = user.scene.arena.weather?.weatherType || WeatherType.NONE;
       if (weatherType === WeatherType.HAIL) {
         accuracy.value = -1;
         return true;
       }
+    }
 
     return false;
   }
@@ -1336,6 +1373,8 @@ export class MissEffectAttr extends MoveAttr {
   }
 }
 
+export class TypelessAttr extends MoveAttr { }
+
 export class DisableMoveAttr extends MoveEffectAttr {
   constructor() {
     super(false);
@@ -1732,6 +1771,10 @@ export function applyMoveAttrs(attrType: { new(...args: any[]): MoveAttr }, user
 
 export const allMoves = [
   new StatusMove(Moves.NONE, "-", Type.NORMAL, MoveCategory.STATUS, -1, -1, "", -1, 0, 1),
+];
+
+export function initMoves() {
+  allMoves.push(
     new AttackMove(Moves.POUND, "Pound", Type.NORMAL, MoveCategory.PHYSICAL, 40, 100, 35, -1, "", -1, 0, 1),
     new AttackMove(Moves.KARATE_CHOP, "Karate Chop", Type.FIGHTING, MoveCategory.PHYSICAL, 50, 100, 25, -1, "High critical hit ratio.", -1, 0, 1)
       .attr(HighCritAttr),
@@ -1740,7 +1783,8 @@ export const allMoves = [
     new AttackMove(Moves.COMET_PUNCH, "Comet Punch", Type.NORMAL, MoveCategory.PHYSICAL, 18, 85, 15, -1, "Hits 2-5 times in one turn.", -1, 0, 1)
       .attr(MultiHitAttr),
     new AttackMove(Moves.MEGA_PUNCH, "Mega Punch", Type.NORMAL, MoveCategory.PHYSICAL, 80, 85, 20, -1, "", -1, 0, 1),
-  new AttackMove(Moves.PAY_DAY, "Pay Day (N)", Type.NORMAL, MoveCategory.PHYSICAL, 40, 100, 20, -1, "Money is earned after the battle.", -1, 0, 1),
+    new AttackMove(Moves.PAY_DAY, "Pay Day (N)", Type.NORMAL, MoveCategory.PHYSICAL, 40, 100, 20, -1, "Money is earned after the battle.", -1, 0, 1)
+      .makesContact(false),
     new AttackMove(Moves.FIRE_PUNCH, "Fire Punch", Type.FIRE, MoveCategory.PHYSICAL, 75, 100, 15, 67, "May burn opponent.", 10, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.BURN),
     new AttackMove(Moves.ICE_PUNCH, "Ice Punch", Type.ICE, MoveCategory.PHYSICAL, 75, 100, 15, 69, "May freeze opponent.", 10, 0, 1)
@@ -1801,12 +1845,15 @@ export const allMoves = [
     new StatusMove(Moves.TAIL_WHIP, "Tail Whip", Type.NORMAL, 100, 30, -1, "Lowers opponent's Defense.", -1, 0, 1)
       .attr(StatChangeAttr, BattleStat.DEF, -1),
     new AttackMove(Moves.POISON_STING, "Poison Sting", Type.POISON, MoveCategory.PHYSICAL, 15, 100, 35, -1, "May poison the opponent.", 30, 0, 1)
-    .attr(StatusEffectAttr, StatusEffect.POISON),
+      .attr(StatusEffectAttr, StatusEffect.POISON)
+      .makesContact(false),
     new AttackMove(Moves.TWINEEDLE, "Twineedle", Type.BUG, MoveCategory.PHYSICAL, 25, 100, 20, -1, "Hits twice in one turn. May poison opponent.", 20, 0, 1)
       .attr(MultiHitAttr, MultiHitType._2)
-    .attr(StatusEffectAttr, StatusEffect.POISON),
+      .attr(StatusEffectAttr, StatusEffect.POISON)
+      .makesContact(false),
     new AttackMove(Moves.PIN_MISSILE, "Pin Missile", Type.BUG, MoveCategory.PHYSICAL, 25, 95, 20, -1, "Hits 2-5 times in one turn.", -1, 1, 0)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new StatusMove(Moves.LEER, "Leer", Type.NORMAL, 100, 30, -1, "Lowers opponent's Defense.", 100, 0, 1)
       .attr(StatChangeAttr, BattleStat.DEF, -1),
     new AttackMove(Moves.BITE, "Bite", Type.DARK, MoveCategory.PHYSICAL, 60, 100, 25, -1, "May cause flinching.", 30, 0, 1)
@@ -1865,7 +1912,8 @@ export const allMoves = [
     new SelfStatusMove(Moves.GROWTH, "Growth", Type.NORMAL, -1, 20, -1, "Raises user's Attack and Special Attack.", -1, 0, 1)
       .attr(GrowthStatChangeAttr),
     new AttackMove(Moves.RAZOR_LEAF, "Razor Leaf", Type.GRASS, MoveCategory.PHYSICAL, 55, 95, 25, -1, "High critical hit ratio.", -1, 0, 1)
-    .attr(HighCritAttr),
+      .attr(HighCritAttr)
+      .makesContact(false),
     new AttackMove(Moves.SOLAR_BEAM, "Solar Beam", Type.GRASS, MoveCategory.SPECIAL, 120, 100, 10, 168, "Charges on first turn, attacks on second.", -1, 0, 1)
       .attr(SolarBeamChargeAttr)
       .attr(SolarBeamPowerAttr),
@@ -1878,7 +1926,8 @@ export const allMoves = [
     new AttackMove(Moves.PETAL_DANCE, "Petal Dance", Type.GRASS, MoveCategory.SPECIAL, 120, 100, 10, -1, "User attacks for 2-3 turns but then becomes confused.", -1, 0, 1)
       .attr(FrenzyAttr)
       .attr(MissEffectAttr, frenzyMissFunc)
-    .attr(ConfuseAttr, true), // TODO: Update to still confuse if last hit misses
+      .attr(ConfuseAttr, true) // TODO: Update to still confuse if last hit misses
+      .makesContact(),
     new StatusMove(Moves.STRING_SHOT, "String Shot", Type.BUG, 95, 40, -1, "Sharply lowers opponent's Speed.", -1, 0, 1)
       .attr(StatChangeAttr, BattleStat.SPD, -2),
     new AttackMove(Moves.DRAGON_RAGE, "Dragon Rage", Type.DRAGON, MoveCategory.SPECIAL, -1, 100, 10, -1, "Always inflicts 40 HP.", -1, 0, 1)
@@ -1894,11 +1943,14 @@ export const allMoves = [
       .attr(ThunderAccuracyAttr),
     new AttackMove(Moves.THUNDER, "Thunder", Type.ELECTRIC, MoveCategory.SPECIAL, 110, 70, 10, 166, "May paralyze opponent.", 30, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.PARALYSIS),
-  new AttackMove(Moves.ROCK_THROW, "Rock Throw", Type.ROCK, MoveCategory.PHYSICAL, 50, 90, 15, -1, "", -1, 0, 1),
+    new AttackMove(Moves.ROCK_THROW, "Rock Throw", Type.ROCK, MoveCategory.PHYSICAL, 50, 90, 15, -1, "", -1, 0, 1)
+      .makesContact(false),
     new AttackMove(Moves.EARTHQUAKE, "Earthquake", Type.GROUND, MoveCategory.PHYSICAL, 100, 100, 10, 149, "Power is doubled if opponent is underground from using Dig.", -1, 0, 1)
-    .attr(HitsTagAttr, BattlerTagType.UNDERGROUND, true),
+      .attr(HitsTagAttr, BattlerTagType.UNDERGROUND, true)
+      .makesContact(false),
     new AttackMove(Moves.FISSURE, "Fissure", Type.GROUND, MoveCategory.PHYSICAL, -1, 30, 5, -1, "One-Hit-KO, if it hits.", -1, 0, 1)
-    .attr(OneHitKOAttr),
+      .attr(OneHitKOAttr)
+      .makesContact(false),
     new AttackMove(Moves.DIG, "Dig", Type.GROUND, MoveCategory.PHYSICAL, 80, 100, 10, 55, "Digs underground on first turn, attacks on second. Can also escape from caves.", -1, 0, 1)
       .attr(ChargeAttr, ChargeAnim.DIG_CHARGING, 'dug a hole!', BattlerTagType.UNDERGROUND),
     new StatusMove(Moves.TOXIC, "Toxic", Type.POISON, 90, 10, -1, "Badly poisons opponent.", -1, 0, 1)
@@ -1950,8 +2002,10 @@ export const allMoves = [
       .attr(RandomMoveAttr),
     new SelfStatusMove(Moves.MIRROR_MOVE, "Mirror Move (N)", Type.FLYING, -1, 20, -1, "User performs the opponent's last move.", -1, 0, 1),
     new AttackMove(Moves.SELF_DESTRUCT, "Self-Destruct", Type.NORMAL, MoveCategory.PHYSICAL, 200, 100, 5, -1, "User faints.", -1, 0, 1)
-    .attr(SacrificialAttr),
+      .attr(SacrificialAttr)
-  new AttackMove(Moves.EGG_BOMB, "Egg Bomb", Type.NORMAL, MoveCategory.PHYSICAL, 100, 75, 10, -1, "", -1, 0, 1),
+      .makesContact(false),
+    new AttackMove(Moves.EGG_BOMB, "Egg Bomb", Type.NORMAL, MoveCategory.PHYSICAL, 100, 75, 10, -1, "", -1, 0, 1)
+      .makesContact(false),
     new AttackMove(Moves.LICK, "Lick", Type.GHOST, MoveCategory.PHYSICAL, 30, 100, 30, -1, "May paralyze opponent.", 30, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.PARALYSIS),
     new AttackMove(Moves.SMOG, "Smog", Type.POISON, MoveCategory.SPECIAL, 30, 70, 20, -1, "May poison opponent.", 40, 0, 1)
@@ -1959,7 +2013,8 @@ export const allMoves = [
     new AttackMove(Moves.SLUDGE, "Sludge", Type.POISON, MoveCategory.SPECIAL, 65, 100, 20, -1, "May poison opponent.", 30, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.POISON),
     new AttackMove(Moves.BONE_CLUB, "Bone Club", Type.GROUND, MoveCategory.PHYSICAL, 65, 85, 20, -1, "May cause flinching.", 10, 0, 1)
-    .attr(FlinchAttr),
+      .attr(FlinchAttr)
+      .makesContact(false),
     new AttackMove(Moves.FIRE_BLAST, "Fire Blast", Type.FIRE, MoveCategory.SPECIAL, 110, 85, 5, 141, "May burn opponent.", 10, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.BURN),
     new AttackMove(Moves.WATERFALL, "Waterfall", Type.WATER, MoveCategory.PHYSICAL, 80, 100, 15, 77, "May cause flinching.", 20, 0, 1)
@@ -1971,7 +2026,8 @@ export const allMoves = [
       .attr(ChargeAttr, ChargeAnim.SKULL_BASH_CHARGING, 'lowered\nits head!', null, true)
       .attr(StatChangeAttr, BattleStat.DEF, 1, true),
     new AttackMove(Moves.SPIKE_CANNON, "Spike Cannon", Type.NORMAL, MoveCategory.PHYSICAL, 20, 100, 15, -1, "Hits 2-5 times in one turn.", -1, 0, 1)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new AttackMove(Moves.CONSTRICT, "Constrict", Type.NORMAL, MoveCategory.PHYSICAL, 10, 100, 35, -1, "May lower opponent's Speed by one stage.", 10, 0, 1)
       .attr(StatChangeAttr, BattleStat.SPD, -1),
     new SelfStatusMove(Moves.AMNESIA, "Amnesia", Type.PSYCHIC, -1, 20, 128, "Sharply raises user's Special Defense.", -1, 0, 1)
@@ -1990,7 +2046,8 @@ export const allMoves = [
     new StatusMove(Moves.POISON_GAS, "Poison Gas", Type.POISON, 90, 40, -1, "Poisons opponent.", -1, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.POISON),
     new AttackMove(Moves.BARRAGE, "Barrage", Type.NORMAL, MoveCategory.PHYSICAL, 15, 85, 20, -1, "Hits 2-5 times in one turn.", -1, 0, 1)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new AttackMove(Moves.LEECH_LIFE, "Leech Life", Type.BUG, MoveCategory.PHYSICAL, 80, 100, 10, 95, "User recovers half the HP inflicted on opponent.", -1, 0, 1)
       .attr(HitHealAttr),
     new StatusMove(Moves.LOVELY_KISS, "Lovely Kiss", Type.NORMAL, 75, 10, -1, "Puts opponent to sleep.", -1, 0, 1)
@@ -1998,7 +2055,8 @@ export const allMoves = [
     new AttackMove(Moves.SKY_ATTACK, "Sky Attack", Type.FLYING, MoveCategory.PHYSICAL, 140, 90, 5, -1, "Charges on first turn, attacks on second. May cause flinching. High critical hit ratio.", 30, 0, 1)
       .attr(ChargeAttr, ChargeAnim.SKY_ATTACK_CHARGING, 'is glowing!')
       .attr(HighCritAttr)
-    .attr(FlinchAttr),
+      .attr(FlinchAttr)
+      .makesContact(false),
     new SelfStatusMove(Moves.TRANSFORM, "Transform (N)", Type.NORMAL, -1, 10, -1, "User takes on the form and attacks of the opponent.", -1, 0, 1),
     new AttackMove(Moves.BUBBLE, "Bubble", Type.WATER, MoveCategory.SPECIAL, 40, 100, 30, -1, "May lower opponent's Speed.", 10, 0, 1)
       .attr(StatChangeAttr, BattleStat.SPD, -1),
@@ -2016,17 +2074,20 @@ export const allMoves = [
     new AttackMove(Moves.CRABHAMMER, "Crabhammer", Type.WATER, MoveCategory.PHYSICAL, 100, 90, 10, -1, "High critical hit ratio.", -1, 0, 1)
       .attr(HighCritAttr),
     new AttackMove(Moves.EXPLOSION, "Explosion", Type.NORMAL, MoveCategory.PHYSICAL, 250, 100, 5, -1, "User faints.", -1, 0, 1)
-    .attr(SacrificialAttr),
+      .attr(SacrificialAttr)
+      .makesContact(false),
     new AttackMove(Moves.FURY_SWIPES, "Fury Swipes", Type.NORMAL, MoveCategory.PHYSICAL, 18, 80, 15, -1, "Hits 2-5 times in one turn.", -1, 0, 1)
       .attr(MultiHitAttr),
     new AttackMove(Moves.BONEMERANG, "Bonemerang", Type.GROUND, MoveCategory.PHYSICAL, 50, 90, 10, -1, "Hits twice in one turn.", -1, 0, 1)
-    .attr(MultiHitAttr, MultiHitType._2),
+      .attr(MultiHitAttr, MultiHitType._2)
+      .makesContact(false),
     new SelfStatusMove(Moves.REST, "Rest", Type.PSYCHIC, -1, 5, 85, "User sleeps for 2 turns, but user is fully healed.", -1, 0, 1)
       .attr(StatusEffectAttr, StatusEffect.SLEEP, true, 3)
       .attr(HealAttr, 1, true)
       .condition((user: Pokemon, target: Pokemon, move: Move) => user.status?.effect !== StatusEffect.SLEEP),
     new AttackMove(Moves.ROCK_SLIDE, "Rock Slide", Type.ROCK, MoveCategory.PHYSICAL, 75, 90, 10, 86, "May cause flinching.", 30, 0, 1)
-    .attr(FlinchAttr),
+      .attr(FlinchAttr)
+      .makesContact(false),
     new AttackMove(Moves.HYPER_FANG, "Hyper Fang", Type.NORMAL, MoveCategory.PHYSICAL, 80, 90, 15, -1, "May cause flinching.", 10, 0, 1)
       .attr(FlinchAttr),
     new SelfStatusMove(Moves.SHARPEN, "Sharpen", Type.NORMAL, -1, 30, -1, "Raises user's Attack.", -1, 0, 1)
@@ -2040,8 +2101,11 @@ export const allMoves = [
       .attr(TargetHalfHpDamageAttr),
     new AttackMove(Moves.SLASH, "Slash", Type.NORMAL, MoveCategory.PHYSICAL, 70, 100, 20, -1, "High critical hit ratio.", -1, 0, 1)
       .attr(HighCritAttr),
-  new SelfStatusMove(Moves.SUBSTITUTE, "Substitute (N)", Type.NORMAL, -1, 10, 103, "Uses HP to creates a decoy that takes hits.", -1, 0, 1),
+    new SelfStatusMove(Moves.SUBSTITUTE, "Substitute (N)", Type.NORMAL, -1, 10, 103, "Uses HP to creates a decoy that takes hits.", -1, 0, 1)
-  new AttackMove(Moves.STRUGGLE, "Struggle", Type.NORMAL, MoveCategory.PHYSICAL, 50, -1, -1, -1, "Only usable when all PP are gone. Hurts the user.", -1, 0, 1),
+      .attr(RecoilAttr),
+    new AttackMove(Moves.STRUGGLE, "Struggle", Type.NORMAL, MoveCategory.PHYSICAL, 50, -1, -1, -1, "Only usable when all PP are gone. Hurts the user.", -1, 0, 1)
+      .attr(RecoilAttr, true)
+      .attr(TypelessAttr),
     new SelfStatusMove(Moves.SKETCH, "Sketch", Type.NORMAL, -1, 1, -1, "Permanently copies the opponent's last move.", -1, 0, 2)
       .attr(SketchAttr),
     new AttackMove(Moves.TRIPLE_KICK, "Triple Kick", Type.FIGHTING, MoveCategory.PHYSICAL, 10, 90, 10, -1, "Hits thrice in one turn at increasing power.", -1, 0, 2)
@@ -2095,15 +2159,16 @@ export const allMoves = [
       .attr(StatusEffectAttr, StatusEffect.PARALYSIS),
     new StatusMove(Moves.FORESIGHT, "Foresight (N)", Type.NORMAL, -1, 40, -1, "Resets opponent's Evasiveness, and allows Normal- and Fighting-type attacks to hit Ghosts.", -1, 0, 2), // TODO
     new StatusMove(Moves.DESTINY_BOND, "Destiny Bond (N)", Type.GHOST, -1, 5, -1, "If the user faints, the opponent also faints.", -1, 0, 2)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new StatusMove(Moves.PERISH_SONG, "Perish Song (N)", Type.NORMAL, -1, 5, -1, "Any Pokémon in play when this attack is used faints in 3 turns.", -1, 0, 2)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new AttackMove(Moves.ICY_WIND, "Icy Wind", Type.ICE, MoveCategory.SPECIAL, 55, 95, 15, 34, "Lowers opponent's Speed.", 100, 0, 2)
       .attr(StatChangeAttr, BattleStat.SPD, -1),
     new SelfStatusMove(Moves.DETECT, "Detect", Type.FIGHTING, -1, 5, -1, "Protects the user, but may fail if used consecutively.", -1, 4, 2)
       .attr(ProtectAttr),
     new AttackMove(Moves.BONE_RUSH, "Bone Rush", Type.GROUND, MoveCategory.PHYSICAL, 25, 90, 10, -1, "Hits 2-5 times in one turn.", -1, 0, 2)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new SelfStatusMove(Moves.LOCK_ON, "Lock-On (N)", Type.NORMAL, -1, 5, -1, "User's next attack is guaranteed to hit.", -1, 0, 2),
     new AttackMove(Moves.OUTRAGE, "Outrage", Type.DRAGON, MoveCategory.PHYSICAL, 120, 100, 10, 156, "User attacks for 2-3 turns but then becomes confused.", -1, 0, 2)
       .attr(FrenzyAttr)
@@ -2139,13 +2204,16 @@ export const allMoves = [
       .condition((user: Pokemon, target: Pokemon, move: Move) => user.status?.effect === StatusEffect.SLEEP),
     new SelfStatusMove(Moves.HEAL_BELL, "Heal Bell (N)", Type.NORMAL, -1, 5, -1, "Heals the user's party's status conditions.", -1, 0, 2),
     new AttackMove(Moves.RETURN, "Return (N)", Type.NORMAL, MoveCategory.PHYSICAL, -1, 100, 20, -1, "Power increases with higher Friendship.", -1, 0, 2),
-  new AttackMove(Moves.PRESENT, "Present (N)", Type.NORMAL, MoveCategory.PHYSICAL, -1, 90, 15, -1, "Either deals damage or heals.", -1, 0, 2),
+    new AttackMove(Moves.PRESENT, "Present (N)", Type.NORMAL, MoveCategory.PHYSICAL, -1, 90, 15, -1, "Either deals damage or heals.", -1, 0, 2)
+      .makesContact(false),
     new AttackMove(Moves.FRUSTRATION, "Frustration (N)", Type.NORMAL, MoveCategory.PHYSICAL, -1, 100, 20, -1, "Power decreases with higher Friendship.", -1, 0, 2),
     new SelfStatusMove(Moves.SAFEGUARD, "Safeguard (N)", Type.NORMAL, -1, 25, -1, "The user's party is protected from status conditions.", -1, 0, 2),
     new StatusMove(Moves.PAIN_SPLIT, "Pain Split (N)", Type.NORMAL, -1, 20, -1, "The user's and opponent's HP becomes the average of both.", -1, 0, 2),
     new AttackMove(Moves.SACRED_FIRE, "Sacred Fire", Type.FIRE, MoveCategory.PHYSICAL, 100, 95, 5, -1, "May burn opponent.", 50, 0, 2)
-    .attr(StatusEffectAttr, StatusEffect.BURN),
+      .attr(StatusEffectAttr, StatusEffect.BURN)
-  new AttackMove(Moves.MAGNITUDE, "Magnitude (N)", Type.GROUND, MoveCategory.PHYSICAL, -1, 100, 30, -1, "Hits with random power.", -1, 0, 2),
+      .makesContact(false),
+    new AttackMove(Moves.MAGNITUDE, "Magnitude (N)", Type.GROUND, MoveCategory.PHYSICAL, -1, 100, 30, -1, "Hits with random power.", -1, 0, 2)
+      .makesContact(false),
     new AttackMove(Moves.DYNAMIC_PUNCH, "Dynamic Punch", Type.FIGHTING, MoveCategory.PHYSICAL, 100, 50, 5, -1, "Confuses opponent.", 100, 0, 2)
       .attr(ConfuseAttr),
     new AttackMove(Moves.MEGAHORN, "Megahorn", Type.BUG, MoveCategory.PHYSICAL, 120, 85, 10, -1, "", -1, 0, 2),
@@ -2194,7 +2262,8 @@ export const allMoves = [
       .attr(StatChangeAttr, BattleStat.DEF, -1),
     new AttackMove(Moves.WHIRLPOOL, "Whirlpool", Type.WATER, MoveCategory.SPECIAL, 35, 85, 15, -1, "Traps opponent, damaging them for 4-5 turns.", 100, 0, 2)
       .attr(TrapAttr, BattlerTagType.WHIRLPOOL),
-  new AttackMove(Moves.BEAT_UP, "Beat Up (N)", Type.DARK, MoveCategory.PHYSICAL, -1, 100, 10, -1, "Each Pokémon in user's party attacks.", -1, 0, 2),
+    new AttackMove(Moves.BEAT_UP, "Beat Up (N)", Type.DARK, MoveCategory.PHYSICAL, -1, 100, 10, -1, "Each Pokémon in user's party attacks.", -1, 0, 2)
+      .makesContact(false),
     new AttackMove(Moves.FAKE_OUT, "Fake Out", Type.NORMAL, MoveCategory.PHYSICAL, 40, 100, 10, -1, "User attacks first, foe flinches. Only usable on first turn.", 100, 3, 3)
       .attr(FlinchAttr)
       .condition((user: Pokemon, target: Pokemon, move: Move) => user.scene.currentBattle.turn === 1),
@@ -2252,7 +2321,8 @@ export const allMoves = [
       .condition((user: Pokemon, target: Pokemon, move: Move) => user.status && (user.status.effect === StatusEffect.PARALYSIS || user.status.effect === StatusEffect.POISON || user.status.effect === StatusEffect.TOXIC || user.status.effect === StatusEffect.BURN)),
     new SelfStatusMove(Moves.GRUDGE, "Grudge (N)", Type.GHOST, -1, 5, -1, "If the users faints after using this move, the PP for the opponent's last move is depleted.", -1, 0, 3),
     new SelfStatusMove(Moves.SNATCH, "Snatch (N)", Type.DARK, -1, 10, -1, "Steals the effects of the opponent's next move.", -1, 4, 3),
-  new AttackMove(Moves.SECRET_POWER, "Secret Power (N)", Type.NORMAL, MoveCategory.PHYSICAL, 70, 100, 20, -1, "Effects of the attack vary with the location.", 30, 0, 3),
+    new AttackMove(Moves.SECRET_POWER, "Secret Power (N)", Type.NORMAL, MoveCategory.PHYSICAL, 70, 100, 20, -1, "Effects of the attack vary with the location.", 30, 0, 3)
+      .makesContact(false),
     new AttackMove(Moves.DIVE, "Dive", Type.WATER, MoveCategory.PHYSICAL, 80, 100, 10, -1, "Dives underwater on first turn, attacks on second turn.", -1, 0, 3)
       .attr(ChargeAttr, ChargeAnim.DIVE_CHARGING, 'hid\nunderwater!'),
     new AttackMove(Moves.ARM_THRUST, "Arm Thrust", Type.FIGHTING, MoveCategory.PHYSICAL, 15, 100, 20, -1, "Hits 2-5 times in one turn.", -1, 0, 3)
@@ -2304,7 +2374,8 @@ export const allMoves = [
       .attr(StatChangeAttr, BattleStat.SPATK, -2, true),
     new StatusMove(Moves.ODOR_SLEUTH, "Odor Sleuth (N)", Type.NORMAL, -1, 40, -1, "Resets opponent's Evasiveness, and allows Normal- and Fighting-type attacks to hit Ghosts.", -1, 0, 3),
     new AttackMove(Moves.ROCK_TOMB, "Rock Tomb", Type.ROCK, MoveCategory.PHYSICAL, 60, 95, 15, 36, "Lowers opponent's Speed.", 100, 0, 3)
-    .attr(StatChangeAttr, BattleStat.SPD, -1),
+      .attr(StatChangeAttr, BattleStat.SPD, -1)
+      .makesContact(false),
     new AttackMove(Moves.SILVER_WIND, "Silver Wind", Type.BUG, MoveCategory.SPECIAL, 60, 100, 5, -1, "May raise all stats of user at once.", 10, 0, 3)
       .attr(StatChangeAttr, [ BattleStat.ATK, BattleStat.DEF, BattleStat.SPATK, BattleStat.SPDEF, BattleStat.SPD ], 1, true),
     new StatusMove(Moves.METAL_SOUND, "Metal Sound", Type.STEEL, 85, 40, -1, "Sharply lowers opponent's Special Defense.", -1, 0, 3)
@@ -2326,16 +2397,19 @@ export const allMoves = [
     new AttackMove(Moves.SKY_UPPERCUT, "Sky Uppercut", Type.FIGHTING, MoveCategory.PHYSICAL, 85, 90, 15, -1, "Hits the opponent, even during Fly.", -1, 0, 3)
       .attr(HitsTagAttr, BattlerTagType.FLYING),
     new AttackMove(Moves.SAND_TOMB, "Sand Tomb", Type.GROUND, MoveCategory.PHYSICAL, 35, 85, 15, -1, "Traps opponent, damaging them for 4-5 turns.", 100, 0, 3)
-    .attr(TrapAttr, BattlerTagType.SAND_TOMB),
+      .attr(TrapAttr, BattlerTagType.SAND_TOMB)
+      .makesContact(false),
     new AttackMove(Moves.SHEER_COLD, "Sheer Cold", Type.ICE, MoveCategory.SPECIAL, -1, 30, 5, -1, "One-Hit-KO, if it hits.", -1, 0, 3)
       .attr(OneHitKOAttr),
     new AttackMove(Moves.MUDDY_WATER, "Muddy Water", Type.WATER, MoveCategory.SPECIAL, 90, 85, 10, -1, "May lower opponent's Accuracy.", 30, 0, 3)
       .attr(StatChangeAttr, BattleStat.ACC, -1),
     new AttackMove(Moves.BULLET_SEED, "Bullet Seed", Type.GRASS, MoveCategory.PHYSICAL, 25, 100, 30, 56, "Hits 2-5 times in one turn.", -1, 0, 3)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new AttackMove(Moves.AERIAL_ACE, "Aerial Ace", Type.FLYING, MoveCategory.PHYSICAL, 60, -1, 20, 27, "Ignores Accuracy and Evasiveness.", -1, 0, 3),
     new AttackMove(Moves.ICICLE_SPEAR, "Icicle Spear", Type.ICE, MoveCategory.PHYSICAL, 25, 100, 30, -1, "Hits 2-5 times in one turn.", -1, 0, 3)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new SelfStatusMove(Moves.IRON_DEFENSE, "Iron Defense", Type.STEEL, -1, 15, 104, "Sharply raises user's Defense.", -1, 0, 3)
       .attr(StatChangeAttr, BattleStat.DEF, 2, true),
     new StatusMove(Moves.BLOCK, "Block", Type.NORMAL, -1, 5, -1, "Opponent cannot flee or switch.", -1, 0, 3)
@@ -2369,7 +2443,8 @@ export const allMoves = [
     new SelfStatusMove(Moves.DRAGON_DANCE, "Dragon Dance", Type.DRAGON, -1, 20, 100, "Raises user's Attack and Speed.", -1, 0, 3)
       .attr(StatChangeAttr, [ BattleStat.ATK, BattleStat.SPD ], 1, true),
     new AttackMove(Moves.ROCK_BLAST, "Rock Blast", Type.ROCK, MoveCategory.PHYSICAL, 25, 90, 10, 76, "Hits 2-5 times in one turn.", -1, 0, 3)
-    .attr(MultiHitAttr),
+      .attr(MultiHitAttr)
+      .makesContact(false),
     new AttackMove(Moves.SHOCK_WAVE, "Shock Wave", Type.ELECTRIC, MoveCategory.SPECIAL, 60, -1, 20, -1, "Ignores Accuracy and Evasiveness.", -1, 0, 3),
     new AttackMove(Moves.WATER_PULSE, "Water Pulse", Type.WATER, MoveCategory.SPECIAL, 60, 100, 20, 11, "May confuse opponent.", 20, 0, 3)
       .attr(ConfuseAttr),
@@ -2390,26 +2465,32 @@ export const allMoves = [
       .attr(SacrificialAttr), // TODO
     new AttackMove(Moves.BRINE, "Brine", Type.WATER, MoveCategory.SPECIAL, 65, 100, 10, -1, "Power doubles if opponent's HP is less than 50%.", -1, 0, 4)
       .attr(MovePowerMultiplierAttr, (user: Pokemon, target: Pokemon, move: Move) => target.getHpRatio() < 0.5 ? 2 : 1),
-  new AttackMove(Moves.NATURAL_GIFT, "Natural Gift (N)", Type.NORMAL, MoveCategory.PHYSICAL, -1, 100, 15, -1, "Power and type depend on the user's held berry.", -1, 0, 4),
+    new AttackMove(Moves.NATURAL_GIFT, "Natural Gift (N)", Type.NORMAL, MoveCategory.PHYSICAL, -1, 100, 15, -1, "Power and type depend on the user's held berry.", -1, 0, 4)
+      .makesContact(false),
     new AttackMove(Moves.FEINT, "Feint", Type.NORMAL, MoveCategory.PHYSICAL, 30, 100, 10, -1, "Only hits if opponent uses Protect or Detect in the same turn.", -1, 2, 4)
       .condition((user: Pokemon, target: Pokemon, move: Move) => !!target.getTag(BattlerTagType.PROTECTED))
-    .ignoreProtect(),
+      .makesContact(false)
+      .ignoresProtect(),
     new AttackMove(Moves.PLUCK, "Pluck (N)", Type.FLYING, MoveCategory.PHYSICAL, 60, 100, 20, -1, "If the opponent is holding a berry, its effect is stolen by user.", -1, 0, 4),
     new SelfStatusMove(Moves.TAILWIND, "Tailwind (N)", Type.FLYING, -1, 15, 113, "Doubles Speed for 4 turns.", -1, 0, 4),
     new SelfStatusMove(Moves.ACUPRESSURE, "Acupressure", Type.NORMAL, -1, 30, -1, "Sharply raises a random stat.", -1, 0, 4)
       .attr(StatChangeAttr, BattleStat.RAND, 2, true),
-  new AttackMove(Moves.METAL_BURST, "Metal Burst (N)", Type.STEEL, MoveCategory.PHYSICAL, -1, 100, 10, -1, "Deals damage equal to 1.5x opponent's attack.", -1, 0, 4),
+    new AttackMove(Moves.METAL_BURST, "Metal Burst (N)", Type.STEEL, MoveCategory.PHYSICAL, -1, 100, 10, -1, "Deals damage equal to 1.5x opponent's attack.", -1, 0, 4)
+      .makesContact(false),
     new AttackMove(Moves.U_TURN, "U-turn (N)", Type.BUG, MoveCategory.PHYSICAL, 70, 100, 20, 60, "User switches out immediately after attacking.", -1, 0, 4),
     new AttackMove(Moves.CLOSE_COMBAT, "Close Combat", Type.FIGHTING, MoveCategory.PHYSICAL, 120, 100, 5, 167, "Lowers user's Defense and Special Defense.", 100, 0, 4)
       .attr(StatChangeAttr, [ BattleStat.DEF, BattleStat.SPDEF ], -1, true),
     new AttackMove(Moves.PAYBACK, "Payback (N)", Type.DARK, MoveCategory.PHYSICAL, 50, 100, 10, -1, "Power doubles if the user was attacked first.", -1, 0, 4),
     new AttackMove(Moves.ASSURANCE, "Assurance (N)", Type.DARK, MoveCategory.PHYSICAL, 60, 100, 10, -1, "Power doubles if opponent already took damage in the same turn.", -1, 0, 4),
     new StatusMove(Moves.EMBARGO, "Embargo (N)", Type.DARK, 100, 15, -1, "Opponent cannot use items.", -1, 0, 4),
-  new AttackMove(Moves.FLING, "Fling (N)", Type.DARK, MoveCategory.PHYSICAL, -1, 100, 10, 43, "Power depends on held item.", -1, 0, 4),
+    new AttackMove(Moves.FLING, "Fling (N)", Type.DARK, MoveCategory.PHYSICAL, -1, 100, 10, 43, "Power depends on held item.", -1, 0, 4)
+      .makesContact(false),
     new StatusMove(Moves.PSYCHO_SHIFT, "Psycho Shift (N)", Type.PSYCHIC, 100, 10, -1, "Transfers user's status condition to the opponent.", -1, 0, 4),
-  new AttackMove(Moves.TRUMP_CARD, "Trump Card (N)", Type.NORMAL, MoveCategory.SPECIAL, -1, -1, 5, -1, "The lower the PP, the higher the power.", -1, 0, 4),
+    new AttackMove(Moves.TRUMP_CARD, "Trump Card (N)", Type.NORMAL, MoveCategory.SPECIAL, -1, -1, 5, -1, "The lower the PP, the higher the power.", -1, 0, 4)
+      .makesContact(),
     new StatusMove(Moves.HEAL_BLOCK, "Heal Block (N)", Type.PSYCHIC, 100, 15, -1, "Prevents the opponent from restoring HP for 5 turns.", -1, 0, 4),
-  new AttackMove(Moves.WRING_OUT, "Wring Out (N)", Type.NORMAL, MoveCategory.SPECIAL, -1, 100, 5, -1, "The higher the opponent's HP, the higher the damage.", -1, 0, 4),
+    new AttackMove(Moves.WRING_OUT, "Wring Out (N)", Type.NORMAL, MoveCategory.SPECIAL, -1, 100, 5, -1, "The higher the opponent's HP, the higher the damage.", -1, 0, 4)
+      .makesContact(),
     new SelfStatusMove(Moves.POWER_TRICK, "Power Trick (N)", Type.PSYCHIC, -1, 10, -1, "User's own Attack and Defense switch.", -1, 0, 4),
     new StatusMove(Moves.GASTRO_ACID, "Gastro Acid (N)", Type.POISON, 100, 10, -1, "Cancels out the effect of the opponent's Ability.", -1, 0, 4),
     new StatusMove(Moves.LUCKY_CHANT, "Lucky Chant (N)", Type.NORMAL, -1, 30, -1, "Opponent cannot land critical hits for 5 turns.", -1, 0, 4)
@@ -2444,7 +2525,8 @@ export const allMoves = [
     new AttackMove(Moves.NIGHT_SLASH, "Night Slash", Type.DARK, MoveCategory.PHYSICAL, 70, 100, 15, -1, "High critical hit ratio.", -1, 0, 4)
       .attr(HighCritAttr),
     new AttackMove(Moves.AQUA_TAIL, "Aqua Tail", Type.WATER, MoveCategory.PHYSICAL, 90, 90, 10, -1, "", -1, 0, 4),
-  new AttackMove(Moves.SEED_BOMB, "Seed Bomb", Type.GRASS, MoveCategory.PHYSICAL, 80, 100, 15, 71, "", -1, 0, 4),
+    new AttackMove(Moves.SEED_BOMB, "Seed Bomb", Type.GRASS, MoveCategory.PHYSICAL, 80, 100, 15, 71, "", -1, 0, 4)
+      .makesContact(false),
     new AttackMove(Moves.AIR_SLASH, "Air Slash", Type.FLYING, MoveCategory.SPECIAL, 75, 95, 15, 65, "May cause flinching.", 30, 0, 4)
       .attr(FlinchAttr),
     new AttackMove(Moves.X_SCISSOR, "X-Scissor", Type.BUG, MoveCategory.PHYSICAL, 80, 100, 15, 105, "", -1, 0, 4),
@@ -2473,7 +2555,8 @@ export const allMoves = [
     new AttackMove(Moves.BULLET_PUNCH, "Bullet Punch", Type.STEEL, MoveCategory.PHYSICAL, 40, 100, 30, -1, "User attacks first.", -1, 1, 4),
     new AttackMove(Moves.AVALANCHE, "Avalanche", Type.ICE, MoveCategory.PHYSICAL, 60, 100, 10, 46, "Power doubles if user took damage first.", -1, -4, 4)
       .attr(TurnDamagedDoublePowerAttr),
-  new AttackMove(Moves.ICE_SHARD, "Ice Shard", Type.ICE, MoveCategory.PHYSICAL, 40, 100, 30, -1, "User attacks first.", -1, 1, 4),
+    new AttackMove(Moves.ICE_SHARD, "Ice Shard", Type.ICE, MoveCategory.PHYSICAL, 40, 100, 30, -1, "User attacks first.", -1, 1, 4)
+      .makesContact(false),
     new AttackMove(Moves.SHADOW_CLAW, "Shadow Claw", Type.GHOST, MoveCategory.PHYSICAL, 70, 100, 15, 61, "High critical hit ratio.", -1, 0, 4)
       .attr(HighCritAttr),
     new AttackMove(Moves.THUNDER_FANG, "Thunder Fang", Type.ELECTRIC, MoveCategory.PHYSICAL, 65, 95, 15, 9, "May cause flinching and/or paralyze opponent.", 10, 0, 4)
@@ -2489,7 +2572,8 @@ export const allMoves = [
     new AttackMove(Moves.MUD_BOMB, "Mud Bomb", Type.GROUND, MoveCategory.SPECIAL, 65, 85, 10, -1, "May lower opponent's Accuracy.", 30, 0, 4)
       .attr(StatChangeAttr, BattleStat.ACC, -1),
     new AttackMove(Moves.PSYCHO_CUT, "Psycho Cut", Type.PSYCHIC, MoveCategory.PHYSICAL, 70, 100, 20, -1, "High critical hit ratio.", -1, 0, 4)
-    .attr(HighCritAttr),
+      .attr(HighCritAttr)
+      .makesContact(false),
     new AttackMove(Moves.ZEN_HEADBUTT, "Zen Headbutt", Type.PSYCHIC, MoveCategory.PHYSICAL, 80, 90, 15, 59, "May cause flinching.", 20, 0, 4)
       .attr(FlinchAttr),
     new AttackMove(Moves.MIRROR_SHOT, "Mirror Shot", Type.STEEL, MoveCategory.SPECIAL, 65, 85, 10, -1, "May lower opponent's Accuracy.", 30, 0, 4)
@@ -2503,7 +2587,7 @@ export const allMoves = [
       .attr(ClearWeatherAttr, WeatherType.FOG),
     new StatusMove(Moves.TRICK_ROOM, "Trick Room", Type.PSYCHIC, -1, 5, 161, "Slower Pokémon move first in the turn for 5 turns.", -1, 0, 4)
       .attr(AddArenaTagAttr, ArenaTagType.TRICK_ROOM, 5)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new AttackMove(Moves.DRACO_METEOR, "Draco Meteor", Type.DRAGON, MoveCategory.SPECIAL, 130, 90, 5, 169, "Sharply lowers user's Special Attack.", 100, -7, 4)
       .attr(StatChangeAttr, BattleStat.SPATK, -2, true),
     new AttackMove(Moves.DISCHARGE, "Discharge", Type.ELECTRIC, MoveCategory.SPECIAL, 80, 100, 15, -1, "May paralyze opponent.", 30, 0, 4)
@@ -2514,22 +2598,27 @@ export const allMoves = [
       .attr(StatChangeAttr, BattleStat.SPATK, -2, true),
     new AttackMove(Moves.POWER_WHIP, "Power Whip", Type.GRASS, MoveCategory.PHYSICAL, 120, 85, 10, -1, "", -1, 0, 4),
     new AttackMove(Moves.ROCK_WRECKER, "Rock Wrecker", Type.ROCK, MoveCategory.PHYSICAL, 150, 90, 5, -1, "User must recharge next turn.", -1, 0, 4)
-    .attr(AddBattlerTagAttr, BattlerTagType.RECHARGING, true),
+      .attr(AddBattlerTagAttr, BattlerTagType.RECHARGING, true)
+      .makesContact(false),
     new AttackMove(Moves.CROSS_POISON, "Cross Poison", Type.POISON, MoveCategory.PHYSICAL, 70, 100, 20, -1, "High critical hit ratio. May poison opponent.", 10, 0, 4)
       .attr(HighCritAttr)
       .attr(StatusEffectAttr, StatusEffect.POISON),
     new AttackMove(Moves.GUNK_SHOT, "Gunk Shot", Type.POISON, MoveCategory.PHYSICAL, 120, 80, 5, 102, "May poison opponent.", 30, 0, 4)
-    .attr(StatusEffectAttr, StatusEffect.POISON),
+      .attr(StatusEffectAttr, StatusEffect.POISON)
+      .makesContact(false),
     new AttackMove(Moves.IRON_HEAD, "Iron Head", Type.STEEL, MoveCategory.PHYSICAL, 80, 100, 15, 99, "May cause flinching.", 30, 0, 4)
       .attr(FlinchAttr),
-  new AttackMove(Moves.MAGNET_BOMB, "Magnet Bomb", Type.STEEL, MoveCategory.PHYSICAL, 60, -1, 20, -1, "Ignores Accuracy and Evasiveness.", -1, 0, 4),
+    new AttackMove(Moves.MAGNET_BOMB, "Magnet Bomb", Type.STEEL, MoveCategory.PHYSICAL, 60, -1, 20, -1, "Ignores Accuracy and Evasiveness.", -1, 0, 4)
+      .makesContact(false),
     new AttackMove(Moves.STONE_EDGE, "Stone Edge", Type.ROCK, MoveCategory.PHYSICAL, 100, 80, 5, 150, "High critical hit ratio.", -1, 0, 4)
-    .attr(HighCritAttr),
+      .attr(HighCritAttr)
+      .makesContact(false),
     new StatusMove(Moves.CAPTIVATE, "Captivate (N)", Type.NORMAL, 100, 20, -1, "Sharply lowers opponent's Special Attack if opposite gender.", -1, 0, 4), // TODO
     new StatusMove(Moves.STEALTH_ROCK, "Stealth Rock", Type.ROCK, -1, 20, 116, "Damages opponent switching into battle.", -1, 0, 4)
       .attr(AddArenaTrapTagAttr, ArenaTagType.STEALTH_ROCK),
     new AttackMove(Moves.GRASS_KNOT, "Grass Knot", Type.GRASS, MoveCategory.SPECIAL, -1, 100, 20, 81, "The heavier the opponent, the stronger the attack.", -1, 0, 4)
-    .attr(WeightPowerAttr),
+      .attr(WeightPowerAttr)
+      .makesContact(),
     new AttackMove(Moves.CHATTER, "Chatter", Type.FLYING, MoveCategory.SPECIAL, 65, 100, 20, -1, "Confuses opponent.", 100, 0, 4)
       .attr(ConfuseAttr),
     new AttackMove(Moves.JUDGMENT, "Judgment (N)", Type.NORMAL, MoveCategory.SPECIAL, 100, 100, 10, -1, "Type depends on the Arceus Plate being held.", -1, 0, 4),
@@ -2540,7 +2629,8 @@ export const allMoves = [
       .attr(RecoilAttr),
     new AttackMove(Moves.AQUA_JET, "Aqua Jet", Type.WATER, MoveCategory.PHYSICAL, 40, 100, 20, -1, "User attacks first.", -1, 1, 4),
     new AttackMove(Moves.ATTACK_ORDER, "Attack Order", Type.BUG, MoveCategory.PHYSICAL, 90, 100, 15, -1, "High critical hit ratio.", -1, 0, 4)
-    .attr(HighCritAttr),
+      .attr(HighCritAttr)
+      .makesContact(false),
     new SelfStatusMove(Moves.DEFEND_ORDER, "Defend Order", Type.BUG, -1, 10, -1, "Raises user's Defense and Special Defense.", -1, 0, 4)
       .attr(StatChangeAttr, [ BattleStat.DEF, BattleStat.SPDEF ], 1, true),
     new SelfStatusMove(Moves.HEAL_ORDER, "Heal Order", Type.BUG, -1, 10, -1, "User recovers half its max HP.", -1, 0, 4)
@@ -2566,14 +2656,14 @@ export const allMoves = [
   .attr(StatChangeAttr, [ BattleStat.ATK, BattleStat.DEF, BattleStat.SPATK, BattleStat.SPDEF, BattleStat.SPD ], 1, true),
     new AttackMove(Moves.SHADOW_FORCE, "Shadow Force", Type.GHOST, MoveCategory.PHYSICAL, 120, 100, 5, -1, "Disappears on first turn, attacks on second. Can strike through Protect/Detect.", -1, 0, 4)
       .attr(ChargeAttr, ChargeAnim.SHADOW_FORCE_CHARGING, 'vanished\ninstantly!', BattlerTagType.HIDDEN)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new SelfStatusMove(Moves.HONE_CLAWS, "Hone Claws", Type.DARK, -1, 15, -1, "Raises user's Attack and Accuracy.", -1, 0, 5)
       .attr(StatChangeAttr, [ BattleStat.ATK, BattleStat.ACC ], 1, true),
     new SelfStatusMove(Moves.WIDE_GUARD, "Wide Guard (N)", Type.ROCK, -1, 10, -1, "Protects the user's team from multi-target attacks.", -1, 3, 5),
     new StatusMove(Moves.GUARD_SPLIT, "Guard Split (N)", Type.PSYCHIC, -1, 10, -1, "Averages Defense and Special Defense with the target.", -1, 0, 5),
     new StatusMove(Moves.POWER_SPLIT, "Power Split (N)", Type.PSYCHIC, -1, 10, -1, "Averages Attack and Special Attack with the target.", -1, 0, 5),
     new StatusMove(Moves.WONDER_ROOM, "Wonder Room (N)", Type.PSYCHIC, -1, 10, -1, "Swaps every Pokémon's Defense and Special Defense for 5 turns.", -1, -7, 5)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new AttackMove(Moves.PSYSHOCK, "Psyshock (N)", Type.PSYCHIC, MoveCategory.SPECIAL, 80, 100, 10, 54, "Inflicts damage based on the target's Defense, not Special Defense.", -1, 0, 5),
     new AttackMove(Moves.VENOSHOCK, "Venoshock (N)", Type.POISON, MoveCategory.SPECIAL, 65, 100, 10, 45, "Inflicts double damage if the target is poisoned.", -1, 0, 5),
     new SelfStatusMove(Moves.AUTOTOMIZE, "Autotomize", Type.STEEL, -1, 15, -1, "Reduces weight and sharply raises Speed.", -1, 0, 5)
@@ -2581,8 +2671,9 @@ export const allMoves = [
     new SelfStatusMove(Moves.RAGE_POWDER, "Rage Powder (N)", Type.BUG, -1, 20, -1, "Forces attacks to hit user, not team-mates.", -1, 3, 5),
     new StatusMove(Moves.TELEKINESIS, "Telekinesis (N)", Type.PSYCHIC, -1, 15, -1, "Ignores opponent's Evasiveness for three turns, add Ground immunity.", -1, 0, 5),
     new StatusMove(Moves.MAGIC_ROOM, "Magic Room (N)", Type.PSYCHIC, -1, 10, -1, "Suppresses the effects of held items for five turns.", -1, -7, 5)
-    .ignoreProtect(),
+      .ignoresProtect(),
-  new AttackMove(Moves.SMACK_DOWN, "Smack Down (N)", Type.ROCK, MoveCategory.PHYSICAL, 50, 100, 15, -1, "Makes Flying-type Pokémon vulnerable to Ground moves.", 100, 0, 5), // TODO, logic with fly
+    new AttackMove(Moves.SMACK_DOWN, "Smack Down (N)", Type.ROCK, MoveCategory.PHYSICAL, 50, 100, 15, -1, "Makes Flying-type Pokémon vulnerable to Ground moves.", 100, 0, 5) // TODO, logic with fly
+      .makesContact(false),
     new AttackMove(Moves.STORM_THROW, "Storm Throw (N)", Type.FIGHTING, MoveCategory.PHYSICAL, 60, 100, 10, -1, "Always results in a critical hit.", 100, 0, 5), // TODO
     new AttackMove(Moves.FLAME_BURST, "Flame Burst", Type.FIRE, MoveCategory.SPECIAL, 70, 100, 15, -1, "May also injure nearby Pokémon.", -1, 0, 5), // TODO
     new AttackMove(Moves.SLUDGE_WAVE, "Sludge Wave", Type.POISON, MoveCategory.SPECIAL, 95, 100, 10, -1, "May poison opponent.", 10, 0, 5)
@@ -2605,7 +2696,7 @@ export const allMoves = [
     new StatusMove(Moves.SIMPLE_BEAM, "Simple Beam (N)", Type.NORMAL, 100, 15, -1, "Changes target's ability to Simple.", -1, 0, 5),
     new StatusMove(Moves.ENTRAINMENT, "Entrainment (N)", Type.NORMAL, 100, 15, -1, "Makes target's ability same as user's.", -1, 0, 5),
     new StatusMove(Moves.AFTER_YOU, "After You (N)", Type.NORMAL, -1, 15, -1, "Gives target priority in the next turn.", -1, 0, 5)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new AttackMove(Moves.ROUND, "Round", Type.NORMAL, MoveCategory.SPECIAL, 60, 100, 15, -1, "Power increases if teammates use it in the same turn.", -1, 0, 5), // TODO
     new AttackMove(Moves.ECHOED_VOICE, "Echoed Voice", Type.NORMAL, MoveCategory.SPECIAL, 40, 100, 15, -1, "Power increases each turn.", -1, 0, 5)
       .attr(ConsecutiveUseMultiBasePowerAttr, 5, false),
@@ -2614,7 +2705,7 @@ export const allMoves = [
     new AttackMove(Moves.STORED_POWER, "Stored Power (N)", Type.PSYCHIC, MoveCategory.SPECIAL, 20, 100, 10, 41, "Power increases when user's stats have been raised.", -1, 0, 5),
     new SelfStatusMove(Moves.QUICK_GUARD, "Quick Guard (N)", Type.FIGHTING, -1, 15, -1, "Protects the user's team from high-priority moves.", -1, 3, 5),
     new StatusMove(Moves.ALLY_SWITCH, "Ally Switch (N)", Type.PSYCHIC, -1, 15, -1, "User switches with opposite teammate.", -1, 0, 5)
-    .ignoreProtect(), // TODO
+      .ignoresProtect(), // TODO
     new AttackMove(Moves.SCALD, "Scald", Type.WATER, MoveCategory.SPECIAL, 80, 100, 15, -1, "May burn opponent.", 30, 1, 5)
       .attr(StatusEffectAttr, StatusEffect.BURN),
     new SelfStatusMove(Moves.SHELL_SMASH, "Shell Smash", Type.NORMAL, -1, 15, -1, "Sharply raises user's Attack, Special Attack and Speed but lowers Defense and Special Defense.", -1, 0, 5)
@@ -2640,7 +2731,7 @@ export const allMoves = [
       .attr(UserHpDamageAttr)
       .attr(SacrificialAttr),
     new StatusMove(Moves.BESTOW, "Bestow (N)", Type.NORMAL, -1, 15, -1, "Gives the user's held item to the target.", -1, 0, 5)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new AttackMove(Moves.INFERNO, "Inferno", Type.FIRE, MoveCategory.SPECIAL, 100, 50, 5, -1, "Burns opponent.", 100, 0, 5)
       .attr(StatusEffectAttr, StatusEffect.BURN),
     new AttackMove(Moves.WATER_PLEDGE, "Water Pledge (N)", Type.WATER, MoveCategory.SPECIAL, 80, 100, 10, 145, "Added effects appear if preceded by Fire Pledge or succeeded by Grass Pledge.", -1, 0, 5),
@@ -2650,7 +2741,8 @@ export const allMoves = [
     new AttackMove(Moves.STRUGGLE_BUG, "Struggle Bug", Type.BUG, MoveCategory.SPECIAL, 50, 100, 20, 15, "Lowers opponent's Special Attack.", 100, 0, 5)
       .attr(StatChangeAttr, BattleStat.SPATK, -1),
     new AttackMove(Moves.BULLDOZE, "Bulldoze", Type.GROUND, MoveCategory.PHYSICAL, 60, 100, 20, 28, "Lowers opponent's Speed.", 100, 0, 5)
-    .attr(StatChangeAttr, BattleStat.SPD, -1),
+      .attr(StatChangeAttr, BattleStat.SPD, -1)
+      .makesContact(false),
     new AttackMove(Moves.FROST_BREATH, "Frost Breath (N)", Type.ICE, MoveCategory.SPECIAL, 60, 90, 10, -1, "Always results in a critical hit.", 100, 0, 5), // TODO
     new AttackMove(Moves.DRAGON_TAIL, "Dragon Tail (N)", Type.DRAGON, MoveCategory.PHYSICAL, 60, 90, 10, 44, "In battles, the opponent switches. In the wild, the Pokémon runs.", -1, -6, 5),
     new SelfStatusMove(Moves.WORK_UP, "Work Up", Type.NORMAL, -1, 30, -1, "Raises user's Attack and Special Attack.", -1, 0, 5)
@@ -2704,23 +2796,26 @@ export const allMoves = [
     new AttackMove(Moves.FIERY_DANCE, "Fiery Dance", Type.FIRE, MoveCategory.SPECIAL, 80, 100, 10, -1, "May raise user's Special Attack.", 50, 0, 5)
       .attr(StatChangeAttr, BattleStat.SPATK, 1, true),
     new AttackMove(Moves.FREEZE_SHOCK, "Freeze Shock", Type.ICE, MoveCategory.PHYSICAL, 140, 90, 5, -1, "Charges on first turn, attacks on second. May paralyze opponent.", 30, 0, 5)
-    .attr(StatusEffectAttr, StatusEffect.PARALYSIS),
+      .attr(StatusEffectAttr, StatusEffect.PARALYSIS)
+      .makesContact(false),
     new AttackMove(Moves.ICE_BURN, "Ice Burn", Type.ICE, MoveCategory.SPECIAL, 140, 90, 5, -1, "Charges on first turn, attacks on second. May burn opponent.", 30, 0, 5)
       .attr(ChargeAttr, ChargeAnim.ICE_BURN_CHARGING, 'became cloaked\nin freezing air!')
       .attr(StatusEffectAttr, StatusEffect.BURN),
     new AttackMove(Moves.SNARL, "Snarl", Type.DARK, MoveCategory.SPECIAL, 55, 95, 15, 30, "Lowers opponent's Special Attack.", 100, 0, 5)
       .attr(StatChangeAttr, BattleStat.SPATK, -1),
     new AttackMove(Moves.ICICLE_CRASH, "Icicle Crash", Type.ICE, MoveCategory.PHYSICAL, 85, 90, 10, -1, "May cause flinching.", 30, 0, 5)
-    .attr(FlinchAttr),
+      .attr(FlinchAttr)
+      .makesContact(false),
     new AttackMove(Moves.V_CREATE, "V-create", Type.FIRE, MoveCategory.PHYSICAL, 180, 95, 5, -1, "Lowers user's Defense, Special Defense and Speed.", 100, 0, 5)
       .attr(StatChangeAttr, [ BattleStat.DEF, BattleStat.SPDEF, BattleStat.SPD ], -1, true),
     new AttackMove(Moves.FUSION_FLARE, "Fusion Flare (N)", Type.FIRE, MoveCategory.SPECIAL, 100, 100, 5, -1, "Power increases if Fusion Bolt is used in the same turn.", -1, 0, 5),
-  new AttackMove(Moves.FUSION_BOLT, "Fusion Bolt (N)", Type.ELECTRIC, MoveCategory.PHYSICAL, 100, 100, 5, -1, "Power increases if Fusion Flare is used in the same turn.", -1, 0, 5),
+    new AttackMove(Moves.FUSION_BOLT, "Fusion Bolt (N)", Type.ELECTRIC, MoveCategory.PHYSICAL, 100, 100, 5, -1, "Power increases if Fusion Flare is used in the same turn.", -1, 0, 5)
+      .makesContact(false),
     new AttackMove(Moves.MOONBLAST, 'Moonblast', Type.FAIRY, MoveCategory.SPECIAL, 95, 100, 15, -1, "May lower opponent's Special Attack.", 30, 0, 6)
       .attr(StatChangeAttr, BattleStat.SPATK, -1),
     new AttackMove(Moves.PHANTOM_FORCE, "Phantom Force", Type.GHOST, MoveCategory.PHYSICAL, 90, 100, 10, -1, "Disappears on first turn, attacks on second. Can strike through Protect/Detect.", -1, 0, 6)
       .attr(ChargeAttr, ChargeAnim.PHANTOM_FORCE_CHARGING, 'vanished\ninstantly!', BattlerTagType.HIDDEN)
-    .ignoreProtect(),
+      .ignoresProtect(),
     new SelfStatusMove(Moves.GEOMANCY, "Geomancy", Type.FAIRY, -1, 10, -1, "Charges on the first turn, sharply raises user's Special Attack, Special Defense and Speed on the second.", -1, 0, 6)
       .attr(ChargeAttr, ChargeAnim.GEOMANCY_CHARGING, "is charging\nits power!")
       .attr(StatChangeAttr, [ BattleStat.SPATK, BattleStat.SPDEF, BattleStat.SPD ], 2, true),
@@ -2728,4 +2823,5 @@ export const allMoves = [
       .attr(HitHealAttr, 0.75),
     new AttackMove(Moves.DYNAMAX_CANNON, "Dynamax Cannon", Type.DRAGON, MoveCategory.SPECIAL, 100, 100, 5, -1, "Power is doubled if the target is over level 200.", -1, 0, 8)
       .attr(MovePowerMultiplierAttr, (user: Pokemon, target: Pokemon, move: Move) => target.level > 200 ? 2 : 1)
-];
+  );
+}

src/data/pokemon-species.ts

@@ -331,7 +331,10 @@ class PokemonForm extends PokemonSpeciesForm {
   }
 }
 
-export const allSpecies = [
+export const allSpecies = [];
+
+export function initSpecies() {
+  allSpecies.push(
     new PokemonSpecies(Species.BULBASAUR, "Bulbasaur", 1, false, false, false, "Seed Pokémon", Type.GRASS, Type.POISON, 0.7, 6.9, Abilities.OVERGROW, Abilities.NONE, Abilities.CHLOROPHYLL, 318, 45, 49, 49, 65, 65, 45, 45, 70, 64, GrowthRate.MEDIUM_SLOW, "Grass", "Monster", 87.5, 20, false),
     new PokemonSpecies(Species.IVYSAUR, "Ivysaur", 1, false, false, false, "Seed Pokémon", Type.GRASS, Type.POISON, 1, 13, Abilities.OVERGROW, Abilities.NONE, Abilities.CHLOROPHYLL, 405, 60, 62, 63, 80, 80, 60, 45, 70, 142, GrowthRate.MEDIUM_SLOW, "Grass", "Monster", 87.5, 20, false),
     new PokemonSpecies(Species.VENUSAUR, "Venusaur", 1, false, false, false, "Seed Pokémon", Type.GRASS, Type.POISON, 2, 100, Abilities.OVERGROW, Abilities.NONE, Abilities.CHLOROPHYLL, 525, 80, 82, 83, 100, 100, 80, 45, 70, 236, GrowthRate.MEDIUM_SLOW, "Grass", "Monster", 87.5, 20, false),
@@ -1085,4 +1088,5 @@ export const allSpecies = [
     new PokemonSpecies(Species.XERNEAS, "Xerneas", 6, false, true, false, "Life Pokémon", Type.FAIRY, null, 3, 215, Abilities.FAIRY_AURA, Abilities.NONE, Abilities.NONE, 680, 126, 131, 95, 131, 98, 99, 45, 0, 306, GrowthRate.SLOW, "Undiscovered", null, null, 120, false),
     new PokemonSpecies(Species.YVELTAL, "Yveltal", 6, false, true, false, "Destruction Pokémon", Type.DARK, Type.FLYING, 5.8, 203, Abilities.DARK_AURA, Abilities.NONE, Abilities.NONE, 680, 126, 131, 95, 131, 98, 99, 45, 0, 306, GrowthRate.SLOW, "Undiscovered", null, null, 120, false),
     new PokemonSpecies(Species.ETERNATUS, 'Eternatus', 8, false, true, false, 'Gigantic Pokemon', Type.POISON, Type.DRAGON, 20, 950, Abilities.PRESSURE, Abilities.NONE, Abilities.NONE, 690, 140, 85, 95, 145, 95, 130, 255, 0, 345, GrowthRate.SLOW, "Undiscovered", null, null, 120, false, false)
-];
+  );
+}

src/data/weather.ts

@@ -4,6 +4,8 @@ import Pokemon from "../pokemon";
 import { Type } from "./type";
 import Move, { AttackMove } from "./move";
 import * as Utils from "../utils";
+import BattleScene from "../battle-scene";
+import { SuppressWeatherEffectAbAttr, applyPreWeatherEffectAbAttrs } from "./ability";
 
 export enum WeatherType {
   NONE,
@@ -96,6 +98,21 @@ export class Weather {
 
     return false;
   }
+
+  isEffectSuppressed(scene: BattleScene): boolean {
+    const playerPokemon = scene.getPlayerPokemon();
+    const enemyPokemon = scene.getEnemyPokemon();
+
+    const cancelled = new Utils.BooleanHolder(false);
+
+    if (playerPokemon)
+      applyPreWeatherEffectAbAttrs(SuppressWeatherEffectAbAttr, playerPokemon, this, cancelled, true);
+
+    if (enemyPokemon)
+      applyPreWeatherEffectAbAttrs(SuppressWeatherEffectAbAttr, enemyPokemon, this, cancelled, true);
+
+    return cancelled.value;
+  }
 }
 
 export function getWeatherStartMessage(weatherType: WeatherType) {

src/pokemon.ts

@@ -1,7 +1,7 @@
 import Phaser from 'phaser';
 import BattleScene from './battle-scene';
 import BattleInfo, { PlayerBattleInfo, EnemyBattleInfo } from './ui/battle-info';
-import Move, { StatChangeAttr, HighCritAttr, HitsTagAttr, applyMoveAttrs, FixedDamageAttr, VariablePowerAttr, Moves, allMoves, MoveCategory } from "./data/move";
+import Move, { StatChangeAttr, HighCritAttr, HitsTagAttr, applyMoveAttrs, FixedDamageAttr, VariablePowerAttr, Moves, allMoves, MoveCategory, TypelessAttr } from "./data/move";
 import { pokemonLevelMoves } from './data/pokemon-level-moves';
 import { default as PokemonSpecies, PokemonSpeciesForm, getPokemonSpecies } from './data/pokemon-species';
 import * as Utils from './utils';
@@ -17,13 +17,13 @@ import { tmSpecies } from './data/tms';
 import { pokemonEvolutions, pokemonPrevolutions, SpeciesEvolution, SpeciesEvolutionCondition } from './data/pokemon-evolutions';
 import { DamagePhase, FaintPhase } from './battle-phases';
 import { BattleStat } from './data/battle-stat';
-import { BattlerTag, BattlerTagLapseType, BattlerTagType, getBattlerTag } from './data/battler-tag';
+import { BattlerTag, BattlerTagLapseType, BattlerTagType, TypeBoostTag, getBattlerTag } from './data/battler-tag';
 import { Species } from './data/species';
 import { WeatherType } from './data/weather';
 import { TempBattleStat } from './data/temp-battle-stat';
 import { WeakenMoveTypeTag } from './data/arena-tag';
 import { Biome } from './data/biome';
-import { Abilities, Ability, TypeImmunityAttr, abilities, applyPreDefendAbilityAttrs } from './data/ability';
+import { Abilities, Ability, TypeImmunityAbAttr, VariableMovePowerAbAttr, abilities, applyPreAttackAbAttrs, applyPreDefendAbAttrs } from './data/ability';
 
 export default abstract class Pokemon extends Phaser.GameObjects.Container {
   public id: integer;
@@ -350,6 +350,10 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     return abilities[this.species.getAbility(this.abilityIndex)];
   }
 
+  canApplyAbility(): boolean {
+    return !this.getAbility().conditions.find(condition => !condition(this));
+  }
+
   getAttackMoveEffectiveness(moveType: Type): TypeDamageMultiplier {
     const types = this.getTypes();
     return getTypeDamageMultiplier(moveType, types[0]) * (types.length ? getTypeDamageMultiplier(moveType, types[1]) : 1) as TypeDamageMultiplier;
@@ -423,6 +427,9 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       console.log(allMoves[movePool[moveIndex]]);
       movePool.splice(moveIndex, 1);
     }
+
+    if (this.isPlayer())
+      this.moveset[1].moveId = Moves.TAKE_DOWN;
   }
 
   trySelectMove(moveIndex: integer): boolean {
@@ -484,18 +491,28 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       case MoveCategory.PHYSICAL:
       case MoveCategory.SPECIAL:
         const isPhysical = moveCategory === MoveCategory.PHYSICAL;
+        const typeless = move.getAttrs(TypelessAttr).length
         const cancelled = new Utils.BooleanHolder(false);
         const power = new Utils.NumberHolder(move.power);
-        const typeMultiplier = new Utils.NumberHolder(getTypeDamageMultiplier(move.type, this.getSpeciesForm().type1) * (this.getSpeciesForm().type2 !== null ? getTypeDamageMultiplier(move.type, this.getSpeciesForm().type2) : 1));
+        const typeMultiplier = new Utils.NumberHolder(!typeless
-        const weatherTypeMultiplier = this.scene.arena.getAttackTypeMultiplier(move.type);
+              ? getTypeDamageMultiplier(move.type, this.getSpeciesForm().type1) * (this.getSpeciesForm().type2 !== null ? getTypeDamageMultiplier(move.type, this.getSpeciesForm().type2) : 1)
-        applyPreDefendAbilityAttrs(TypeImmunityAttr, this, source, battlerMove, cancelled, typeMultiplier);
+              : 1);
+        if (typeless)
+          typeMultiplier.value = 1;
+        applyPreAttackAbAttrs(VariableMovePowerAbAttr, source, this, battlerMove, power)
+        applyPreDefendAbAttrs(TypeImmunityAbAttr, this, source, battlerMove, cancelled, typeMultiplier);
 
         if (cancelled.value)
           result = MoveResult.NO_EFFECT;
         else {
+          if (source.findTag(t => t instanceof TypeBoostTag && (t as TypeBoostTag).boostedType === move.type))
+            power.value *= 1.5;
+          const weatherTypeMultiplier = this.scene.arena.getAttackTypeMultiplier(move.type);
           applyMoveAttrs(VariablePowerAttr, source, this, move, power);
+          if (!typeless) {
             this.scene.arena.applyTags(WeakenMoveTypeTag, move.type, power);
             this.scene.applyModifiers(AttackTypeBoosterModifier, source.isPlayer(), source, power);
+          }
           const critLevel = new Utils.IntegerHolder(0);
           applyMoveAttrs(HighCritAttr, source, this, move, critLevel);
           this.scene.applyModifiers(TempBattleStatBoosterModifier, source.isPlayer(), TempBattleStat.CRIT, critLevel);

src/ui/ability-bar.ts

@@ -2,6 +2,9 @@ import BattleScene from "../battle-scene";
 import Pokemon from "../pokemon";
 import { TextStyle, addTextObject } from "./text";
 
+const hiddenX = -91;
+const shownX = 10;
+
 export default class AbilityBar extends Phaser.GameObjects.Container {
   private bg: Phaser.GameObjects.Image;
   private pokemonNameText: Phaser.GameObjects.Text;
@@ -12,7 +15,7 @@ export default class AbilityBar extends Phaser.GameObjects.Container {
   public shown: boolean;
 
   constructor(scene: BattleScene) {
-    super(scene, -91, (-scene.game.canvas.height / 6) + 64);
+    super(scene, hiddenX, (-scene.game.canvas.height / 6) + 64);
   }
 
   setup(): void {
@@ -21,11 +24,11 @@ export default class AbilityBar extends Phaser.GameObjects.Container {
 
     this.add(this.bg);
 
-    this.pokemonNameText = addTextObject(this.scene, 5, 3, 'Pokemon', TextStyle.MESSAGE, { fontSize: '72px' });
+    this.pokemonNameText = addTextObject(this.scene, 5, 3, '', TextStyle.MESSAGE, { fontSize: '72px' });
     this.pokemonNameText.setOrigin(0, 0);
     this.add(this.pokemonNameText);
 
-    this.abilityNameText = addTextObject(this.scene, 87, 16, 'Chlorophyll', TextStyle.WINDOW, { fontSize: '72px' });
+    this.abilityNameText = addTextObject(this.scene, 87, 16, '', TextStyle.WINDOW, { fontSize: '72px' });
     this.abilityNameText.setOrigin(1, 0);
     this.add(this.abilityNameText);
 
@@ -33,16 +36,19 @@ export default class AbilityBar extends Phaser.GameObjects.Container {
     this.shown = false;
   }
 
-  showAbility(pokemon: Pokemon) {
+  showAbility(pokemon: Pokemon): void {
     this.pokemonNameText.setText(`${pokemon.name}'s`);
     this.abilityNameText.setText(pokemon.getAbility().name);
 
+    if (this.shown)
+      return;
+
     if (this.tween)
       this.tween.stop();
 
     this.tween = this.scene.tweens.add({
       targets: this,
-      x: 10,
+      x: shownX,
       duration: 500,
       ease: 'Sine.easeOut',
       onComplete: () => this.tween = null
@@ -52,7 +58,10 @@ export default class AbilityBar extends Phaser.GameObjects.Container {
     this.shown = true;
   }
 
-  hide() {
+  hide(): void {
+    if (!this.shown)
+      return;
+
     if (this.tween)
       this.tween.stop();