@bkm016/calcite 0.1.0 → 0.2.0

package/dist/client.d.ts

@@ -1,223 +1,99 @@
-import { EventEmitter } from 'node:events';
-import { type CalcitePaths } from './paths.js';
-export type RenderMode = 'off' | 'on-demand' | 'always';
-export type Account = {
-    type: 'offline';
-    username: string;
-} | {
-    type: 'microsoft';
-    name?: string;
-};
-export type Phase = 'idle' | 'preparing' | 'waiting_for_server' | 'starting' | 'connecting' | 'in_game' | 'disconnected' | 'reconnecting' | 'stopping' | 'stopped' | 'crashed';
-export interface ServerAddress {
-    host: string;
-    port: number;
-}
-export interface ClientOptions {
-    /** Instance name; also the game directory name. Letters, digits, '-', '_' and '.' only. */
-    name: string;
-    /** Minecraft version id, "latest" or "snapshot". */
-    version: string;
-    /** Server to join ("host[:port]"). Without a server the client stays on the title screen. */
-    server?: string | ServerAddress;
-    /** Account: offline (any username, for online-mode=false servers) or a stored Microsoft account. */
-    account?: Account;
-    /**
-     * World rendering: 'off' (no renderer, cheapest, no screenshots), 'on-demand' (renders only for screenshots,
-     * default), 'always'. Rendering needs a display (Linux: DISPLAY or Xvfb) and, with an offline account, Linux.
-     */
-    render?: RenderMode;
-    /** Explicit java executable for the game. */
-    javaPath?: string;
-    /** Download a Temurin runtime when the required Java is missing (default true). */
-    allowJavaDownload?: boolean;
-    /** Max heap, e.g. "2G" (default "2G"). */
-    memory?: string;
-    /** Extra JVM / game arguments (must not contain spaces). */
-    jvmArgs?: string[];
-    gameArgs?: string[];
-    renderDistance?: number;
-    maxFps?: number;
-    /** Reconnect (relaunch) after a disconnect or crash. Default: enabled, 10 attempts. */
-    reconnect?: boolean | {
-        maxAttempts?: number;
-    };
-    /** How long to wait for the server port before launching (default 120 s). */
-    waitForServerMs?: number;
-    /** Overall start timeout including downloads (default 15 min). */
-    startTimeoutMs?: number;
-    paths?: CalcitePaths;
-}
-export interface LogLine {
-    seq: number;
-    time: number;
-    source: 'game' | 'calcite';
-    line: string;
-}
-export interface ChatLine {
-    seq: number;
-    time: number;
-    message: string;
-}
-export interface PlayerState {
-    id?: number;
-    uuid?: string;
-    name?: string;
-    x?: number;
-    y?: number;
-    z?: number;
-    yaw?: number;
-    pitch?: number;
-    health?: number;
-    dimension?: string;
-}
-export interface GameState {
-    ready: boolean;
-    headless: boolean;
-    inGame: boolean;
-    screen?: string | null;
-    /** A resource (re)load overlay is showing. */
-    loading?: boolean;
-    disconnectReason?: string | null;
-    fps?: number;
-    noRender?: boolean;
-    player?: PlayerState;
-}
-export interface EntityInfo {
-    id: number;
-    uuid: string;
-    type: string;
-    x?: number;
-    y?: number;
-    z?: number;
-    yaw?: number;
-    pitch?: number;
-    name?: string;
-    customName?: string;
-    vehicleId?: number | null;
-    invisible?: boolean;
-    removed?: boolean;
-}
-export interface EntityQuery {
-    /** Only entities within this distance of the player (blocks). */
-    radius?: number;
-    /** Entity type id, e.g. "minecraft:villager" (the "minecraft:" prefix is optional). */
-    type?: string;
-    uuid?: string;
-    /** Substring match on name or custom name (case-insensitive). */
-    name?: string;
-    limit?: number;
-    includeSelf?: boolean;
-}
-export interface ClientStatus {
-    name: string;
-    version: string;
-    phase: Phase;
-    render: RenderMode;
-    headless: boolean;
-    account: Account;
-    server?: ServerAddress;
-    gameDir: string;
-    pid?: number;
-    java?: string;
-    startedAt?: number;
-    reconnects: number;
-    lastError?: string;
-    probeConnected: boolean;
-    game?: GameState;
-}
-export declare class CalciteError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
-}
-export declare function parseServer(server: string | ServerAddress): ServerAddress;
-/** Offline username derived from a client name (3-16 chars of [A-Za-z0-9_]). */
-export declare function defaultUsername(name: string): string;
-export interface InstallOptions {
-    paths?: CalcitePaths;
-    javaPath?: string;
-    allowJavaDownload?: boolean;
-    onLine?: (line: string) => void;
-}
-/**
- * Downloads everything a version needs (client, libraries, natives, assets, mappings, Java, HeadlessMC) without
- * starting the game, so later launches start fast and work offline.
- */
-export declare function installVersion(spec: string, opts?: InstallOptions): Promise<{
-    id: string;
-    java: string;
-    probe: string;
-}>;
+import { ClientCore } from './client-core.js';
+import { type BlockFace, type BlockInfo, type BlockPosition, type ChatLine, type ClickMode, type ContainerInfo, type DigResult, type EntityInfo, type EntityQuery, type GameState, type HitTarget, type InventoryInfo, type ItemInfo, type LogLine, type MoveControls, type Phase, type WalkResult } from './types.js';
+export * from './types.js';
+export { installVersion, type InstallOptions } from './install.js';
 /**
  * One Minecraft client controlled by Calcite.
  *
  * Events: 'phase' (Phase), 'log' (LogLine), 'chat' (ChatLine), 'state' (GameState), 'exit' (code).
  */
