@pkmn/sim 0.7.58 → 0.7.59

package/build/types/sim/battle-actions.d.ts

@@ -0,0 +1,90 @@
+import { ActiveMove, Battle, Effect, ModdedDex, Move, Pokemon, Side, SpreadMoveDamage, SpreadMoveTargets, ZMoveOptions } from './exported-global-types';
+import { Dex } from './dex';
+export declare class BattleActions {
+    battle: Battle;
+    dex: ModdedDex;
+    readonly MAX_MOVES: {
+        readonly [k: string]: string;
+    };
+    readonly Z_MOVES: {
+        readonly [k: string]: string;
+    };
+    constructor(battle: Battle);
+    switchIn(pokemon: Pokemon, pos: number, sourceEffect?: Effect | null, isDrag?: boolean): boolean | "pursuitfaint";
+    dragIn(side: Side, pos: number): boolean;
+    runSwitch(pokemon: Pokemon): boolean;
+    /**
+     * runMove is the "outside" move caller. It handles deducting PP,
+     * flinching, full paralysis, etc. All the stuff up to and including
+     * the "POKEMON used MOVE" message.
+     *
+     * For details of the difference between runMove and useMove, see
+     * useMove's info.
+     *
+     * externalMove skips LockMove and PP deduction, mostly for use by
+     * Dancer.
+     */
+    runMove(moveOrMoveName: Move | string, pokemon: Pokemon, targetLoc: number, sourceEffect?: Effect | null, zMove?: string, externalMove?: boolean, maxMove?: string, originalTarget?: Pokemon): void;
+    /**
+     * useMove is the "inside" move caller. It handles effects of the
+     * move itself, but not the idea of using the move.
+     *
+     * Most caller effects, like Sleep Talk, Nature Power, Magic Bounce,
+     * etc use useMove.
+     *
+     * The only ones that use runMove are Instruct, Pursuit, and
+     * Dancer.
+     */
+    useMove(move: Move | string, pokemon: Pokemon, target?: Pokemon | null, sourceEffect?: Effect | null, zMove?: string, maxMove?: string): boolean;
+    useMoveInner(moveOrMoveName: Move | string, pokemon: Pokemon, target?: Pokemon | null, sourceEffect?: Effect | null, zMove?: string, maxMove?: string): boolean;
+    /** NOTE: includes single-target moves */
+    trySpreadMoveHit(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove, notActive?: boolean): boolean;
+    hitStepInvulnerabilityEvent(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): any;
+    hitStepTryHitEvent(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): any;
+    hitStepTypeImmunity(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): boolean[];
+    hitStepTryImmunity(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): boolean[];
+    hitStepAccuracy(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): boolean[];
+    hitStepBreakProtect(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): undefined;
+    hitStepStealBoosts(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): undefined;
+    afterMoveSecondaryEvent(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): undefined;
+    /** NOTE: used only for moves that target sides/fields rather than pokemon */
+    tryMoveHit(targetOrTargets: Pokemon | Pokemon[], pokemon: Pokemon, move: ActiveMove): number | undefined | false | '';
+    hitStepMoveHitLoop(targets: Pokemon[], pokemon: Pokemon, move: ActiveMove): (number | boolean | undefined)[];
+    spreadMoveHit(targets: SpreadMoveTargets, pokemon: Pokemon, moveOrMoveName: ActiveMove, hitEffect?: Dex.HitEffect, isSecondary?: boolean, isSelf?: boolean): [SpreadMoveDamage, SpreadMoveTargets];
+    tryPrimaryHitEvent(damage: SpreadMoveDamage, targets: SpreadMoveTargets, pokemon: Pokemon, move: ActiveMove, moveData: ActiveMove, isSecondary?: boolean): SpreadMoveDamage;
+    getSpreadDamage(damage: SpreadMoveDamage, targets: SpreadMoveTargets, source: Pokemon, move: ActiveMove, moveData: ActiveMove, isSecondary?: boolean, isSelf?: boolean): SpreadMoveDamage;
+    runMoveEffects(damage: SpreadMoveDamage, targets: SpreadMoveTargets, source: Pokemon, move: ActiveMove, moveData: ActiveMove, isSecondary?: boolean, isSelf?: boolean): SpreadMoveDamage;
+    selfDrops(targets: SpreadMoveTargets, source: Pokemon, move: ActiveMove, moveData: ActiveMove, isSecondary?: boolean): void;
+    secondaries(targets: SpreadMoveTargets, source: Pokemon, move: ActiveMove, moveData: ActiveMove, isSelf?: boolean): void;
+    forceSwitch(damage: SpreadMoveDamage, targets: SpreadMoveTargets, source: Pokemon, move: ActiveMove): SpreadMoveDamage;
+    moveHit(targets: Pokemon | null | (Pokemon | null)[], pokemon: Pokemon, moveOrMoveName: ActiveMove, moveData?: Dex.HitEffect, isSecondary?: boolean, isSelf?: boolean): number | undefined | false;
+    calcRecoilDamage(damageDealt: number, move: Move, pokemon: Pokemon): number;
+    getZMove(move: Move, pokemon: Pokemon, skipChecks?: boolean): string | undefined;
+    getActiveZMove(move: Move, pokemon: Pokemon): ActiveMove;
+    canZMove(pokemon: Pokemon): ZMoveOptions | undefined;
+    getMaxMove(move: Move, pokemon: Pokemon): import("./dex-moves").Move | undefined;
+    getActiveMaxMove(move: Move, pokemon: Pokemon): import("./dex-moves").ActiveMove;
+    runZPower(move: ActiveMove, pokemon: Pokemon): void;
+    targetTypeChoices(targetType: string): boolean;
+    combineResults<T extends number | boolean | null | '' | undefined, U extends number | boolean | null | '' | undefined>(left: T, right: U): T | U;
+    /**
+     * 0 is a success dealing 0 damage, such as from False Swipe at 1 HP.
+     *
+     * Normal PS return value rules apply:
+     * undefined = success, null = silent failure, false = loud failure
+     */
+    getDamage(source: Pokemon, target: Pokemon, move: string | number | ActiveMove, suppressMessages?: boolean): number | undefined | null | false;
+    modifyDamage(baseDamage: number, pokemon: Pokemon, target: Pokemon, move: ActiveMove, suppressMessages?: boolean): number;
+    /**
+     * Confusion damage is unique - most typical modifiers that get run when calculating
+     * damage (e.g. Huge Power, Life Orb, critical hits) don't apply. It also uses a 16-bit
+     * context for its damage, unlike the regular damage formula (though this only comes up
+     * for base damage).
+     */
+    getConfusionDamage(pokemon: Pokemon, basePower: number): number;
+    canMegaEvo(pokemon: Pokemon): string | null | undefined;
+    canUltraBurst(pokemon: Pokemon): "Necrozma-Ultra" | null;
+    runMegaEvo(pokemon: Pokemon): boolean;
+    canTerastallize(pokemon: Pokemon): string | null;
+    terastallize(pokemon: Pokemon): void;
+}

