Add base logic for enemy buff modifiers

src/modifier/modifier-type.ts

@@ -660,6 +660,9 @@ export const modifierTypes = {
   
   GOLDEN_POKEBALL: () => new ModifierType(`Golden ${getPokeballName(PokeballType.POKEBALL)}`, 'Adds 1 extra item option at the end of every battle',
     (type, _args) => new Modifiers.ExtraModifierModifier(type), 'pb_gold', null, 'pb_bounce_1'),
+
+  ENEMY_DAMAGE_BOOSTER: () => new ModifierType('Damage Booster', 'Increases damage by 20%', (type, _args) => new Modifiers.EnemyDamageBoosterModifier(type), 'wl_item_drop'),
+  ENEMY_DAMAGE_REDUCTION: () => new ModifierType('Damage Reducer', 'Reduces incoming damage by 10%', (type, _args) => new Modifiers.EnemyDamageReducerModifier(type), 'wl_guard_spec')
 };
 
 const modifierPool = {
@@ -797,6 +800,13 @@ const trainerModifierPool = {
   ].map(m => { m.setTier(ModifierTier.MASTER); return m; })
 };
 
+export function getModifierType(modifierTypeFunc: ModifierTypeFunc): ModifierType {
+  const modifierType = modifierTypeFunc();
+  if (!modifierType.id)
+    modifierType.id = Object.keys(modifierTypes).find(k => modifierTypes[k] === modifierTypeFunc);
+  return modifierType;
+}
+
 let modifierPoolThresholds = {};
 let ignoredPoolIndexes = {};
 
@@ -860,11 +870,8 @@ export function getPlayerModifierTypeOptionsForWave(waveIndex: integer, count: i
 
 export function getEnemyModifierTypesForWave(waveIndex: integer, count: integer, party: EnemyPokemon[], poolType: ModifierPoolType.WILD | ModifierPoolType.TRAINER, gameMode: GameMode): PokemonHeldItemModifierType[] {
   const ret = new Array(count).fill(0).map(() => getNewModifierTypeOption(party, poolType).type as PokemonHeldItemModifierType);
-  if ((gameMode === GameMode.CLASSIC && waveIndex === 200) || !(waveIndex % 1000)) {
-    const miniBlackHole = modifierTypes.MINI_BLACK_HOLE();
-    miniBlackHole.id = 'MINI_BLACK_HOLE';
-    ret.push(miniBlackHole);
-  }
+  if ((gameMode === GameMode.CLASSIC && waveIndex === 200) || !(waveIndex % 1000))
+    ret.push(getModifierType(modifierTypes.MINI_BLACK_HOLE) as PokemonHeldItemModifierType);
   return ret;
 }
 

src/modifier/modifier.ts

@@ -1,5 +1,5 @@
 import * as ModifierTypes from './modifier-type';
-import { LearnMovePhase, LevelUpPhase, PokemonHealPhase } from "../battle-phases";
+import { LearnMovePhase, LevelUpPhase, ObtainStatusEffectPhase, PokemonHealPhase } from "../battle-phases";
 import BattleScene from "../battle-scene";
 import { getLevelTotalExp } from "../data/exp";
 import { PokeballType } from "../data/pokeball";
@@ -15,6 +15,7 @@ import { TempBattleStat } from '../data/temp-battle-stat';
 import { BerryType, getBerryEffectFunc, getBerryPredicate } from '../data/berry';
 import { Species } from '../data/species';
 import { BattleType } from '../battle';
+import { StatusEffect } from '../data/status-effect';
 
 type ModifierType = ModifierTypes.ModifierType;
 export type ModifierPredicate = (modifier: Modifier) => boolean;
@@ -1224,4 +1225,88 @@ export class ExtraModifierModifier extends PersistentModifier {
   getMaxStackCount(): integer {
     return 3;
   }
+}
+
+export abstract class EnemyPersistentModifer extends PersistentModifier {
+  constructor(type: ModifierType, stackCount?: integer) {
+    super(type, stackCount);
+  }
+}
+
+export class EnemyDamageBoosterModifier extends EnemyPersistentModifer {
+  constructor(type: ModifierType, stackCount?: integer) {
+    super(type, stackCount);
+  }
+
+  match(modifier: Modifier): boolean {
+    return modifier instanceof EnemyDamageBoosterModifier;
+  }
+
+  clone(): EnemyDamageBoosterModifier {
+    return new EnemyDamageBoosterModifier(this.type, this.stackCount);
+  }
+
+  apply(args: any[]): boolean {
+    (args[0] as Utils.NumberHolder).value = Math.floor((args[0] as Utils.NumberHolder).value * (1 + 0.2 * this.getStackCount()));
+
+    return true;
+  }
+
+  getMaxStackCount(): number {
+    return 5;
+  }
+}
+
+export class EnemyDamageReducerModifier extends EnemyPersistentModifer {
+  constructor(type: ModifierType, stackCount?: integer) {
+    super(type, stackCount);
+  }
+
+  match(modifier: Modifier): boolean {
+    return modifier instanceof EnemyDamageReducerModifier;
+  }
+
+  clone(): EnemyDamageReducerModifier {
+    return new EnemyDamageReducerModifier(this.type, this.stackCount);
+  }
+
+  apply(args: any[]): boolean {
+    (args[0] as Utils.NumberHolder).value = Math.floor((args[0] as Utils.NumberHolder).value * (1 - 0.2 * this.getStackCount()));
+
+    return true;
+  }
+
+  getMaxStackCount(): number {
+    return 5;
+  }
+}
+
+export class EnemyAttackStatusEffectChanceModifier extends EnemyPersistentModifer {
+  public effect: StatusEffect;
+
+  constructor(type: ModifierType, effect: StatusEffect, stackCount?: integer) {
+    super(type, stackCount);
+
+    this.effect = effect;
+  }
+
+  match(modifier: Modifier): boolean {
+    return modifier instanceof EnemyAttackStatusEffectChanceModifier && modifier.effect === this.effect;
+  }
+
+  clone(): EnemyDamageReducerModifier {
+    return new EnemyAttackStatusEffectChanceModifier(this.type, this.effect, this.stackCount);
+  }
+
+  apply(args: any[]): boolean {
+    const target = (args[0] as Pokemon);
+    if (Utils.randInt(10) < this.getStackCount())
+      target.scene.unshiftPhase(new ObtainStatusEffectPhase(target.scene, target.getBattlerIndex(), this.effect));
+
+    return true;
+  }
+
+  getMaxStackCount(): number {
+    return 5;
+  }
 }