@pkmn/sim 0.8.4 → 0.8.6

package/build/types/sim/team-validator.d.ts

@@ -1,198 +0,0 @@
-import { Ability, AnyObject, EventInfo, Format, ID, Item, ModdedDex, Move, Nature, PokemonSet, SparseStatsTable, Species, StatsTable } from './exported-global-types';
-/**
- * Describes a possible way to get a pokemon. Is not exhaustive!
- * sourcesBefore covers all sources that do not have exclusive
- * moves (like catching wild pokemon).
- *
- * First character is a generation number, 1-8.
- * Second character is a source ID, one of:
- *
- * - E = egg, 3rd char+ is the father in gen 2-5, empty in gen 6-7
- *   because egg moves aren't restricted to fathers anymore
- * - S = event, 3rd char+ is the index in .eventData
- * - D = Dream World, only 5D is valid
- * - V = Virtual Console or Let's Go transfer, only 7V/8V is valid
- *
- * Designed to match MoveSource where possible.
- */
-export type PokemonSource = string;
-/**
- * Represents a set of possible ways to get a Pokémon with a given
- * set.
- *
- * `new PokemonSources()` creates an empty set;
- * `new PokemonSources(dex.gen)` allows all Pokemon.
- *
- * The set mainly stored as an Array `sources`, but for sets that
- * could be sourced from anywhere (for instance, TM moves), we
- * instead just set `sourcesBefore` to a number meaning "any
- * source at or before this gen is possible."
- *
- * In other words, this variable represents the set of all
- * sources in `sources`, union all sources at or before
- * gen `sourcesBefore`.
- */
-export declare class PokemonSources {
-    /**
-     * A set of specific possible PokemonSources; implemented as
-     * an Array rather than a Set for perf reasons.
-     */
-    sources: PokemonSource[];
-    /**
-     * if nonzero: the set also contains all possible sources from
-     * this gen and earlier.
-     */
-    sourcesBefore: number;
-    /**
-     * the set requires sources from this gen or later
-     * this should be unchanged from the format's minimum past gen
-     * (3 in modern games, 6 if pentagon is required, etc)
-     */
-    sourcesAfter: number;
-    isHidden: boolean | null;
-    /**
-     * `limitedEggMoves` is a list of moves that can only be obtained from an
-     * egg with another father in gen 2-5. If there are multiple such moves,
-     * potential fathers need to be checked to see if they can actually
-     * learn the move combination in question.
-     *
-     * `null` = the current move is definitely not a limited egg move
-     *
-     * `undefined` = the current move may or may not be a limited egg move
-     */
-    limitedEggMoves?: ID[] | null;
-    /**
-     * Moves that should be in limitedEggMoves that would otherwise be skipped
-     * because they can be learned universally in a past generation
-     */
-    possiblyLimitedEggMoves?: ID[] | null;
-    /**
-     * Moves that should be in limitedEggMoves that would otherwise be skipped
-     * because they can be learned via Gen 1-2 tradeback
-     */
-    tradebackLimitedEggMoves?: ID[] | null;
-    /**
-     * Tracks level up egg moves for female-only Pokemon
-     */
-    levelUpEggMoves?: ID[] | null;
-    /**
-     * Moves that can be learned via Pomeg glitch and does not require a
-     * particular parent to learn
-     */
-    pomegEggMoves?: ID[] | null;
-    /**
-     * Event egg source that may be used with the Pomeg glitch
-     *
-     * `null` = definitely not an event egg that can be used with the Pomeg glitch
-     */
-    pomegEventEgg?: string | null;
-    /**
-     * Some Pokemon evolve by having a move in their learnset (like Piloswine
-     * with Ancient Power). These can only carry three other moves from their
-     * prevo, because the fourth move must be the evo move. This restriction
-     * doesn't apply to gen 6+ eggs, which can get around the restriction with
-     * the relearner.
-     */
-    moveEvoCarryCount: number;
-    babyOnly?: string;
-    sketchMove?: string;
-    dreamWorldMoveCount: number;
-    hm?: string;
-    isFromPokemonGo?: boolean;
-    pokemonGoSource?: string;
-    restrictiveMoves?: string[];
-    /** Obscure learn methods */
-    restrictedMove?: ID;
-    constructor(sourcesBefore?: number, sourcesAfter?: number);
-    size(): number;
-    add(source: PokemonSource, limitedEggMove?: ID | null): void;
-    addGen(sourceGen: number): void;
-    minSourceGen(): number;
-    maxSourceGen(): number;
-    intersectWith(other: PokemonSources): void;
-}
-export declare class TeamValidator {
-    readonly format: Format;
-    readonly dex: ModdedDex;
-    readonly gen: number;
-    readonly ruleTable: import('./dex-formats').RuleTable;
-    readonly minSourceGen: number;
-    readonly toID: (str: any) => ID;
-    constructor(format: string | Format, dex?: import("./dex").ModdedDex);
-    validateTeam(team: PokemonSet[] | null, options?: {
-        removeNicknames?: boolean;
-        skipSets?: {
-            [name: string]: {
-                [key: string]: boolean;
-            };
-        };
-    }): string[] | null;
-    baseValidateTeam(team: PokemonSet[] | null, options?: {
-        removeNicknames?: boolean;
-        skipSets?: {
-            [name: string]: {
-                [key: string]: boolean;
-            };
-        };
-    }): string[] | null;
-    getEventOnlyData(species: Species, noRecurse?: boolean): {
-        species: Species;
-        eventData: EventInfo[];
-    } | null;
-    getValidationSpecies(set: PokemonSet): [Species, Species];
-    validateSet(set: PokemonSet, teamHas: AnyObject): string[] | null;
-    validateStats(set: PokemonSet, species: Species, setSources: PokemonSources, pokemonGoProblems: string[] | null): string[];
-    /**
-     * Not exhaustive, just checks Atk and Spe, which are the only competitively
-     * relevant IVs outside of extremely obscure situations.
-     */
-    possibleBottleCapHpType(type: string, ivs: StatsTable): boolean;
-    validateSource(set: PokemonSet, source: PokemonSource, setSources: PokemonSources, species: Species, because: string): string[] | undefined;
-    validateSource(set: PokemonSet, source: PokemonSource, setSources: PokemonSources, species: Species): true | undefined;
-    findEggMoveFathers(source: PokemonSource, species: Species, setSources: PokemonSources, getAll?: false, pokemonBlacklist?: ID[], noRecurse?: true): boolean;
-    findEggMoveFathers(source: PokemonSource, species: Species, setSources: PokemonSources, getAll?: true): ID[] | null;
-    /**
-     * We could, if we wanted, do a complete move validation of the father's
-     * moveset to see if it's valid. This would recurse and be NP-Hard so
-     * instead we won't. We'll instead use a simplified algorithm: The father
-     * is allowed to have multiple egg moves and a maximum of one move from
-     * any other restrictive source; recursion is done only if there are less
-     * egg moves to validate or if the father has an egg group it doesn't
-     * share with the egg Pokemon. Recursion is also limited to two iterations
-     * of calling findEggMoveFathers.
-     */
-    fatherCanLearn(baseSpecies: Species, species: Species, moves: ID[], eggGen: number, pokemonBlacklist: ID[], noRecurse: boolean | undefined): boolean;
-    validateForme(set: PokemonSet): string[];
-    checkSpecies(set: PokemonSet, species: Species, tierSpecies: Species, setHas: {
-        [k: string]: true;
-    }): string | null;
-    checkItem(set: PokemonSet, item: Item, setHas: {
-        [k: string]: true;
-    }): string | null;
-    checkMove(set: PokemonSet, move: Move, setHas: {
-        [k: string]: true;
-    }): string | null;
-    checkAbility(set: PokemonSet, ability: Ability, setHas: {
-        [k: string]: true;
-    }): string | null;
-    checkNature(set: PokemonSet, nature: Nature, setHas: {
-        [k: string]: true;
-    }): string | null;
-    validateEvent(set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species): true | undefined;
-    validateEvent(set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species, because: string, from?: string): string[] | undefined;
-    allSources(species?: Species): PokemonSources;
-    validateMoves(species: Species, moves: string[], setSources: PokemonSources, set?: Partial<PokemonSet>, name?: string, moveLegalityWhitelist?: {
-        [k: string]: true | undefined;
-    }): string[];
-    /**
-     * Returns a list of problems regarding a Pokemon's avilability in Pokemon GO (empty list if no problems)
-     * If the Pokemon cannot be obtained from Pokemon GO, returns null
-     */
-    validatePokemonGo(species: Species, set: Partial<PokemonSet>, setSources: PokemonSources, name?: string): string[] | null;
-    omCheckCanLearn(move: Move, s: Species, setSources?: PokemonSources, set?: Partial<PokemonSet>, problem?: string): string | null;
-    /** Returns null if you can learn the move, or a string explaining why you can't learn it */
-    checkCanLearn(move: Move, s: Species, setSources?: PokemonSources, set?: Partial<PokemonSet>): string | null;
-    learnsetParent(species: Species): import("./dex-species").Species | null;
-    static fillStats(stats: SparseStatsTable | null, fillNum?: number): StatsTable;
-    static get(format: string | Format): TeamValidator;
-}

