@igneosoft/forge 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,503 @@
+import * as THREE from 'three';
+export { THREE };
+
+declare class Engine {
+    private renderer;
+    private scene;
+    private camera;
+    private player;
+    private input;
+    private sceneManager;
+    private animationFrameId;
+    private clock;
+    constructor(canvas: HTMLCanvasElement);
+    start(): void;
+    stop(): void;
+    private loop;
+    private handleResize;
+}
+
+declare function createIsometricCamera(width: number, height: number): THREE.OrthographicCamera;
+declare function updateCameraTarget(camera: THREE.OrthographicCamera, target: THREE.Vector3): void;
+
+interface EntityState {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    dead?: boolean;
+    hp?: number;
+    [key: string]: unknown;
+}
+interface SceneStateData {
+    entities: EntityState[];
+    visited: boolean;
+}
+
+interface SpawnPoint$1 {
+    x: number;
+    z: number;
+}
+declare abstract class GameScene {
+    readonly id: string;
+    protected objects: THREE.Object3D[];
+    constructor(id: string);
+    abstract buildInitialState(): SceneStateData;
+    abstract populate(threeScene: THREE.Scene, state: SceneStateData): void;
+    abstract update(delta: number): void;
+    abstract getSpawnPoint(fromSceneId?: string): SpawnPoint$1;
+    saveState(): SceneStateData | null;
+    clear(threeScene: THREE.Scene): void;
+}
+
+declare class SceneManager {
+    private scenes;
+    private states;
+    private threeScene;
+    private _current;
+    constructor(threeScene: THREE.Scene);
+    get current(): GameScene | null;
+    register(scene: GameScene): void;
+    load(sceneId: string, fromSceneId?: string): SpawnPoint$1;
+    getState(sceneId: string): SceneStateData | undefined;
+    getAllStates(): Record<string, SceneStateData>;
+}
+
+interface TileData {
+    color: string;
+    walkable: boolean;
+    height: number;
+}
+interface MapObject {
+    id: string;
+    type: string;
+    x: number;
+    z: number;
+    color: string;
+    height: number;
+    solid: boolean;
+}
+interface Portal {
+    x: number;
+    z: number;
+    targetScene: string;
+    targetSpawn: string;
+}
+interface SpawnPoint {
+    x: number;
+    z: number;
+}
+interface MapData {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    tileSize: number;
+    tiles: TileData[][];
+    objects: MapObject[];
+    portals: Portal[];
+    spawns: Record<string, SpawnPoint>;
+}
+declare function createEmptyMap(id: string, width: number, height: number, name?: string, baseColor?: string): MapData;
+
+declare class MapRenderer {
+    private group;
+    private tileMeshes;
+    private gridLines;
+    private currentWidth;
+    private currentHeight;
+    getGroup(): THREE.Group;
+    render(mapData: MapData): THREE.Group;
+    syncTiles(mapData: MapData): void;
+    needsFullRebuildForHeight(mapData: MapData): boolean;
+    needsFullRebuild(mapData: MapData): boolean;
+    needsGeometryUpdate(mapData: MapData): boolean;
+    private renderObjects;
+    private buildHeightWalls;
+    private buildGrid;
+    dispose(): void;
+}
+
+declare class CollisionMap {
+    private walkable;
+    private heights;
+    private solidObjects;
+    private width;
+    private height;
+    private tileSize;
+    constructor(mapData: MapData);
+    canWalk(worldX: number, worldZ: number, fromWorldX?: number, fromWorldZ?: number): boolean;
+    getTileHeight(worldX: number, worldZ: number): number;
+    isWater(worldX: number, worldZ: number): boolean;
+}
+
+declare function createWorldGrid(cols: number, rows: number, tileSize?: number): THREE.Group;
+
+declare class FieldScene extends GameScene {
+    constructor();
+    buildInitialState(): SceneStateData;
+    populate(threeScene: THREE.Scene, _state: SceneStateData): void;
+    update(_delta: number): void;
+    getSpawnPoint(_fromSceneId?: string): SpawnPoint$1;
+}
+
+declare class InputManager {
+    private keys;
+    private onKeyDown;
+    private onKeyUp;
+    attach(): void;
+    detach(): void;
+    getDirection(): {
+        x: number;
+        z: number;
+    };
+}
+
+interface ColorPalette {
+    skin: string;
+    primary: string;
+    secondary: string;
+    accent: string;
+}
+type PartFactory = (palette: ColorPalette) => THREE.Mesh;
+type SlotName = 'head' | 'torso' | 'armL' | 'armR' | 'forearmL' | 'forearmR' | 'legL' | 'legR' | 'shinL' | 'shinR' | 'weapon';
+interface CharacterConfig {
+    id: string;
+    palette: ColorPalette;
+    head: PartFactory;
+    torso: PartFactory;
+    armL: PartFactory;
+    armR: PartFactory;
+    forearmL: PartFactory;
+    forearmR: PartFactory;
+    legL: PartFactory;
+    legR: PartFactory;
+    shinL: PartFactory;
+    shinR: PartFactory;
+    weapon?: PartFactory;
+}
+
+declare class CharacterEntity {
+    readonly root: THREE.Group;
+    private bones;
+    private mixer;
+    private actions;
+    private currentAction;
+    private parts;
+    private palette;
+    constructor(config: CharacterConfig);
+    /** Play an animation by name. Crossfades from current. */
+    play(name: string, crossFadeDuration?: number): void;
+    /** Swap a body part at runtime (e.g., equip new armor) */
+    swapPart(slot: SlotName, factory: PartFactory): void;
+    /** Must be called every frame with delta time */
+    update(delta: number): void;
+    /** Cleanup GPU resources */
+    dispose(): void;
+}
+
+declare class Player {
+    readonly entity: CharacterEntity;
+    readonly mesh: THREE.Group;
+    private targetPosition;
+    private collisionMap;
+    private wasMoving;
+    constructor(config?: CharacterConfig);
+    get position(): THREE.Vector3;
+    setPosition(x: number, z: number): void;
+    setCollisionMap(collisionMap: CollisionMap | null): void;
+    update(delta: number, direction: {
+        x: number;
+        z: number;
+    }): void;
+    dispose(): void;
+}
+
+interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface PivotAxes {
+    x: boolean;
+    y: boolean;
+    z: boolean;
+}
+interface RotationConstraints {
+    axes: PivotAxes;
+    min: Vec3;
+    max: Vec3;
+}
+interface InternalPivot {
+    name: string;
+    position: Vec3;
+    constraints: RotationConstraints;
+}
+interface Connector {
+    name: string;
+    position: Vec3;
+}
+interface BoneDefinition {
+    start: Vec3;
+    end: Vec3;
+    pivots: InternalPivot[];
+    connectors: Connector[];
+}
+interface Attachment {
+    parentPart: string;
+    parentConnector: string;
+    constraints: RotationConstraints;
+}
+interface BodyPartDefinition {
+    name: string;
+    size: Vec3;
+    bone: BoneDefinition;
+    attachment: Attachment | null;
+}
+interface MorphologyData {
+    _id?: string;
+    name: string;
+    bodyParts: BodyPartDefinition[];
+}
+declare const humanoidMorphology: MorphologyData;
+
+type MorphologyScene = {
+    root: THREE.Group;
+    groups: Record<string, THREE.Group>;
+};
+/**
+ * Builds a THREE.Group hierarchy from the new bodyParts-based MorphologyData.
+ * Each bodyPart becomes a group. Internal pivots become sub-groups.
+ * Returns the root group + a map of all groups by name.
+ */
+declare function buildFromMorphology(data: MorphologyData): MorphologyScene;
+interface BoneRefs {
+    root: THREE.Group;
+    hips: THREE.Group;
+    spine: THREE.Group;
+    neck: THREE.Group;
+    shoulderL: THREE.Group;
+    armL: THREE.Group;
+    forearmL: THREE.Group;
+    shoulderR: THREE.Group;
+    armR: THREE.Group;
+    forearmR: THREE.Group;
+    weaponMount: THREE.Group;
+    hipL: THREE.Group;
+    legL: THREE.Group;
+    shinL: THREE.Group;
+    hipR: THREE.Group;
+    legR: THREE.Group;
+    shinR: THREE.Group;
+}
+/**
+ * Manual skeleton builder — maintains exact same hierarchy as the original.
+ * Used by CharacterEntity, CharacterAssembler, Player, and animations.
+ * Does NOT depend on MorphologyData.
+ */
+declare function createSkeleton(): BoneRefs;
+
+declare class CharacterAssembler {
+    /** Attach all parts from config to bones. Returns map of slot -> mesh for tracking. */
+    static assemble(bones: BoneRefs, config: CharacterConfig, parts: Map<SlotName, THREE.Object3D>): void;
+    /** Swap a single part. Disposes the old mesh. */
+    static swapPart(bones: BoneRefs, parts: Map<SlotName, THREE.Object3D>, slot: SlotName, factory: PartFactory, palette: ColorPalette): void;
+}
+
+/**
+ * Data-driven character definition.
+ * Links a morphology with voxel parts and a color palette.
+ * Stored in MongoDB, loaded by the editor and game.
+ */
+interface CharacterDefinition {
+    _id?: string;
+    name: string;
+    morphologyId: string;
+    palette: ColorPalette;
+    /** Maps body part name → voxel part id */
+    parts: Record<string, string>;
+}
+
+interface Voxel {
+    x: number;
+    y: number;
+    z: number;
+    color: string;
+}
+interface VoxelPartData {
+    _id?: string;
+    name: string;
+    slot: string;
+    morphologyId: string;
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    voxelSize: number;
+    origin: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    voxels: Voxel[];
+    paletteMapping?: Record<string, 'skin' | 'primary' | 'secondary' | 'accent'>;
+}
+interface VoxelEditorMesh {
+    mesh: THREE.InstancedMesh;
+    /** Maps instanceId → voxel index in the voxels array */
+    instanceToVoxel: Map<number, number>;
+    /** Maps "x,y,z" → instanceId */
+    positionToInstance: Map<string, number>;
+}
+declare function buildEditorMesh(data: VoxelPartData): VoxelEditorMesh;
+declare function buildRuntimeMesh(data: VoxelPartData, palette?: Record<string, string>): THREE.Mesh;
+/** Get the face normal and adjacent position for placing a new voxel */
+declare function getAdjacentPosition(_face: THREE.Face | null, intersect: THREE.Intersection, voxelSize: number, origin: {
+    x: number;
+    y: number;
+    z: number;
+}): {
+    x: number;
+    y: number;
+    z: number;
+} | null;
+/** Get the voxel position that was clicked (for remove/paint) */
+declare function getClickedVoxelPosition(intersect: THREE.Intersection, voxelSize: number, origin: {
+    x: number;
+    y: number;
+    z: number;
+}): {
+    x: number;
+    y: number;
+    z: number;
+} | null;
+
+/**
+ * A single armor piece that overlays a body part.
+ * Uses the same voxel data format but rendered slightly larger
+ * on top of the base body part mesh.
+ */
+interface ArmorPieceData {
+    _id?: string;
+    name: string;
+    slot: string;
+    morphologyId: string;
+    scaleOffset: number;
+    voxelData: VoxelPartData;
+}
+interface ArmorSetData {
+    _id?: string;
+    name: string;
+    morphologyId: string;
+    pieceIds: string[];
+}
+
+/** Standard humanoid head */
+declare const humanHead: PartFactory;
+/** Skull */
+declare const skullHead: PartFactory;
+/** Helmet */
+declare const helmetHead: PartFactory;
+/** Hood */
+declare const hoodHead: PartFactory;
+
+/** Basic tunic/shirt */
+declare const tunicTorso: PartFactory;
+/** Skeleton ribcage */
+declare const ribcageTorso: PartFactory;
+/** Armored torso */
+declare const armorTorso: PartFactory;
+/** Rags */
+declare const ragsTorso: PartFactory;
+/** Robe with skirt */
+declare const robeTorso: PartFactory;
+
+declare const humanArm: PartFactory;
+declare const boneArm: PartFactory;
+declare const armorArm: PartFactory;
+declare const robeArm: PartFactory;
+declare const humanForearm: PartFactory;
+declare const boneForearm: PartFactory;
+declare const armorForearm: PartFactory;
+declare const robeForearm: PartFactory;
+
+declare const humanLeg: PartFactory;
+declare const boneLeg: PartFactory;
+declare const armorLeg: PartFactory;
+declare const robeLeg: PartFactory;
+declare const humanShin: PartFactory;
+declare const boneShin: PartFactory;
+declare const armorShin: PartFactory;
+declare const robeShin: PartFactory;
+
+/** Short sword */
+declare const sword: PartFactory;
+/** Battle axe */
+declare const axe: PartFactory;
+/** Staff */
+declare const staff: PartFactory;
+
+declare const playerConfig: CharacterConfig;
+declare const skeletonConfig: CharacterConfig;
+declare const zombieConfig: CharacterConfig;
+declare const warriorConfig: CharacterConfig;
+declare const mageConfig: CharacterConfig;
+
+declare function register(clip: THREE.AnimationClip): void;
+declare const AnimationLibrary: {
+    get(name: string): THREE.AnimationClip;
+    getAll(): THREE.AnimationClip[];
+    register: typeof register;
+};
+
+/**
+ * Serializable animation format for data-driven animations.
+ * Stored in MongoDB, exported via .igneokit, editable in the animation editor.
+ */
+interface BonePose {
+    boneName: string;
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+interface Keyframe {
+    time: number;
+    poses: BonePose[];
+}
+interface AnimationData {
+    _id?: string;
+    name: string;
+    duration: number;
+    loop: boolean;
+    morphologyId: string;
+    keyframes: Keyframe[];
+}
+
+/**
+ * Builds a THREE.AnimationClip from serializable AnimationData.
+ * Uses the morphology's bone hierarchy to build dot-notation track paths
+ * compatible with THREE's property binding system.
+ */
+declare function buildAnimationClip(data: AnimationData, morphology?: MorphologyData): THREE.AnimationClip;
+/**
+ * Converts an existing hardcoded AnimationClip to AnimationData format.
+ * Useful for migrating existing animations.
+ */
+declare function clipToAnimationData(clip: THREE.AnimationClip, morphologyId: string, loop?: boolean): AnimationData;
+
+/** Subtle breathing/bobbing animation */
+declare function createIdleClip(): THREE.AnimationClip;
+
+/** Walk cycle - arms and legs swing opposite */
+declare function createWalkClip(): THREE.AnimationClip;
+
+/** Single attack swing with right arm */
+declare function createAttackClip(): THREE.AnimationClip;
+
+export { type AnimationData, AnimationLibrary, type ArmorPieceData, type ArmorSetData, type Attachment, type BodyPartDefinition, type BoneDefinition, type BonePose, type BoneRefs, CharacterAssembler, type CharacterConfig, type CharacterDefinition, CharacterEntity, CollisionMap, type ColorPalette, type Connector, Engine, type EntityState, FieldScene, GameScene, InputManager, type InternalPivot, type Keyframe, type MapData, type MapObject, MapRenderer, type MorphologyData, type MorphologyScene, type PartFactory, type PivotAxes, Player, type Portal, type RotationConstraints, SceneManager, type SceneStateData, type SlotName, type SpawnPoint$1 as SpawnPoint, type TileData, type Vec3, type Voxel, type VoxelEditorMesh, type VoxelPartData, armorArm, armorForearm, armorLeg, armorShin, armorTorso, axe, boneArm, boneForearm, boneLeg, boneShin, buildAnimationClip, buildEditorMesh, buildFromMorphology, buildRuntimeMesh, clipToAnimationData, createAttackClip, createEmptyMap, createIdleClip, createIsometricCamera, createSkeleton, createWalkClip, createWorldGrid, getAdjacentPosition, getClickedVoxelPosition, helmetHead, hoodHead, humanArm, humanForearm, humanHead, humanLeg, humanShin, humanoidMorphology, mageConfig, playerConfig, ragsTorso, ribcageTorso, robeArm, robeForearm, robeLeg, robeShin, robeTorso, skeletonConfig, skullHead, staff, sword, tunicTorso, updateCameraTarget, warriorConfig, zombieConfig };