@pkmn/sim 0.8.3 → 0.8.5

package/build/types/lib/utils.d.ts

@@ -1,139 +0,0 @@
-/**
- * Utils library
- *
- * Miscellaneous utility functions that don't really have a better place.
- *
- * It'll always be a judgment call whether or not a function goes into a
- * "catch-all" library like this, so here are some guidelines:
- *
- * - It must not have any dependencies
- *
- * - It must conceivably have a use in a wide variety of projects, not just
- *   Pokémon (if it's Pokémon-specific, Dex is probably a good place for it)
- *
- * - A lot of Chat functions are kind of iffy, but I'm going to say for now
- *   that if it's English-specific, it should be left out of here.
- */
-/// <reference types="node" />
-export type Comparable = number | string | boolean | Comparable[] | {
-    reverse: Comparable;
-};
-/**
- * Safely converts the passed variable into a string. Unlike '' + str,
- * String(str), or str.toString(), Utils.getString is guaranteed not to
- * crash.
- *
- * Specifically, the fear with untrusted JSON is an object like:
- *
- *     let a = {"toString": "this is not a function"};
- *     console.log(`a is ${a}`);
- *
- * This will crash (because a.toString() is not a function). Instead,
- * getString simply returns '' if the passed variable isn't a
- * string or a number.
- */
-export declare function getString(str: any): string;
-export declare function escapeRegex(str: string): string;
-/**
- * Escapes HTML in a string.
-*/
-export declare function escapeHTML(str: string | number): string;
-/**
- * Strips HTML from a string.
- */
-export declare function stripHTML(htmlContent: string): string;
-/**
- * Maps numbers to their ordinal string.
- */
-export declare function formatOrder(place: number): string;
-/**
- * Visualizes eval output in a slightly more readable form
- */
-export declare function visualize(value: any, depth?: number): string;
-/**
- * Compares two variables; intended to be used as a smarter comparator.
- * The two variables must be the same type (TypeScript will not check this).
- *
- * - Numbers are sorted low-to-high, use `-val` to reverse
- * - Strings are sorted A to Z case-semi-insensitively, use `{reverse: val}` to reverse
- * - Booleans are sorted true-first (REVERSE of casting to numbers), use `!val` to reverse
- * - Arrays are sorted lexically in the order of their elements
- *
- * In other words: `[num, str]` will be sorted A to Z, `[num, {reverse: str}]` will be sorted Z to A.
- */
-export declare function compare(a: Comparable, b: Comparable): number;
-/**
- * Sorts an array according to the callback's output on its elements.
- *
- * The callback's output is compared according to `PSUtils.compare`
- * (numbers low to high, strings A-Z, booleans true-first, arrays in order).
- */
-export declare function sortBy<T>(array: T[], callback: (a: T) => Comparable): T[];
-/**
- * Sorts an array according to `PSUtils.compare`
- * (numbers low to high, strings A-Z, booleans true-first, arrays in order).
- *
- * Note that array.sort() only works on strings, not numbers, so you'll need
- * this to sort numbers.
- */
-export declare function sortBy<T extends Comparable>(array: T[]): T[];
-export declare function splitFirst(str: string, delimiter: string): [string, string];
-export declare function splitFirst(str: string, delimiter: string, limit: 2): [string, string, string];
-export declare function splitFirst(str: string, delimiter: string, limit: 3): [string, string, string, string];
-export declare function splitFirst(str: string, delimiter: string, limit: number): string[];
-/**
- * Template string tag function for escaping HTML
- */
-export declare function html(strings: TemplateStringsArray, ...args: any): string;
-/**
- * This combines escapeHTML and forceWrap. The combination allows us to use
- * <wbr /> instead of U+200B, which will make sure the word-wrapping hints
- * can't be copy/pasted (which would mess up code).
- */
-export declare function escapeHTMLForceWrap(text: string): string;
-/**
- * HTML doesn't support `word-wrap: break-word` in tables, but sometimes it
- * would be really nice if it did. This emulates `word-wrap: break-word` by
- * manually inserting U+200B to tell long words to wrap.
- */
-export declare function forceWrap(text: string): string;
-export declare function shuffle<T>(arr: T[]): T[];
-export declare function randomElement<T>(arr: T[]): T;
-/** Forces num to be an integer (between min and max). */
-export declare function clampIntRange(num: any, min?: number, max?: number): number;
-export declare function clearRequireCache(options?: {
-    exclude?: string[];
-}): void;
-export declare function uncacheModuleTree(mod: NodeJS.Module, excludes: string[], depth?: number): void;
-export declare function deepClone(obj: any): any;
-export declare function levenshtein(s: string, t: string, l: number): number;
-export declare function waitUntil(time: number): Promise<void>;
-/** Like parseInt, but returns NaN if the int isn't already in normalized form */
-export declare function parseExactInt(str: string): number;
-/** formats an array into a series of question marks and adds the elements to an arguments array */
-export declare function formatSQLArray(arr: unknown[], args?: unknown[]): string;
-export declare class Multiset<T> extends Map<T, number> {
-    add(key: T): this;
-    remove(key: T): boolean;
-}
-export declare const Utils: {
-    parseExactInt: typeof parseExactInt;
-    waitUntil: typeof waitUntil;
-    html: typeof html;
-    escapeHTML: typeof escapeHTML;
-    compare: typeof compare;
-    sortBy: typeof sortBy;
-    levenshtein: typeof levenshtein;
-    shuffle: typeof shuffle;
-    deepClone: typeof deepClone;
-    clearRequireCache: typeof clearRequireCache;
-    randomElement: typeof randomElement;
-    forceWrap: typeof forceWrap;
-    splitFirst: typeof splitFirst;
-    stripHTML: typeof stripHTML;
-    visualize: typeof visualize;
-    getString: typeof getString;
-    escapeRegex: typeof escapeRegex;
-    formatSQLArray: typeof formatSQLArray;
-    Multiset: typeof Multiset;
-};

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

@@ -1,90 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,67 +0,0 @@
-/// <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>;
-}