dist/data/mods/gen2/conditions.js

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var conditions_exports = {};
__export(conditions_exports, {
  Conditions: () => Conditions
});
module.exports = __toCommonJS(conditions_exports);
const Conditions = {
  brn: {
    name: "brn",
    effectType: "Status",
    onStart(target) {
      this.add("-status", target, "brn");
    },
    onAfterMoveSelfPriority: 3,
    onAfterMoveSelf(pokemon) {
      residualdmg(this, pokemon);
    },
    onAfterSwitchInSelf(pokemon) {
      residualdmg(this, pokemon);
    }
  },
  par: {
    name: "par",
    inherit: true,
    onBeforeMovePriority: 2,
    onBeforeMove(pokemon) {
      if (this.randomChance(1, 4)) {
        this.add("cant", pokemon, "par");
        return false;
      }
    }
  },
  slp: {
    name: "slp",
    effectType: "Status",
    onStart(target, source, sourceEffect) {
      if (sourceEffect && sourceEffect.effectType === "Move") {
        this.add("-status", target, "slp", `[from] move: ${sourceEffect.name}`);
      } else {
        this.add("-status", target, "slp");
      }
      this.effectState.time = this.random(2, 8);
      if (target.removeVolatile("nightmare")) {
        this.add("-end", target, "Nightmare", "[silent]");
      }
    },
    onBeforeMovePriority: 10,
    onBeforeMove(pokemon, target, move) {
      pokemon.statusState.time--;
      if (pokemon.statusState.time <= 0) {
        pokemon.cureStatus();
        return;
      }
      this.add("cant", pokemon, "slp");
      if (move.sleepUsable) {
        return;
      }
      return false;
    }
  },
  frz: {
    name: "frz",
    inherit: true,
    onBeforeMove(pokemon, target, move) {
      if (move.flags["defrost"])
        return;
      this.add("cant", pokemon, "frz");
      return false;
    },
    onModifyMove() {
    },
    onDamagingHit() {
    },
    onAfterMoveSecondary(target, source, move) {
      if (move.secondary && move.secondary.status === "brn" || move.statusRoll === "brn") {
        target.cureStatus();
      }
    },
    onAfterMoveSecondarySelf(pokemon, target, move) {
      if (move.flags["defrost"])
        pokemon.cureStatus();
    },
    onResidualOrder: 7,
    onResidual(pokemon) {
      if (this.randomChance(25, 256))
        pokemon.cureStatus();
    }
  },
  psn: {
    name: "psn",
    effectType: "Status",
    onStart(target) {
      this.add("-status", target, "psn");
    },
    onAfterMoveSelfPriority: 3,
    onAfterMoveSelf(pokemon) {
      residualdmg(this, pokemon);
    },
    onAfterSwitchInSelf(pokemon) {
      residualdmg(this, pokemon);
    }
  },
  tox: {
    name: "tox",
    effectType: "Status",
    onStart(target) {
      this.add("-status", target, "tox");
      if (!target.volatiles["residualdmg"])
        target.addVolatile("residualdmg");
      target.volatiles["residualdmg"].counter = 0;
    },
    onAfterMoveSelfPriority: 3,
    onAfterMoveSelf(pokemon) {
      const damage = this.clampIntRange(Math.floor(pokemon.maxhp / 16), 1) * pokemon.volatiles["residualdmg"].counter;
      this.damage(damage, pokemon, pokemon);
    },
    onSwitchIn(pokemon) {
      pokemon.status = "psn";
      this.add("-status", pokemon, "psn", "[silent]");
    },
    onAfterSwitchInSelf(pokemon) {
      this.damage(this.clampIntRange(Math.floor(pokemon.maxhp / 16), 1));
    }
  },
  confusion: {
    inherit: true,
    onStart(target, source, sourceEffect) {
      if (sourceEffect && sourceEffect.id === "lockedmove") {
        this.add("-start", target, "confusion", "[silent]");
      } else {
        this.add("-start", target, "confusion");
      }
      if (sourceEffect && sourceEffect.id === "berserkgene") {
        this.effectState.time = 256;
      } else {
        this.effectState.time = this.random(2, 6);
      }
    },
    onBeforeMove(pokemon, target, move) {
      pokemon.volatiles["confusion"].time--;
      if (!pokemon.volatiles["confusion"].time) {
        pokemon.removeVolatile("confusion");
        return;
      }
      this.add("-activate", pokemon, "confusion");
      if (this.randomChance(1, 2)) {
        return;
      }
      move = {
        basePower: 40,
        type: "???",
        baseMoveType: move.type,
        category: "Physical",
        willCrit: false,
        isConfusionSelfHit: true,
        noDamageVariance: true,
        flags: {},
        selfdestruct: move.selfdestruct
      };
      const damage = this.actions.getDamage(pokemon, pokemon, move);
      if (typeof damage !== "number")
        throw new Error("Confusion damage not dealt");
      this.directDamage(damage);
      return false;
    }
  },
  partiallytrapped: {
    inherit: true,
    durationCallback(target, source) {
      return this.random(3, 6);
    },
    onResidualOrder: 3,
    onResidualSubOrder: 1
  },
  lockedmove: {
    name: "lockedmove",
    // Outrage, Thrash, Petal Dance...
    durationCallback() {
      return this.random(2, 4);
    },
    onResidual(target) {
      if (target.lastMove && target.lastMove.id === "struggle" || target.status === "slp") {
        delete target.volatiles["lockedmove"];
      }
    },
    onStart(target, source, effect) {
      this.effectState.move = effect.id;
    },
    onEnd(target) {
      delete target.volatiles["confusion"];
      if (!target.side.getSideCondition("safeguard"))
        target.addVolatile("confusion");
    },
    onLockMove(pokemon) {
      return this.effectState.move;
    },
    onMoveAborted(pokemon) {
      delete pokemon.volatiles["lockedmove"];
    },
    onBeforeTurn(pokemon) {
      const move = this.dex.moves.get(this.effectState.move);
      if (move.id) {
        this.debug("Forcing into " + move.id);
        this.queue.changeAction(pokemon, { choice: "move", moveid: move.id });
      }
    }
  },
  futuremove: {
    inherit: true,
    onResidualOrder: 1
  },
  raindance: {
    inherit: true,
    onFieldResidualOrder: 2
  },
  sunnyday: {
    inherit: true,
    onFieldResidualOrder: 2
  },
  sandstorm: {
    inherit: true,
    onFieldResidualOrder: 2,
    onWeather(target) {
      this.damage(target.baseMaxhp / 8);
    }
  },
  stall: {
    name: "stall",
    duration: 2,
    onStart() {
      this.effectState.counter = 127;
    },
    onStallMove() {
      const counter = Math.floor(this.effectState.counter) || 127;
      this.debug(`Success chance: ${Math.round(counter * 1e3 / 255) / 10}% (${counter}/255)`);
      return this.randomChance(counter, 255);
    },
    onRestart() {
      this.effectState.counter /= 2;
      this.effectState.duration = 2;
    }
  },
  residualdmg: {
    name: "residualdmg",
    onStart(target) {
      target.volatiles["residualdmg"].counter = 0;
    },
    onAfterMoveSelfPriority: 100,
    onAfterMoveSelf(pokemon) {
      if (["brn", "psn", "tox"].includes(pokemon.status))
        pokemon.volatiles["residualdmg"].counter++;
    },
    onAfterSwitchInSelf(pokemon) {
      if (["brn", "psn", "tox"].includes(pokemon.status))
        pokemon.volatiles["residualdmg"].counter++;
    }
  }
};
function residualdmg(battle, pokemon) {
  if (pokemon.volatiles["residualdmg"]) {
    const residualDmg = battle.clampIntRange(
      Math.floor(pokemon.maxhp / 16) * pokemon.volatiles["residualdmg"].counter,
      1
    );
    battle.damage(residualDmg, pokemon);
    battle.hint("In Gen 2, Toxic's counter is retained through Baton Pass/Heal Bell and applies to PSN/BRN.", true);
  } else {
    battle.damage(battle.clampIntRange(Math.floor(pokemon.maxhp / 8), 1), pokemon);
  }
}
//# sourceMappingURL=conditions.js.map