-export declare class Client extends EventEmitter {
-    readonly options: Required<Pick<ClientOptions, 'name' | 'version'>> & ClientOptions;
-    readonly paths: CalcitePaths;
-    readonly gameDir: string;
-    readonly render: RenderMode;
-    readonly account: Account;
-    readonly server?: ServerAddress;
-    private phaseValue;
-    private logs;
-    private chats;
-    private seq;
-    private probe;
-    private run;
-    private display;
-    private releaseInstance;
-    private probeConfig;
-    private java;
-    private versionJson;
-    private names;
-    private headlessValue;
-    private lastState;
-    private lastError;
-    /** Error code of a failure that relaunching cannot fix (reported by start() instead of "crashed"). */
-    private fatalCode;
-    private startedAt;
-    private reconnects;
-    private stopping;
-    private poller;
-    private inGameSince;
-    private relaunching;
-    private everInGame;
-    private joinRequested;
-    private readonly log;
-    constructor(options: ClientOptions);
-    get phase(): Phase;
-    get headless(): boolean;
-    private setPhase;
-    private note;
-    private pushLog;
-    /**
-     * Prepares everything (Java, game files, mappings), launches the client and resolves once it is in a world
-     * (or on the title screen when no server is configured).
-     */
-    start(): Promise<ClientStatus>;
-    /** Downloads and verifies everything needed to launch (idempotent). */
-    prepare(): Promise<void>;
-    private resolveHeadless;
-    private launch;
-    private onProbeConnected;
-    private poll;
-    private reconnectLimit;
-    private maybeReconnect;
-    private onGameExit;
-    private waitUntilStarted;
-    private cleanupRun;
-    private shutdown;
-    /** Stops the game and releases all resources. */
-    stop(): Promise<void>;
-    status(): ClientStatus;
-    private requireProbe;
+export declare class Client extends ClientCore {
     state(): Promise<GameState>;
     entities(query?: EntityQuery): Promise<EntityInfo[]>;
     chat(message: string): Promise<void>;
     command(command: string): Promise<void>;
     respawn(): Promise<void>;
+    /** Turns the player to an absolute rotation (degrees; yaw 0 = south, pitch -90 = up) or towards a point. */
+    look(to: {
+        yaw?: number;
+        pitch?: number;
+    } | {
+        x: number;
+        y: number;
+        z: number;
+    }): Promise<{
+        yaw: number;
+        pitch: number;
+    }>;
+    /**
+     * Holds movement controls until changed (or for {@code ticks} game ticks, 20 per second). Pass false to release
+     * a control; {@link stop} releases all of them.
+     */
+    move(controls: MoveControls, opts?: {
+        ticks?: number;
+    }): Promise<MoveControls & {
+        releaseInTicks?: number;
+    }>;
+    /** Releases every control and cancels a running walkTo/dig/held use. */
+    stopActions(): Promise<void>;
+    /**
+     * Walks in a straight line to (x, z), jumping over single blocks and swimming. Resolves when within
+     * {@code range} blocks, or with {@code arrived: false} when stuck (no progress for 3 s) or timed out.
+     * There is no path finding: route around obstacles with intermediate points.
+     */
+    walkTo(x: number, z: number, opts?: {
+        range?: number;
+        sprint?: boolean;
+        timeoutMs?: number;
+    }): Promise<WalkResult>;
+    /** Left click: attacks the entity (facing it first) or whatever the crosshair points at. */
+    attack(entityId?: number): Promise<HitTarget>;
+    /**
+     * Right click: interacts with an entity, a block (opening chests, pressing buttons, placing the held block
+     * against that face) or, with no target, whatever the crosshair points at / the held item in the air.
+     * {@code holdTicks} keeps the button pressed afterwards (eating, drinking, drawing a bow, shields).
+     */
+    use(target?: {
+        entityId?: number;
+        block?: BlockPosition & {
+            face?: BlockFace;
+        };
+        holdTicks?: number;
+    }): Promise<HitTarget>;
+    /** Mines a block like a player (holding left click, taking the real break time). */
+    dig(block: BlockPosition & {
+        face?: BlockFace;
+    }, opts?: {
+        timeoutMs?: number;
+    }): Promise<DigResult>;
+    /** The block at a position as the client sees it. */
+    block(pos: BlockPosition): Promise<BlockInfo>;
+    /** What the crosshair points at. */
+    target(): Promise<HitTarget>;
+    inventory(): Promise<InventoryInfo>;
+    /** Selects hotbar slot 0-8. */
+    selectSlot(slot: number): Promise<{
+        selected: number;
+        item: ItemInfo | null;
+    }>;
+    /** The open container (chest, furnace, villager trade, ...) or the inventory; {@code waitMs} waits for one to open. */
+    container(opts?: {
+        waitMs?: number;
+    }): Promise<ContainerInfo>;
+    /**
+     * Clicks a slot of the open container (or the inventory). Modes: pickup (default; button 0 left, 1 right),
+     * quick_move (shift click), swap (button = hotbar slot 0-8 or 40 for the offhand), clone, throw (button 1 =
+     * whole stack), quick_craft, pickup_all. Slot -999 is outside the window.
+     */
+    click(slot: number, opts?: {
+        button?: number;
+        mode?: ClickMode;
+    }): Promise<ContainerInfo>;
+    closeContainer(): Promise<void>;
+    /** Drops one item (or the whole stack) from the selected hotbar slot. */
+    drop(opts?: {
+        all?: boolean;
+    }): Promise<ItemInfo>;
     setRender(enabled: boolean): Promise<void>;
     /** Takes a screenshot and returns the PNG. With {@code keep} the file stays in the game's screenshots folder. */
     screenshot({ keep }?: {