Big rebalance

changelog.md

@@ -19,14 +19,20 @@
 - Improved Spawning
   - Overhauled spawning engine so it hopefully crashes less
   - Greatly improved managing which channels Pokemon spawn in
+- Big combat rebalance
+  - Balance pass over most moves and abilities
+    - Lowered many cooldowns
+    - Buffed most basic moves
+    - Made many stat-affecting effects last longer
+    - Made many status moves and abilites more powerful
+  - Reworked sleep: wake up when taking direct damage but take more damage
+  - Targetting back rows deals less damage
+  - Super effective attacks deal more damage
+  - Add X target pattern shape
 
 TODO:
 
 - User profile sharing
-- Balancing
-  - Move & ability rework
-  - Not front row penalty
-  - Move first penalty?
 - Stretch: Achievements
 - Stretch: New event
 - Stretch: Analytics

src/battle/data/effects.js

@@ -1,6 +1,8 @@
 /* eslint-disable no-param-reassign */
 const { effectTypes } = require("../../config/battleConfig");
-const { effectIdEnum } = require("../../enums/battleEnums");
+const { effectIdEnum, battleEventEnum } = require("../../enums/battleEnums");
+const { getIsTargetPokemonCallback } = require("../engine/eventConditions");
+const { getEffect } = require("./effectRegistry");
 
 /**
  * @template T
@@ -94,6 +96,40 @@ const effectsToRegister = Object.freeze({
       battle.addToLog(`${target.name}'s shield was removed!`);
     },
   }),
+  [effectIdEnum.DEBUFF_IMMUNITY]: new Effect({
+    id: effectIdEnum.DEBUFF_IMMUNITY,
+    name: "Debuff Immunity",
+    description: "The target is immune to debuffs.",
+    type: effectTypes.BUFF,
+    dispellable: true,
+    /**
+     * @param {EffectAddBasicArgs & {initialArgs: any}} args
+     */
+    effectAdd({ battle, target }) {
+      battle.addToLog(`${target.name} is immune to debuffs!`);
+      return {
+        listenerId: battle.registerListenerFunction({
+          eventName: battleEventEnum.BEFORE_EFFECT_ADD,
+          callback: (eventArgs) => {
+            const effect = getEffect(eventArgs.effectId);
+            if (effect.type !== effectTypes.DEBUFF || effect.dispellable) {
+              return;
+            }
+
+            eventArgs.canAdd = false;
+            battle.addToLog(
+              `${target.name} is immune to debuffs and cannot be affected by ${effect.name}!`
+            );
+          },
+          conditionCallback: getIsTargetPokemonCallback(target),
+        }),
+      };
+    },
+    effectRemove({ battle, target, properties }) {
+      battle.addToLog(`${target.name} is no longer immune to debuffs!`);
+      battle.unregisterListener(properties.listenerId);
+    },
+  }),
 });
 
 module.exports = {

src/battle/data/moves.js

@@ -113,7 +113,7 @@ const movesToRegister = Object.freeze({
     id: moveIdEnum.VINE_WHIP,
     name: "Vine Whip",
     type: pokemonTypes.GRASS,
-    power: 55,
+    power: 60,
     accuracy: 100,
     cooldown: 0,
     targetType: targetTypes.ENEMY,

src/battle/engine/Battle.js

@@ -757,6 +757,13 @@ class Battle {
     return eligibleTargets;
   }
 
+  /**
+   * @param {BattlePokemon} pokemon
+   */
+  getPartyForPokemon(pokemon) {
+    return this.parties[pokemon.teamName];
+  }
+
   /**
    * TODO: move to pokemon
    * @param {BattlePokemon} pokemon

src/battle/engine/BattlePokemon.js

@@ -450,6 +450,7 @@ class BattlePokemon {
    * @param {PokemonTypeEnum=} param0.moveTypeOverride
    * @param {number=} param0.offTargetDamageMultiplier
    * @param {number=} param0.missedTargetDamageMultiplier
+   * @param {number=} param0.backTargetDamageMultiplier
    * @returns {number}
    */
   calculateMoveDamage({
@@ -467,7 +468,7 @@ class BattlePokemon {
     typeEffectivenessOverride = null,
     moveTypeOverride = null,
     offTargetDamageMultiplier = 0.8,
-    // eslint-disable-next-line no-unused-vars
+    backTargetDamageMultiplier = 0.8,
     missedTargetDamageMultiplier = 0.7,
   }) {
     const power = powerOverride || move.power;
@@ -486,7 +487,9 @@ class BattlePokemon {
         ? target.getDef()
         : target.getSpd());
     const stab = this.type1 === move.type || this.type2 === move.type ? 1.5 : 1;
-    const missMult = missedTargets.includes(target) ? 0.7 : 1;
+    const missMult = missedTargets.includes(target)
+      ? missedTargetDamageMultiplier
+      : 1;
     const moveType = moveTypeOverride || move.type;
     const typeEffectiveness =
       typeEffectivenessOverride !== null
@@ -495,9 +498,9 @@ class BattlePokemon {
     // balance type
     let typeMultiplier = 1;
     if (typeEffectiveness >= 4) {
-      typeMultiplier = 2;
+      typeMultiplier = 2.5;
     } else if (typeEffectiveness >= 2) {
-      typeMultiplier = 1.5;
+      typeMultiplier = 1.75;
     } else if (typeEffectiveness >= 1) {
       typeMultiplier = 1;
     } else if (typeEffectiveness >= 0.5) {
@@ -531,6 +534,28 @@ class BattlePokemon {
     const maybeOffTargetMult =
       target === primaryTarget ? 1 : offTargetDamageMultiplier;
 
+    let isBackTarget = false;
+    // iterate through all rows in front of target. If there is a targetable pokemon, set isBackTarget to true
+    const targetParty = this.battle.getPartyForPokemon(target);
+    const partyPokemons = targetParty.pokemons;
+    const targetRowNum = Math.floor((target.position - 1) / targetParty.cols);
+    for (let i = 0; i < targetRowNum; i += 1) {
+      const row = partyPokemons.slice(
+        i * targetParty.cols,
+        (i + 1) * targetParty.cols
+      );
+      for (const pokemon of row) {
+        if (this.battle.isPokemonTargetable(pokemon, move.id)) {
+          isBackTarget = true;
+          break;
+        }
+      }
+    }
+    const maybeBackTargetMult =
+      isBackTarget && move.targetPosition !== targetPositions.BACK
+        ? backTargetDamageMultiplier
+        : 1;
+
     /* console.log("power", power)
       console.log("level", level)
       console.log("attack", attack)
@@ -547,7 +572,8 @@ class BattlePokemon {
         burn *
         weatherMult *
         missMult *
-        maybeOffTargetMult
+        maybeOffTargetMult *
+        maybeBackTargetMult
     );
 
     return Math.max(damage, 1);
@@ -585,8 +611,8 @@ class BattlePokemon {
           }
           break;
         case statusConditions.SLEEP:
-          // sleep wakeup chance: 0 turns: 0%, 1 turn: 66%, 2 turns: 100%
-          const wakeupChance = this.status.turns * 0.66;
+          // sleep wakeup chance: 0 turns: 0%, 1 turn: 33%, 2 turns: 66%, 3 turns: 100%
+          const wakeupChance = this.status.turns * 0.33;
           const wakeupRoll = Math.random();
           if (wakeupRoll < wakeupChance) {
             this.removeStatus();
@@ -663,7 +689,7 @@ class BattlePokemon {
       multiplier: mult,
     };
     this.battle.eventHandler.emit(
-      battleEventEnum.CALCULATE_TYPE_MULTIPLIER,
+      battleEventEnum.CALCULATE_TYPE_MULTIPLIER, // This maybe shouldn't be an event. Code run by the NPC should not have possible side-effects
       eventArgs
     );
 
@@ -987,6 +1013,20 @@ class BattlePokemon {
     if (freezeCheck) {
       if (this.removeStatus()) {
         damage = Math.floor(damage * 1.5);
+        this.battle.addToLog(
+          `${this.name} Took extra damage because it was frozen!`
+        );
+      }
+    }
+
+    // if sleep and hit with a move, wake up and deal 1.5x damage
+    const sleepCheck =
+      this.status.statusId === statusConditions.SLEEP &&
+      damageInfo.type === "move";
+    if (sleepCheck) {
+      if (this.removeStatus()) {
+        damage = Math.floor(damage * 1.5);
+        this.battle.addToLog(`${this.name} Took extra damage while sleeping!`);
       }
     }
 

src/battle/engine/eventConditions.js

@@ -5,6 +5,13 @@
 const getIsActivePokemonCallback = (battle, pokemon) => () =>
   battle.activePokemon === pokemon;
 
+/**
+ * @param {BattlePokemon} pokemon
+ */
+const getIsTargetPokemonCallback = (pokemon) => (eventArgs) =>
+  eventArgs?.target === pokemon;
+
 module.exports = {
   getIsActivePokemonCallback,
+  getIsTargetPokemonCallback,
 };

src/battle/engine/events.js

@@ -63,6 +63,12 @@ class BattleEventHandler {
           listener.conditionCallback(fullArgs)
         ) {
           listener.execute(fullArgs);
+          // updates args with new values
+          // TODO: do immutable event handling... someday
+          // Sorry for the hack folks this is too much for me to fix ATM
+          for (const key in args || {}) {
+            args[key] = fullArgs[key];
+          }
         }
       } else {
         listener.execute(listener.initialArgs, args);