@multitapio/multitap 0.0.1

package/dist/types/react/input/types.d.ts

@@ -0,0 +1,46 @@
+import type { Vector2 } from 'three';
+/**
+ * Standard action bit flags.
+ * These map to the standard "actions" flags8 control in mt.config.json.
+ */
+export declare const ACTION_ATTACK: number;
+export declare const ACTION_INTERACT: number;
+export declare const ACTION_JUMP: number;
+export declare const ACTION_CROUCH: number;
+/**
+ * Raw input state from input devices
+ */
+export interface RawInput {
+    /** Look/aim delta (mouse movement, right stick, etc.) */
+    look: Vector2;
+    /** Movement input (WASD, left stick, etc.) - normalized */
+    movement: Vector2;
+    /** Mouse button state (bitmask: 1=left, 2=middle, 4=right) */
+    mouseButtons: number;
+    /** Scroll wheel delta (positive = scroll up/away) */
+    scroll: number;
+    /** Standard action flags (bitmask of ACTION_* constants) */
+    actions: number;
+}
+/**
+ * Interface for input mappers
+ * Mappers translate device input (keyboard, mouse, touch, gamepad) into raw input
+ */
+export interface InputMapper {
+    /** Poll current input state */
+    poll(): RawInput;
+    /** Start listening to input events */
+    bind(): void;
+    /** Stop listening to input events */
+    unbind(): void;
+    /** Enable/disable pointer lock behavior (optional, not all mappers support this) */
+    setPointerLockEnabled?(enabled: boolean): void;
+    /**
+     * Configure how mouse movement is captured into `RawInput.look` (optional).
+     * - pointerLock: only accumulate look delta while pointer locked (default)
+     * - always: always accumulate mouse movement (no pointer lock required)
+     * - drag: accumulate while any mouse button is pressed (click+drag)
+     */
+    setLookMode?(mode: 'pointerLock' | 'always' | 'drag'): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/react/input/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/react/input/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAS,CAAA;AACnC,eAAO,MAAM,eAAe,QAAS,CAAA;AACrC,eAAO,MAAM,WAAW,QAAS,CAAA;AACjC,eAAO,MAAM,aAAa,QAAS,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,yDAAyD;IACzD,IAAI,EAAE,OAAO,CAAA;IACb,2DAA2D;IAC3D,QAAQ,EAAE,OAAO,CAAA;IACjB,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAA;IACpB,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,IAAI,IAAI,QAAQ,CAAA;IAEhB,sCAAsC;IACtC,IAAI,IAAI,IAAI,CAAA;IAEZ,qCAAqC;IACrC,MAAM,IAAI,IAAI,CAAA;IAEd,oFAAoF;IACpF,qBAAqB,CAAC,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAE9C;;;;;OAKG;IACH,WAAW,CAAC,CAAC,IAAI,EAAE,aAAa,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,CAAA;CAC5D"}

package/dist/types/react/providers/SessionProvider.d.ts

@@ -0,0 +1,17 @@
+import type { SessionContextValue, SessionProviderProps } from '../types/session';
+export declare const SessionContext: import("react").Context<SessionContextValue | null>;
+/**
+ * SessionProvider - provides session context to child components
+ *
+ * Wraps game components and manages:
+ * - Session lifecycle (connect, disconnect)
+ * - State snapshots per frame
+ * - Participant tracking
+ * - Input handling
+ */
+export declare function SessionProvider({ config, children }: SessionProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access session context
+ */
+export declare function useSessionContext(): SessionContextValue;
+//# sourceMappingURL=SessionProvider.d.ts.map

package/dist/types/react/providers/SessionProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionProvider.d.ts","sourceRoot":"","sources":["../../../../src/react/providers/SessionProvider.tsx"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EAKrB,MAAM,kBAAkB,CAAA;AAQzB,eAAO,MAAM,cAAc,qDAAkD,CAAA;AAmE7E;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,oBAAoB,2CAmIzE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,mBAAmB,CAMvD"}

package/dist/types/react/providers/index.d.ts

@@ -0,0 +1,2 @@
+export { SessionProvider, SessionContext, useSessionContext } from './SessionProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/react/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/react/providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/types/react/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { Player, EntityStore, PlayerStore, SessionContextValue, SessionProviderProps, ReactSessionInterface, ReactCreateSession, UseSessionRenderCallback, } from './session';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/react/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/react/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,MAAM,EACN,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,WAAW,CAAA"}

package/dist/types/react/types/session.d.ts

@@ -0,0 +1,88 @@
+import type { RefObject } from 'react';
+import type { RootState } from '@react-three/fiber';
+import type { StoreApi as ZustandStoreApi } from 'zustand';
+import type { SessionConfig } from '../../session-config';
+import type { SessionStats, SessionOptions, SessionInterface } from '../../session';
+import type { Participant } from '../../input-graph';
+import type { EntityRef, CompiledSchema } from '../../state';
+import type { InputCodec } from '../../input-codec';
+/**
+ * Player in a session - extends Participant with entity reference
+ */
+export interface Player extends Participant {
+    entity: EntityRef;
+    isCurrentPlayer: boolean;
+}
+/**
+ * Zustand store for tracking entities matching a query
+ */
+export type EntityStore = {
+    entities: EntityRef[];
+    updateEntities: (incoming: Generator<EntityRef>) => void;
+};
+/**
+ * Zustand store for tracking session players
+ */
+export type PlayerStore = {
+    players: Player[];
+    update: (state: DataView, allParticipants: readonly Participant[], currentPlayerId: string) => void;
+};
+/**
+ * Session context value provided by SessionProvider
+ */
+export interface SessionContextValue {
+    /** Ref to current state DataView for the current frame - use within useFrame */
+    stateRef: RefObject<DataView>;
+    /** Store tracking participants for the current stateRef tick */
+    participants: ZustandStoreApi<PlayerStore>;
+    /** Session is ready to be used */
+    isReady: boolean;
+    /** Error during session initialization */
+    error: Error | null;
+    /** Send input to the session */
+    sendInput: (input: Uint8Array) => void;
+    /** Compiled input bindings */
+    inputBindings: InputCodec;
+    /** Session has ended */
+    ended: boolean;
+    /** Session config */
+    config: SessionConfig;
+    /** Compiled state schema for runtime queries */
+    schema: CompiledSchema;
+    /** Get session stats */
+    getStats: () => SessionStats;
+    /** Get current player id */
+    currentPlayerId: string;
+}
+/**
+ * Props for SessionProvider component
+ */
+export interface SessionProviderProps {
+    config: SessionOptions;
+    children: React.ReactNode;
+}
+/**
+ * Interface for session used by React components
+ */
+export interface ReactSessionInterface {
+    getConfig: SessionInterface['getConfig'];
+    getInputBindings: SessionInterface['getInputBindings'];
+    sendInput: SessionInterface['sendInput'];
+    getState: SessionInterface['getState'];
+    getStats: SessionInterface['getStats'];
+    close: SessionInterface['close'];
+    getParticipants: SessionInterface['getParticipants'];
+    getCurrentPlayerId: SessionInterface['getCurrentPlayerId'];
+}
+/**
+ * Factory function type for creating sessions (allows test mocking)
+ */
+export type ReactCreateSession = (config: SessionOptions) => Promise<ReactSessionInterface>;
+/**
+ * Callback type for useFrame hook
+ */
+export type UseSessionRenderCallback = (state: RootState & {
+    state: DataView;
+    players: Player[];
+}, delta: number, frame?: XRFrame) => void;
+//# sourceMappingURL=session.d.ts.map

package/dist/types/react/types/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/react/types/session.ts"],"names":[],"mappings":"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"}

package/dist/types/react/types.d.ts

@@ -0,0 +1,134 @@
+import type { Quaternion, Vector3 } from 'three';
+import type { ReactNode } from 'react';
+import type { InputMapper } from './input/types';
+/**
+ * Types that can be converted to Vector3
+ */
+export type Vector3Like = Vector3 | [number, number, number] | {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * Types that can be converted to Quaternion
+ */
+export type QuaternionLike = Quaternion | [number, number, number, number] | {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+/**
+ * Supported camera view types
+ */
+export type ViewType = 'firstPerson' | 'thirdPerson' | 'thirdPersonFixed' | 'topDown' | 'topDownFixed' | 'isometric' | 'sideOn' | 'map' | 'vehicle' | 'vehicleFixed' | 'twinStick' | 'moba' | 'asteroids';
+/**
+ * Player component props
+ */
+export interface PlayerProps {
+    /** Body position (from server/game state) */
+    position?: Vector3Like;
+    /** Body rotation quaternion (from server/game state) - NOT the aim */
+    rotation?: QuaternionLike;
+    /** Whether this player captures input (keyboard/mouse/touch) */
+    enableInput?: boolean;
+    /** Whether this player's camera is used for rendering */
+    enableCamera?: boolean;
+    /** Current camera view type */
+    view?: ViewType;
+    /** Custom input mapper (default: DesktopInputMapper) */
+    inputMapper?: InputMapper;
+    /** Distance from camera to player (third-person views) */
+    cameraDistance?: number;
+    /** Height offset for camera */
+    cameraHeight?: number;
+    /** Additional camera offset */
+    cameraOffset?: Vector3Like;
+    /**
+     * Camera smoothing/damping factor (0 = instant, approaching 1 = very smooth)
+     * Values are clamped to [0, 0.99] to prevent the camera from freezing.
+     */
+    damping?: number;
+    /** Pitch angle from vertical in radians (isometric, moba views) */
+    cameraAngle?: number;
+    /** Fixed camera yaw rotation in radians (topDownFixed, isometric, sideOn views) */
+    fixedYaw?: number;
+    /** Model position/rotation smoothing speed (higher = faster, 0 = instant) */
+    modelSmoothing?: number;
+    /**
+     * Vehicle-only: when true and moving backwards, swing the camera to the other side.
+     * Ignored by all non-vehicle views.
+     */
+    reverseCam?: boolean;
+    /** Name for the camera object (useful for testing/debugging) */
+    cameraName?: string;
+    /**
+     * Show crosshair when this player has camera enabled.
+     * The crosshair style adapts to the view type:
+     * - 'center' views (FPS, third-person): crosshair at screen center
+     * - 'cursor' views (twin-stick, MOBA): crosshair follows cursor
+     * - 'none' views (map, sideOn, asteroids): no crosshair
+     */
+    crosshair?: boolean;
+    /** Player model (consumer-provided mesh/geometry) */
+    children?: ReactNode;
+}
+/**
+ * Sampled player intent for network sync
+ *
+ * Coordinate convention (matches Three.js):
+ * - Right-handed, Y-up, XZ ground plane
+ * - Forward = -Z in heading-space (matches Three.js camera/object look direction)
+ *
+ * Intent model:
+ * - `heading`: Movement reference frame (move vector is relative to this)
+ * - `aim`: Attack/targeting direction (where camera points)
+ * - `move`: Movement intent relative to heading (NEVER world-space)
+ *
+ * For many views, heading === aim (same quaternion value).
+ *
+ * Views where aim can differ from heading:
+ * - Orbit-style thirdPerson: aim follows direction of travel while heading stays camera-relative.
+ * - Vehicle: heading = body direction (from server), aim = mouse direction
+ * - TwinStick: heading = screen up (fixed), aim = cursor direction
+ * - Moba: heading = iso camera direction (fixed), aim = cursor direction
+ */
+export interface PlayerIntent {
+    /** Movement reference frame (facing direction quaternion) */
+    heading: Quaternion;
+    /** Attack/look direction (where camera points) */
+    aim: Quaternion;
+    /**
+     * Movement intent relative to heading (ALWAYS heading-space, NEVER world-space)
+     *
+     * Axis convention in heading-space (Three.js standard: forward = -Z):
+     * - move.x > 0: strafe right
+     * - move.x < 0: strafe left
+     * - move.z < 0: forward
+     * - move.z > 0: backward
+     *
+     * Examples:
+     * - Full forward: move = (0, 0, -1)
+     * - Full backward: move = (0, 0, 1)
+     * - Strafe right: move = (1, 0, 0)
+     *
+     * For vehicle-style controls:
+     * - steer = move.x
+     * - throttle = -move.z (so positive throttle = forward)
+     */
+    move: Vector3;
+    /** Standard action flags (bitmask of ACTION_* constants) */
+    actions: number;
+}
+/**
+ * Imperative handle exposed via ref
+ */
+export interface PlayerHandle {
+    /** Set player body position (e.g., from server update) */
+    setPosition(pos: Vector3Like): void;
+    /** Set player body rotation (e.g., from server update) */
+    setRotation(rot: QuaternionLike): void;
+    /** Sample current intent for network sync */
+    sample(): PlayerIntent;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/react/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/react/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEhD;;GAEG;AACH,MAAM,MAAM,WAAW,GACnB,OAAO,GACP,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACxB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,UAAU,GACV,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAElD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAChB,aAAa,GACb,aAAa,GACb,kBAAkB,GAClB,SAAS,GACT,cAAc,GACd,WAAW,GACX,QAAQ,GACR,KAAK,GACL,SAAS,GACT,cAAc,GACd,WAAW,GACX,MAAM,GACN,WAAW,CAAA;AAEf;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,WAAW,CAAA;IACtB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,cAAc,CAAA;IAEzB,gEAAgE;IAChE,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,yDAAyD;IACzD,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB,+BAA+B;IAC/B,IAAI,CAAC,EAAE,QAAQ,CAAA;IAEf,wDAAwD;IACxD,WAAW,CAAC,EAAE,WAAW,CAAA;IAGzB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,+BAA+B;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,+BAA+B;IAC/B,YAAY,CAAC,EAAE,WAAW,CAAA;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,SAAS,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,OAAO,EAAE,UAAU,CAAA;IACnB,kDAAkD;IAClD,GAAG,EAAE,UAAU,CAAA;IACf;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,EAAE,OAAO,CAAA;IACb,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAAA;IACnC,0DAA0D;IAC1D,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAAA;IACtC,6CAA6C;IAC7C,MAAM,IAAI,YAAY,CAAA;CACvB"}

package/dist/types/react/utils/math.d.ts

@@ -0,0 +1,19 @@
+import { Quaternion, Vector3 } from 'three';
+import type { QuaternionLike, Vector3Like } from '../types';
+/**
+ * Convert Vector3Like to Vector3
+ */
+export declare function toVector3(v: Vector3Like): Vector3;
+/**
+ * Convert QuaternionLike to Quaternion
+ */
+export declare function toQuaternion(q: QuaternionLike): Quaternion;
+/**
+ * Lerp between two values
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+/**
+ * Clamp a value between min and max
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+//# sourceMappingURL=math.d.ts.map

package/dist/types/react/utils/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../../src/react/utils/math.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3D;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAIjD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,cAAc,GAAG,UAAU,CAI1D;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/dist/types/react/views/AsteroidsView.d.ts

@@ -0,0 +1,24 @@
+import type { View } from './types';
+/**
+ * Asteroids view (top-down with keyboard rotation)
+ *
+ * Style: Asteroids, classic arcade rotation+thrust games
+ *
+ * Architecture:
+ * - Pivot: at player position, no rotation (fixed north-up camera)
+ * - Camera: directly above pivot, looking straight down
+ *
+ * Controls:
+ * - Arrow Left/Right (look.x): rotate heading (turn ship)
+ * - Arrow Up/Down or W/S (movement.y): thrust forward/backward relative to heading
+ * - A/D (movement.x): strafe relative to heading
+ *
+ * This is different from topDownFixed which has screen-relative movement.
+ * Asteroids view has heading-relative movement like a spaceship.
+ *
+ * NOTE: This is for classic Asteroids-style rotation+thrust mechanics ONLY.
+ * For "tank games" (drive + shoot), use the `vehicle` view instead.
+ * For tank games with fixed camera, use `thirdPersonFixed`.
+ */
+export declare const AsteroidsView: View;
+//# sourceMappingURL=AsteroidsView.d.ts.map

package/dist/types/react/views/AsteroidsView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsteroidsView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/AsteroidsView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAW3D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,EAAE,IAuE3B,CAAA"}

package/dist/types/react/views/FirstPersonView.d.ts

@@ -0,0 +1,10 @@
+import type { View } from './types';
+/**
+ * First-person view
+ *
+ * - Pivot: positioned at player's eye level, rotates on Y axis (yaw)
+ * - Camera: at pivot position, rotates on X axis (pitch)
+ * - Movement is relative to look direction
+ */
+export declare const FirstPersonView: View;
+//# sourceMappingURL=FirstPersonView.d.ts.map

package/dist/types/react/views/FirstPersonView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirstPersonView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/FirstPersonView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAmB3D;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,IAoG7B,CAAA"}

package/dist/types/react/views/IsometricView.d.ts

@@ -0,0 +1,21 @@
+import type { View } from './types';
+/**
+ * Isometric view (fixed angle, screen-relative WASD)
+ *
+ * Style: Diablo, Path of Exile, CRPGs
+ *
+ * Architecture:
+ * - Pivot: at player position, rotated by fixedYaw
+ * - Camera: at angle from vertical (cameraAngle), looking at player
+ *
+ * Mouse input is ignored. WASD is screen-relative, mapped to isometric axes.
+ * Movement is relative to the fixed camera yaw.
+ *
+ * Props:
+ * - cameraAngle: pitch from vertical in radians (default 45°)
+ * - fixedYaw: camera rotation in radians (default -45° for classic iso)
+ *
+ * heading and aim are both fixed to the camera yaw direction.
+ */
+export declare const IsometricView: View;
+//# sourceMappingURL=IsometricView.d.ts.map

package/dist/types/react/views/IsometricView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsometricView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/IsometricView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAY3D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,EAAE,IAuE3B,CAAA"}

package/dist/types/react/views/MapView.d.ts

@@ -0,0 +1,16 @@
+import type { View } from './types';
+/**
+ * Map / RTS view
+ *
+ * This view delegates camera control to drei's MapControls component,
+ * which is rendered by Player.tsx when view === 'map'.
+ *
+ * Controls (MapControls defaults):
+ * - Left-drag: Rotate
+ * - Right-drag: Pan
+ * - Scroll: Zoom
+ *
+ * The view just provides minimal state - MapControls handles everything.
+ */
+export declare const MapView: View;
+//# sourceMappingURL=MapView.d.ts.map

package/dist/types/react/views/MapView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/MapView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAE3D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,EAAE,IA4BrB,CAAA"}

package/dist/types/react/views/MobaView.d.ts

@@ -0,0 +1,17 @@
+import type { View } from './types';
+/**
+ * MOBA view (isometric camera + decoupled mouse aim)
+ *
+ * Style: League of Legends, Dota 2
+ *
+ * - Camera: fixed isometric yaw/pitch (north-east diagonal by default)
+ * - Movement: WASD screen-relative, interpreted relative to fixed camera yaw
+ * - heading: fixed quaternion matching camera yaw (movement reference frame)
+ * - aim: yaw-only quaternion driven by mouse X delta (independent of heading)
+ *
+ * Props:
+ * - cameraAngle: pitch from vertical in radians (default 45°)
+ * - fixedYaw: camera rotation in radians (default -45°)
+ */
+export declare const MobaView: View;
+//# sourceMappingURL=MobaView.d.ts.map

package/dist/types/react/views/MobaView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MobaView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/MobaView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAmB3D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,EAAE,IA4FtB,CAAA"}

package/dist/types/react/views/SideOnView.d.ts

@@ -0,0 +1,23 @@
+import type { View } from './types';
+/**
+ * Side-on view (2.5D platformer)
+ *
+ * Style: Limbo, Little Nightmares, 2.5D platformers
+ *
+ * Architecture:
+ * - Pivot: at player position, rotated 90° so camera faces the X axis
+ * - Camera: offset on local Z axis, looking at player
+ *
+ * This view treats the game as a 2D side-scroller rendered in 3D:
+ * - A/D moves left/right on X axis (world space)
+ * - W could be jump intent (game-level interpretation)
+ * - Mouse input is ignored
+ *
+ * The facing direction flips based on last horizontal movement:
+ * - Moving right (D) → facing direction +1 (facing +X)
+ * - Moving left (A) → facing direction -1 (facing -X)
+ *
+ * heading and aim are set to the current facing direction.
+ */
+export declare const SideOnView: View;
+//# sourceMappingURL=SideOnView.d.ts.map

package/dist/types/react/views/SideOnView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SideOnView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/SideOnView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAK3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,UAAU,EAAE,IA6FxB,CAAA"}

package/dist/types/react/views/ThirdPersonFixedView.d.ts

@@ -0,0 +1,21 @@
+import type { View } from './types';
+/**
+ * Third-person fixed view (over-shoulder, RE4/God of War style)
+ *
+ * The camera is on a ray extending BACKWARD from the player's head.
+ * Think of it as first-person, but the camera is pulled back along the look ray.
+ *
+ * Geometry:
+ * - Pivot is at the player's head, rotated by yaw AND pitch (like FPS)
+ * - Camera is positioned behind the pivot along its local +Z axis
+ * - Camera has no rotation of its own - it inherits pivot's orientation
+ *
+ * When you pitch down:
+ * - The pivot tilts down (looking at ground ahead)
+ * - The camera, being behind the pivot, ends up above and behind
+ * - The camera looks "over the shoulder" at the ground ahead
+ *
+ * This is the same as extending the FPS look ray backward.
+ */
+export declare const ThirdPersonFixedView: View;
+//# sourceMappingURL=ThirdPersonFixedView.d.ts.map

package/dist/types/react/views/ThirdPersonFixedView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThirdPersonFixedView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/ThirdPersonFixedView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAwB3D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,EAAE,IA4HlC,CAAA"}

package/dist/types/react/views/ThirdPersonView.d.ts

@@ -0,0 +1,12 @@
+import type { View } from './types';
+/**
+ * Third-person view (over-shoulder style)
+ *
+ * Architecture:
+ * - Pivot: positioned at player + height offset (this is what camera looks at)
+ * - Camera: orbits around pivot based on yaw/pitch, always looks at pivot
+ *
+ * Pitch controls camera's vertical position in arc around target (not camera rotation)
+ */
+export declare const ThirdPersonView: View;
+//# sourceMappingURL=ThirdPersonView.d.ts.map

package/dist/types/react/views/ThirdPersonView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThirdPersonView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/ThirdPersonView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAuB3D;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE,IA2H7B,CAAA"}

package/dist/types/react/views/TopDownFixedView.d.ts

@@ -0,0 +1,20 @@
+import type { View } from './types';
+/**
+ * Top-down fixed view (north-up, no mouse input)
+ *
+ * Style: Hotline Miami, classic Zelda
+ *
+ * Architecture:
+ * - Pivot: at player position, no rotation (fixed north-up)
+ * - Camera: directly above pivot, looking straight down
+ *
+ * Mouse input is ignored. WASD is screen-relative:
+ * - W = up on screen = -Z in world
+ * - S = down on screen = +Z in world
+ * - A = left on screen = -X in world
+ * - D = right on screen = +X in world
+ *
+ * heading and aim are both fixed facing -Z (identity rotation).
+ */
+export declare const TopDownFixedView: View;
+//# sourceMappingURL=TopDownFixedView.d.ts.map

package/dist/types/react/views/TopDownFixedView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TopDownFixedView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/TopDownFixedView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAK3D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,IA8D9B,CAAA"}

package/dist/types/react/views/TopDownView.d.ts

@@ -0,0 +1,12 @@
+import type { View } from './types';
+/**
+ * Top-down view (overhead camera)
+ *
+ * Architecture:
+ * - Pivot: at player position, rotates on Y axis (yaw)
+ * - Camera: directly above pivot, looking straight down
+ *
+ * Mouse X rotates the view, movement is relative to camera rotation.
+ */
+export declare const TopDownView: View;
+//# sourceMappingURL=TopDownView.d.ts.map

package/dist/types/react/views/TopDownView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TopDownView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/TopDownView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAS3D;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,IAkEzB,CAAA"}

package/dist/types/react/views/TwinStickView.d.ts

@@ -0,0 +1,13 @@
+import type { View } from './types';
+/**
+ * Twin-stick view (fixed top-down camera, independent mouse aim)
+ *
+ * Style: Enter the Gungeon, Nuclear Throne
+ *
+ * - Camera: fixed above the player, north-up (no camera rotation)
+ * - Movement: WASD is screen-relative (W=-Z, S=+Z, A=-X, D=+X)
+ * - heading: fixed to screen up (-Z) (identity quaternion)
+ * - aim: yaw-only quaternion driven by mouse X delta (independent of heading)
+ */
+export declare const TwinStickView: View;
+//# sourceMappingURL=TwinStickView.d.ts.map

package/dist/types/react/views/TwinStickView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TwinStickView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/TwinStickView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AAa3D;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,EAAE,IAqF3B,CAAA"}

package/dist/types/react/views/VehicleFixedView.d.ts

@@ -0,0 +1,16 @@
+import type { View } from './types';
+/**
+ * Vehicle Fixed view
+ *
+ * - `heading` comes from the body rotation (server / props), yaw-only.
+ * - `aim` is locked to heading yaw, but can include pitch for camera tilt.
+ * - Camera stays behind the vehicle body with damping (like a chase cam).
+ *
+ * Controls:
+ * - W/S: throttle (move.z, forward = -Z)
+ * - A/D: steering (move.x)
+ * - Mouse X: also contributes to steering (move.x)
+ * - Mouse Y: camera pitch (clamped)
+ */
+export declare const VehicleFixedView: View;
+//# sourceMappingURL=VehicleFixedView.d.ts.map

package/dist/types/react/views/VehicleFixedView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VehicleFixedView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/VehicleFixedView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AA8B3D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,IAgI9B,CAAA"}

package/dist/types/react/views/VehicleView.d.ts

@@ -0,0 +1,13 @@
+import type { View } from './types';
+/**
+ * Vehicle view
+ *
+ * Key rule: `heading` comes from the body rotation (server / props), while `aim`
+ * comes from local free-look input (mouse).
+ *
+ * - Movement: W/S = throttle (mapped to move.z), A/D = steering (mapped to move.x)
+ * - `move` is ALWAYS relative to `heading` (vehicle body direction)
+ * - Camera follows `aim` so you see where you're aiming, even while the body turns independently
+ */
+export declare const VehicleView: View;
+//# sourceMappingURL=VehicleView.d.ts.map

package/dist/types/react/views/VehicleView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VehicleView.d.ts","sourceRoot":"","sources":["../../../../src/react/views/VehicleView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAA0B,MAAM,SAAS,CAAA;AA2B3D;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,EAAE,IAqJzB,CAAA"}