package/build/types/sim/battle-queue.d.ts

@@ -0,0 +1,164 @@
+import { Effect, ID, Move, Pokemon } from './exported-global-types';
+/**
+ * Simulator Battle Action Queue
+ * Pokemon Showdown - http://pokemonshowdown.com/
+ *
+ * The action queue is the core of the battle simulation. A rough overview of
+ * the core battle loop:
+ *
+ * - chosen moves/switches are added to the action queue
+ * - the action queue is sorted in speed/priority order
+ * - we go through the action queue
+ * - repeat
+ *
+ * @license MIT
+ */
+import type { Battle } from './battle';
+/** A move action */
+export interface MoveAction {
+    /** action type */
+    choice: 'move' | 'beforeTurnMove' | 'priorityChargeMove';
+    order: 3 | 5 | 200 | 201 | 199 | 106;
+    /** priority of the action (lower first) */
+    priority: number;
+    /** fractional priority of the action (lower first) */
+    fractionalPriority: number;
+    /** speed of pokemon using move (higher first if priority tie) */
+    speed: number;
+    /** the pokemon doing the move */
+    pokemon: Pokemon;
+    /** location of the target, relative to pokemon's side */
+    targetLoc: number;
+    /** original target pokemon, for target-tracking moves */
+    originalTarget: Pokemon;
+    /** a move to use (move action only) */
+    moveid: ID;
+    /** a move to use (move action only) */
+    move: Move;
+    /** true if megaing or ultra bursting */
+    mega: boolean | 'done';
+    /** if zmoving, the name of the zmove */
+    zmove?: string;
+    /** if dynamaxed, the name of the max move */
+    maxMove?: string;
+    /** effect that called the move (eg Instruct) if any */
+    sourceEffect?: Effect | null;
+}
+/** A switch action */
+export interface SwitchAction {
+    /** action type */
+    choice: 'switch' | 'instaswitch' | 'revivalblessing';
+    order: 3 | 6 | 103;
+    /** priority of the action (lower first) */
+    priority: number;
+    /** speed of pokemon switching (higher first if priority tie) */
+    speed: number;
+    /** the pokemon doing the switch */
+    pokemon: Pokemon;
+    /** pokemon to switch to */
+    target: Pokemon;
+    /** effect that called the switch (eg U */
+    sourceEffect: Effect | null;
+}
+/** A Team Preview choice action */
+export interface TeamAction {
+    /** action type */
+    choice: 'team';
+    /** priority of the action (lower first) */
+    priority: number;
+    /** unused for this action type */
+    speed: 1;
+    /** the pokemon switching */
+    pokemon: Pokemon;
+    /** new index */
+    index: number;
+}
+/** A generic action not done by a pokemon */
+export interface FieldAction {
+    /** action type */
+    choice: 'start' | 'residual' | 'pass' | 'beforeTurn';
+    /** priority of the action (lower first) */
+    priority: number;
+    /** unused for this action type */
+    speed: 1;
+    /** unused for this action type */
+    pokemon: null;
+}
+/** A generic action done by a single pokemon */
+export interface PokemonAction {
+    /** action type */
+    choice: 'megaEvo' | 'shift' | 'runPrimal' | 'runSwitch' | 'event' | 'runUnnerve' | 'runDynamax' | 'terastallize';
+    /** priority of the action (lower first) */
+    priority: number;
+    /** speed of pokemon doing action (higher first if priority tie) */
+    speed: number;
+    /** the pokemon doing action */
+    pokemon: Pokemon;
+    /** `runSwitch` only: the pokemon forcing this pokemon to switch in */
+    dragger?: Pokemon;
+    /** `event` only: the event to run */
+    event?: string;
+}
+export type Action = MoveAction | SwitchAction | TeamAction | FieldAction | PokemonAction;
+/**
+ * An ActionChoice is like an Action and has the same structure, but it doesn't need to be fully filled out.
+ *
+ * Any Action or ChosenAction qualifies as an ActionChoice.
+ *
+ * The `[k: string]: any` part is required so TypeScript won't warn about unnecessary properties.
+ */
+export interface ActionChoice {
+    choice: string;
+    [k: string]: any;
+}
+/**
+ * Kind of like a priority queue, although not sorted mid-turn in Gen 1-7.
+ *
+ * Sort order is documented in `BattleQueue.comparePriority`.
+ */
+export declare class BattleQueue {
+    battle: Battle;
+    list: Action[];
+    constructor(battle: Battle);
+    shift(): Action | undefined;
+    peek(end?: boolean): Action | undefined;
+    push(action: Action): number;
+    unshift(action: Action): number;
+    [Symbol.iterator](): IterableIterator<Action>;
+    entries(): IterableIterator<[number, Action]>;
+    /**
+     * Takes an ActionChoice, and fills it out into a full Action object.
+     *
+     * Returns an array of Actions because some ActionChoices (like mega moves)
+     * resolve to two Actions (mega evolution + use move)
+     */
+    resolveAction(action: ActionChoice, midTurn?: boolean): Action[];
+    /**
+     * Makes the passed action happen next (skipping speed order).
+     */
+    prioritizeAction(action: MoveAction | SwitchAction, sourceEffect?: Effect): void;
+    /**
+     * Changes a pokemon's action, and inserts its new action
+     * in priority order.
+     *
+     * You'd normally want the OverrideAction event (which doesn't
+     * change priority order).
+     */
+    changeAction(pokemon: Pokemon, action: ActionChoice): void;
+    addChoice(choices: ActionChoice | ActionChoice[]): void;
+    willAct(): Action | null;
+    willMove(pokemon: Pokemon): MoveAction | null;
+    cancelAction(pokemon: Pokemon): boolean;
+    cancelMove(pokemon: Pokemon): boolean;
+    willSwitch(pokemon: Pokemon): MoveAction | SwitchAction | TeamAction | PokemonAction | null;
+    /**
+     * Inserts the passed action into the action queue when it normally
+     * would have happened (sorting by priority/speed), without
+     * re-sorting the existing actions.
+     */
+    insertChoice(choices: ActionChoice | ActionChoice[], midTurn?: boolean): void;
+    clear(): void;
+    debug(action?: any): string;
+    sort(): this;
+}
+export default BattleQueue;