package/build/types/sim/teams.d.ts

@@ -1,26 +0,0 @@
-import * as pkmn from '@pkmn/sets';
-import { PokemonSet } from '@pkmn/sets';
-import { PRNG, PRNGSeed } from './prng';
-import { Format, PlayerOptions } from './exported-global-types';
-interface TeamGenerator {
-    prng: PRNG;
-    getTeam(options?: PlayerOptions): pkmn.PokemonSet[];
-    setSeed(prng?: PRNG | PRNGSeed): void;
-}
-interface TeamGeneratorFactory {
-    getTeamGenerator(format: Format | string, seed: PRNG | PRNGSeed | null): TeamGenerator;
-}
-export declare const Teams: {
-    pack(team: pkmn.PokemonSet[] | null): string;
-    unpack(buf: string): pkmn.PokemonSet[] | null;
-    export(team: pkmn.PokemonSet[], options?: {
-        hideStats?: boolean;
-    }): string;
-    exportSet(set: pkmn.PokemonSet): string;
-    import(buf: string): PokemonSet[] | null;
-    getGenerator(format: Format | string, seed?: PRNG | PRNGSeed | null): TeamGenerator;
-    setGeneratorFactory(factory: TeamGeneratorFactory): any;
-    generate(format: Format | string, options?: PlayerOptions | null): pkmn.PokemonSet[];
-};
-export { PokemonSet } from '@pkmn/sets';
-export default Teams;

