@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/native-engine/AudioEngine.d.ts

@@ -0,0 +1,246 @@
+/**
+ * @file AudioEngine.ts
+ * @description Audio Engine for Nice2Dev Game Engine
+ * PRO-1.11.3: Audio Engine
+ *
+ * Features:
+ * - Web Audio API integration
+ * - 3D Spatial Audio
+ * - Audio mixing and effects
+ * - Adaptive music system
+ * - Reverb zones
+ * - Audio pooling
+ */
+export type AudioState = 'playing' | 'paused' | 'stopped';
+export type EffectType = 'reverb' | 'delay' | 'distortion' | 'compressor' | 'equalizer' | 'lowpass' | 'highpass' | 'bandpass' | 'chorus' | 'flanger';
+export type SpatialModelType = 'HRTF' | 'equalpower';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface AudioSourceDescriptor {
+    url?: string;
+    buffer?: AudioBuffer;
+    loop?: boolean;
+    volume?: number;
+    pitch?: number;
+    spatial?: boolean;
+    position?: Vec3;
+    minDistance?: number;
+    maxDistance?: number;
+    rolloffFactor?: number;
+    coneInnerAngle?: number;
+    coneOuterAngle?: number;
+    coneOuterGain?: number;
+    channel?: string;
+    priority?: number;
+    userData?: unknown;
+}
+export interface AudioSource {
+    id: number;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    getState(): AudioState;
+    getCurrentTime(): number;
+    setCurrentTime(time: number): void;
+    getDuration(): number;
+    getVolume(): number;
+    setVolume(volume: number): void;
+    getPitch(): number;
+    setPitch(pitch: number): void;
+    isLooping(): boolean;
+    setLooping(loop: boolean): void;
+    isSpatial(): boolean;
+    getPosition(): Vec3;
+    setPosition(position: Vec3): void;
+    getOrientation(): Vec3;
+    setOrientation(forward: Vec3): void;
+    getMinDistance(): number;
+    setMinDistance(distance: number): void;
+    getMaxDistance(): number;
+    setMaxDistance(distance: number): void;
+    getRolloffFactor(): number;
+    setRolloffFactor(factor: number): void;
+    getConeInnerAngle(): number;
+    setConeInnerAngle(angle: number): void;
+    getConeOuterAngle(): number;
+    setConeOuterAngle(angle: number): void;
+    getConeOuterGain(): number;
+    setConeOuterGain(gain: number): void;
+    getChannel(): string;
+    setChannel(channel: string): void;
+    onEnded(callback: () => void): void;
+    offEnded(callback: () => void): void;
+    getUserData(): unknown;
+    setUserData(data: unknown): void;
+    dispose(): void;
+}
+export interface AudioChannelDescriptor {
+    name: string;
+    volume?: number;
+    muted?: boolean;
+    effects?: EffectDescriptor[];
+    parent?: string;
+}
+export interface AudioChannel {
+    name: string;
+    getVolume(): number;
+    setVolume(volume: number): void;
+    getFinalVolume(): number;
+    isMuted(): boolean;
+    setMuted(muted: boolean): void;
+    addEffect(effect: EffectDescriptor): AudioEffect;
+    removeEffect(effect: AudioEffect): void;
+    getEffects(): AudioEffect[];
+    getParent(): AudioChannel | null;
+    setParent(parent: AudioChannel | null): void;
+    getChildren(): AudioChannel[];
+    getSources(): AudioSource[];
+}
+export interface EffectDescriptor {
+    type: EffectType;
+    enabled?: boolean;
+    wetDryMix?: number;
+    params?: Record<string, number>;
+}
+export interface AudioEffect {
+    id: number;
+    type: EffectType;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    getWetDryMix(): number;
+    setWetDryMix(mix: number): void;
+    getParam(name: string): number;
+    setParam(name: string, value: number): void;
+    getParams(): Record<string, number>;
+}
+export interface ReverbZoneDescriptor {
+    position: Vec3;
+    innerRadius: number;
+    outerRadius: number;
+    presetIndex?: number;
+    roomSize?: number;
+    dampening?: number;
+    wetLevel?: number;
+    dryLevel?: number;
+    earlyReflections?: number;
+    lateReflections?: number;
+}
+export interface ReverbZone {
+    id: number;
+    getPosition(): Vec3;
+    setPosition(position: Vec3): void;
+    getInnerRadius(): number;
+    setInnerRadius(radius: number): void;
+    getOuterRadius(): number;
+    setOuterRadius(radius: number): void;
+    getRoomSize(): number;
+    setRoomSize(size: number): void;
+    getDampening(): number;
+    setDampening(dampening: number): void;
+    getWetLevel(): number;
+    setWetLevel(level: number): void;
+    getDryLevel(): number;
+    setDryLevel(level: number): void;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+}
+export interface MusicTrackDescriptor {
+    url: string;
+    name: string;
+    bpm?: number;
+    beats?: number;
+    layers?: MusicLayerDescriptor[];
+    transitions?: MusicTransitionDescriptor[];
+}
+export interface MusicLayerDescriptor {
+    url: string;
+    name: string;
+    volume?: number;
+    condition?: string;
+}
+export interface MusicTransitionDescriptor {
+    from: string;
+    to: string;
+    type: 'crossfade' | 'beat-sync' | 'bar-sync' | 'immediate';
+    duration?: number;
+}
+export interface MusicTrack {
+    name: string;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    getState(): AudioState;
+    getCurrentBeat(): number;
+    getCurrentBar(): number;
+    getBPM(): number;
+    getLayer(name: string): MusicLayer | undefined;
+    getLayers(): MusicLayer[];
+    setLayerActive(name: string, active: boolean): void;
+    getVolume(): number;
+    setVolume(volume: number): void;
+}
+export interface MusicLayer {
+    name: string;
+    isActive(): boolean;
+    setActive(active: boolean): void;
+    getVolume(): number;
+    setVolume(volume: number): void;
+}
+export interface AudioListener {
+    getPosition(): Vec3;
+    setPosition(position: Vec3): void;
+    getOrientation(): {
+        forward: Vec3;
+        up: Vec3;
+    };
+    setOrientation(forward: Vec3, up: Vec3): void;
+}
+export declare class AudioEngine {
+    private context;
+    private masterGain;
+    private sources;
+    private channels;
+    private effects;
+    private reverbZones;
+    private musicTracks;
+    private bufferCache;
+    private listener;
+    private nextId;
+    private spatialModel;
+    constructor();
+    initialize(): Promise<void>;
+    resume(): Promise<void>;
+    suspend(): Promise<void>;
+    isReady(): boolean;
+    createSource(descriptor: AudioSourceDescriptor): Promise<AudioSource>;
+    loadBuffer(url: string): Promise<AudioBuffer>;
+    getSource(id: number): AudioSource | undefined;
+    removeSource(source: AudioSource): void;
+    createChannel(descriptor: AudioChannelDescriptor): AudioChannel;
+    getChannel(name: string): AudioChannel | undefined;
+    getMasterVolume(): number;
+    setMasterVolume(volume: number): void;
+    getListener(): AudioListener;
+    setSpatialModel(model: SpatialModelType): void;
+    getSpatialModel(): SpatialModelType;
+    createReverbZone(descriptor: ReverbZoneDescriptor): ReverbZone;
+    getReverbZone(id: number): ReverbZone | undefined;
+    removeReverbZone(zone: ReverbZone): void;
+    updateReverbForListener(): void;
+    private applyReverb;
+    createMusicTrack(descriptor: MusicTrackDescriptor): Promise<MusicTrack>;
+    getMusicTrack(name: string): MusicTrack | undefined;
+    transitionTo(trackName: string, transitionType?: MusicTransitionDescriptor['type'], duration?: number): Promise<void>;
+    private getCurrentMusicTrack;
+    private crossfade;
+    private beatSyncTransition;
+    private barSyncTransition;
+    playOneShot(url: string, options?: Partial<AudioSourceDescriptor>): Promise<void>;
+    playSpatialOneShot(url: string, position: Vec3, options?: Partial<AudioSourceDescriptor>): Promise<void>;
+    update(): void;
+    dispose(): void;
+}
+export declare function createAudioEngine(): AudioEngine;