package/build/types/sim/battle-stream.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+import { AnyObject } from './exported-global-types';
+/**
+ * Battle Stream
+ * Pokemon Showdown - http://pokemonshowdown.com/
+ *
+ * Supports interacting with a PS battle in Stream format.
+ *
+ * This format is VERY NOT FINALIZED, please do not use it directly yet.
+ *
+ * @license MIT
+ */
+import { Streams } from '../lib';
+import { Battle } from './battle';
+export declare class BattleStream extends Streams.ObjectReadWriteStream<string> {
+    debug: boolean;
+    noCatch: boolean;
+    replay: boolean | 'spectator';
+    keepAlive: boolean;
+    battle: Battle | null;
+    constructor(options?: {
+        debug?: boolean;
+        noCatch?: boolean;
+        keepAlive?: boolean;
+        replay?: boolean | 'spectator';
+    });
+    _write(chunk: string): void;
+    _writeLines(chunk: string): void;
+    pushMessage(type: string, data: string): void;
+    _writeLine(type: string, message: string): void;
+    _writeEnd(): void;
+    _destroy(): void;
+}
+/**
+ * Splits a BattleStream into omniscient, spectator, p1, p2, p3 and p4
+ * streams, for ease of consumption.
+ */
+export declare function getPlayerStreams(stream: BattleStream): {
+    omniscient: Streams.ObjectReadWriteStream<string>;
+    spectator: Streams.ObjectReadStream<string>;
+    p1: Streams.ObjectReadWriteStream<string>;
+    p2: Streams.ObjectReadWriteStream<string>;
+    p3: Streams.ObjectReadWriteStream<string>;
+    p4: Streams.ObjectReadWriteStream<string>;
+};
+export declare abstract class BattlePlayer {
+    readonly stream: Streams.ObjectReadWriteStream<string>;
+    readonly log: string[];
+    readonly debug: boolean;
+    constructor(playerStream: Streams.ObjectReadWriteStream<string>, debug?: boolean);
+    start(): Promise<void>;
+    receive(chunk: string): void;
+    receiveLine(line: string): void;
+    abstract receiveRequest(request: AnyObject): void;
+    receiveError(error: Error): void;
+    choose(choice: string): void;
+}
+export declare class BattleTextStream extends Streams.ReadWriteStream {
+    readonly battleStream: BattleStream;
+    currentMessage: string;
+    constructor(options: {
+        debug?: boolean;
+    });
+    start(): Promise<void>;
+    _write(message: string | Buffer): void;
+    _writeEnd(): Promise<void>;
+}