package/build/types/sim/tools/exhaustive-runner.d.ts

@@ -1,52 +0,0 @@
-import { ID } from '../exported-global-types';
-import { PRNG, PRNGSeed } from '../prng';
-import { RunnerOptions } from './runner';
-export interface ExhaustiveRunnerOptions {
-    format: string;
-    cycles?: number;
-    prng?: PRNG | PRNGSeed | null;
-    log?: boolean;
-    maxGames?: number;
-    maxFailures?: number;
-    dual?: boolean | 'debug';
-    possible?: ExhaustiveRunnerPossibilities;
-    runner?: (options: RunnerOptions) => Promise<void>;
-    cmd?: (cycles: number, format: string, seed: string) => string;
-}
-export interface ExhaustiveRunnerPossibilities {
-    pokemon?: ID[];
-    items?: ID[];
-    abilities?: ID[];
-    moves?: ID[];
-}
-export interface ExhaustiveRunnerUsageTracker {
-    pokemon(id: ID): void;
-    item(id: ID): void;
-    ability(id: ID): void;
-    move(id: ID): void;
-}
-export declare class ExhaustiveRunner {
-    static readonly DEFAULT_CYCLES = 1;
-    static readonly MAX_FAILURES = 10;
-    static readonly FORMATS: string[];
-    private readonly format;
-    private readonly cycles;
-    private readonly prng;
-    private readonly log;
-    private readonly maxGames?;
-    private readonly maxFailures?;
-    private readonly dual;
-    private readonly possible?;
-    private readonly runner;
-    private readonly cmd;
-    private failures;
-    private games;
-    private needsClear;
-    constructor(options: ExhaustiveRunnerOptions);
-    run(): Promise<number>;
-    private maybeClear;
-    private createPools;
-    private logProgress;
-    private static getSignatures;
-    private static onlyValid;
-}