package/dist/types/native-engine/InputSystem.d.ts

@@ -0,0 +1,257 @@
+/**
+ * @file InputSystem.ts
+ * @description Input & UI System for Nice2Dev Game Engine
+ * PRO-1.11.5: Input & UI System
+ *
+ * Features:
+ * - Keyboard, Mouse, Gamepad, Touch input
+ * - Input mapping and actions
+ * - Input rebinding
+ * - In-game UI system
+ * - Immediate mode GUI (IMGUI-style)
+ */
+export type InputDeviceType = 'keyboard' | 'mouse' | 'gamepad' | 'touch';
+export type KeyState = 'up' | 'down' | 'pressed' | 'released';
+export type MouseButton = 'left' | 'middle' | 'right' | 'back' | 'forward';
+export type GamepadButton = 'a' | 'b' | 'x' | 'y' | 'lb' | 'rb' | 'lt' | 'rt' | 'back' | 'start' | 'ls' | 'rs' | 'dpad-up' | 'dpad-down' | 'dpad-left' | 'dpad-right';
+export type GamepadAxis = 'left-x' | 'left-y' | 'right-x' | 'right-y' | 'lt' | 'rt';
+export interface InputBinding {
+    type: InputDeviceType;
+    key?: string;
+    button?: MouseButton | GamepadButton;
+    axis?: GamepadAxis;
+    modifiers?: string[];
+    scale?: number;
+    deadzone?: number;
+    invert?: boolean;
+}
+export interface InputAction {
+    name: string;
+    bindings: InputBinding[];
+    type: 'button' | 'axis' | 'vector2';
+}
+export interface InputMap {
+    name: string;
+    actions: InputAction[];
+    enabled: boolean;
+}
+export interface KeyboardState {
+    isKeyDown(key: string): boolean;
+    isKeyUp(key: string): boolean;
+    wasKeyPressed(key: string): boolean;
+    wasKeyReleased(key: string): boolean;
+    getKeysDown(): string[];
+}
+export interface MouseState {
+    position: {
+        x: number;
+        y: number;
+    };
+    delta: {
+        x: number;
+        y: number;
+    };
+    scroll: {
+        x: number;
+        y: number;
+    };
+    isButtonDown(button: MouseButton): boolean;
+    isButtonUp(button: MouseButton): boolean;
+    wasButtonPressed(button: MouseButton): boolean;
+    wasButtonReleased(button: MouseButton): boolean;
+    isLocked(): boolean;
+}
+export interface GamepadState {
+    index: number;
+    id: string;
+    connected: boolean;
+    buttons: Map<GamepadButton, number>;
+    axes: Map<GamepadAxis, number>;
+    getButton(button: GamepadButton): number;
+    isButtonDown(button: GamepadButton, threshold?: number): boolean;
+    wasButtonPressed(button: GamepadButton, threshold?: number): boolean;
+    wasButtonReleased(button: GamepadButton, threshold?: number): boolean;
+    getAxis(axis: GamepadAxis): number;
+    getLeftStick(): {
+        x: number;
+        y: number;
+    };
+    getRightStick(): {
+        x: number;
+        y: number;
+    };
+    setVibration(lowFrequency: number, highFrequency: number, duration: number): void;
+}
+export interface TouchState {
+    touches: Touch[];
+    activeTouches: number;
+}
+export interface Touch {
+    id: number;
+    position: {
+        x: number;
+        y: number;
+    };
+    startPosition: {
+        x: number;
+        y: number;
+    };
+    delta: {
+        x: number;
+        y: number;
+    };
+    pressure: number;
+    phase: 'began' | 'moved' | 'stationary' | 'ended' | 'cancelled';
+}
+export declare class InputSystem {
+    private canvas;
+    private inputMaps;
+    private activeInputMaps;
+    private keyboard;
+    private mouse;
+    private gamepads;
+    private touch;
+    private actionCallbacks;
+    constructor();
+    initialize(canvas: HTMLCanvasElement): void;
+    dispose(): void;
+    createInputMap(name: string, actions: InputAction[]): InputMap;
+    getInputMap(name: string): InputMap | undefined;
+    enableInputMap(name: string): void;
+    disableInputMap(name: string): void;
+    getActionValue(actionName: string): number;
+    getActionVector2(actionName: string): {
+        x: number;
+        y: number;
+    };
+    isActionPressed(actionName: string): boolean;
+    wasActionJustPressed(actionName: string): boolean;
+    wasActionJustReleased(actionName: string): boolean;
+    private evaluateAction;
+    private evaluateActionVector2;
+    private evaluateBinding;
+    private wasBindingJustPressed;
+    private wasBindingJustReleased;
+    private checkModifiers;
+    onAction(actionName: string, callback: (value: number | {
+        x: number;
+        y: number;
+    }) => void): void;
+    offAction(actionName: string, callback: (value: number | {
+        x: number;
+        y: number;
+    }) => void): void;
+    getKeyboard(): KeyboardState;
+    getMouse(): MouseState;
+    getGamepad(index: number): GamepadState | undefined;
+    getGamepads(): GamepadState[];
+    getTouch(): TouchState;
+    lockMouse(): void;
+    unlockMouse(): void;
+    isMouseLocked(): boolean;
+    update(): void;
+    endFrame(): void;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleMouseMove;
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleWheel;
+    private handlePointerLockChange;
+    private handleGamepadConnected;
+    private handleGamepadDisconnected;
+    private pollGamepads;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private handleTouchCancel;
+}
+export interface UIContext {
+    beginWindow(title: string, x: number, y: number, width: number, height: number): boolean;
+    endWindow(): void;
+    beginPanel(id: string): void;
+    endPanel(): void;
+    text(content: string): void;
+    button(label: string): boolean;
+    checkbox(label: string, checked: boolean): boolean;
+    slider(label: string, value: number, min: number, max: number): number;
+    textInput(label: string, value: string): string;
+    dropdown(label: string, selected: number, options: string[]): number;
+    colorPicker(label: string, color: {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    }): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    image(src: string, width: number, height: number): void;
+    progressBar(value: number, max?: number): void;
+    sameLine(): void;
+    newLine(): void;
+    indent(): void;
+    unindent(): void;
+    separator(): void;
+    spacing(amount: number): void;
+    tooltip(content: string): void;
+    isHovered(): boolean;
+}
+export declare class UISystem implements UIContext {
+    private canvas;
+    private ctx;
+    private stateStack;
+    private currentState;
+    private hotWidget;
+    private activeWidget;
+    private mousePos;
+    private mouseDown;
+    private mouseClicked;
+    private keyboardInput;
+    private _isHovered;
+    private style;
+    constructor(canvas: HTMLCanvasElement);
+    private createState;
+    beginFrame(): void;
+    endFrame(): void;
+    beginWindow(title: string, x: number, y: number, width: number, height: number): boolean;
+    endWindow(): void;
+    beginPanel(_id: string): void;
+    endPanel(): void;
+    text(content: string): void;
+    button(label: string): boolean;
+    checkbox(label: string, checked: boolean): boolean;
+    slider(label: string, value: number, min: number, max: number): number;
+    textInput(label: string, value: string): string;
+    dropdown(label: string, selected: number, options: string[]): number;
+    colorPicker(label: string, color: {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    }): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    image(_src: string, width: number, height: number): void;
+    progressBar(value: number, max?: number): void;
+    sameLine(): void;
+    newLine(): void;
+    indent(): void;
+    unindent(): void;
+    separator(): void;
+    spacing(amount: number): void;
+    tooltip(content: string): void;
+    isHovered(): boolean;
+    private getX;
+    private getY;
+    private advanceCursor;
+    private isInRect;
+    private roundRect;
+}
+export declare function createInputSystem(): InputSystem;
+export declare function createUISystem(canvas: HTMLCanvasElement): UISystem;