package/build/types/sim/tools/index.d.ts

@@ -1,2 +0,0 @@
-export * from './exhaustive-runner';
-export * from './runner';

package/build/types/sim/tools/random-player-ai.d.ts

@@ -1,32 +0,0 @@
-import { AnyObject } from '../exported-global-types';
-/**
- * Example random player AI.
- *
- * Pokemon Showdown - http://pokemonshowdown.com/
- *
- * @license MIT
- */
-import { ObjectReadWriteStream } from '../../lib/streams';
-import { BattlePlayer } from '../battle-stream';
-import { PRNG, PRNGSeed } from '../prng';
-export declare class RandomPlayerAI extends BattlePlayer {
-    protected readonly move: number;
-    protected readonly mega: number;
-    protected readonly prng: PRNG;
-    constructor(playerStream: ObjectReadWriteStream<string>, options?: {
-        move?: number;
-        mega?: number;
-        seed?: PRNG | PRNGSeed | null;
-    }, debug?: boolean);
-    receiveError(error: Error): void;
-    receiveRequest(request: AnyObject): void;
-    protected chooseTeamPreview(team: AnyObject[]): string;
-    protected chooseMove(active: AnyObject, moves: {
-        choice: string;
-        move: AnyObject;
-    }[]): string;
-    protected chooseSwitch(active: AnyObject | undefined, switches: {
-        slot: number;
-        pokemon: AnyObject;
-    }[]): number;
-}

package/build/types/sim/tools/runner.d.ts

@@ -1,41 +0,0 @@
-import { PokemonSet } from '../exported-global-types';
-import { ObjectReadWriteStream } from '../../lib/streams';
-import { PRNG, PRNGSeed } from '../prng';
-import { RandomPlayerAI } from './random-player-ai';
-export interface AIOptions {
-    createAI: (stream: ObjectReadWriteStream<string>, options: AIOptions) => RandomPlayerAI;
-    move?: number;
-    mega?: number;
-    seed?: PRNG | PRNGSeed | null;
-    team?: PokemonSet[];
-}
-export interface RunnerOptions {
-    format: string;
-    prng?: PRNG | PRNGSeed | null;
-    p1options?: AIOptions;
-    p2options?: AIOptions;
-    p3options?: AIOptions;
-    p4options?: AIOptions;
-    input?: boolean;
-    output?: boolean;
-    error?: boolean;
-    dual?: boolean | 'debug';
-}
-export declare class Runner {
-    static readonly AI_OPTIONS: AIOptions;
-    private readonly prng;
-    private readonly p1options;
-    private readonly p2options;
-    private readonly p3options;
-    private readonly p4options;
-    private readonly format;
-    private readonly input;
-    private readonly output;
-    private readonly error;
-    private readonly dual;
-    constructor(options: RunnerOptions);
-    run(): Promise<void>;
-    private runGame;
-    private newSeed;
-    private getPlayerSpec;
-}