@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/systems/NiceTween.d.ts

@@ -0,0 +1,164 @@
+export type TweenId = string;
+export type EasingName = 'linear' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce';
+export type EasingFn = (t: number) => number;
+export type LoopMode = 'none' | 'loop' | 'pingpong' | 'yoyo';
+export declare const EASINGS: Record<EasingName, EasingFn>;
+export interface TweenProperty<T = unknown> {
+    key: string;
+    from: T;
+    to: T;
+    current?: T;
+}
+export interface TweenConfig<T = Record<string, number>> {
+    /** Target object */
+    target: T;
+    /** Properties to tween { x: 100, y: 200 } */
+    properties: Partial<Record<keyof T, number | string>>;
+    /** Duration in seconds */
+    duration: number;
+    /** Easing function */
+    easing?: EasingName | EasingFn;
+    /** Delay before start */
+    delay?: number;
+    /** Loop mode */
+    loop?: LoopMode;
+    /** Number of loops (-1 = infinite) */
+    loopCount?: number;
+    /** Time scale */
+    timeScale?: number;
+    /** Start paused */
+    paused?: boolean;
+    /** Relative values (add to current) */
+    relative?: boolean;
+    /** Callbacks */
+    onStart?: () => void;
+    onUpdate?: (progress: number) => void;
+    onComplete?: () => void;
+    onLoop?: (loopIndex: number) => void;
+}
+export interface TweenState {
+    id: TweenId;
+    elapsed: number;
+    delayRemaining: number;
+    progress: number;
+    easedProgress: number;
+    loopsCompleted: number;
+    direction: 1 | -1;
+    started: boolean;
+    paused: boolean;
+    finished: boolean;
+    timeScale: number;
+}
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface RGBA extends RGB {
+    a: number;
+}
+export type TweenEventType = 'tween-created' | 'tween-started' | 'tween-update' | 'tween-paused' | 'tween-resumed' | 'tween-completed' | 'tween-loop' | 'tween-cancelled';
+export interface TweenEvent {
+    type: TweenEventType;
+    timestamp: number;
+    tweenId: TweenId;
+    data?: unknown;
+}
+export type TweenEventCallback = (event: TweenEvent) => void;
+declare class Tween<T extends Record<string, unknown>> {
+    readonly id: TweenId;
+    private target;
+    private properties;
+    private config;
+    private state;
+    private parentSystem?;
+    constructor(id: TweenId, config: TweenConfig<T>, parentSystem?: NiceTween);
+    update(deltaTime: number): boolean;
+    private handleCompletion;
+    pause(): this;
+    resume(): this;
+    stop(): this;
+    reset(): this;
+    setTimeScale(scale: number): this;
+    delay(seconds: number): this;
+    duration(seconds: number): this;
+    ease(easing: EasingName | EasingFn): this;
+    loop(mode?: LoopMode, count?: number): this;
+    onStart(callback: () => void): this;
+    onUpdate(callback: (progress: number) => void): this;
+    onComplete(callback: () => void): this;
+    getState(): TweenState;
+    isFinished(): boolean;
+    isPaused(): boolean;
+    getProgress(): number;
+}
+export declare class NiceTween {
+    private tweens;
+    private eventListeners;
+    private idCounter;
+    private globalTimeScale;
+    private globalPaused;
+    on(event: TweenEventType, callback: TweenEventCallback): () => void;
+    private emit;
+    create<T extends Record<string, unknown>>(config: TweenConfig<T>): Tween<T>;
+    to<T extends Record<string, unknown>>(target: T, properties: Partial<Record<keyof T, number | string>>, duration: number): Tween<T>;
+    from<T extends Record<string, unknown>>(target: T, properties: Partial<Record<keyof T, number | string>>, duration: number): Tween<T>;
+    fromTo<T extends Record<string, unknown>>(target: T, fromProps: Partial<Record<keyof T, number>>, toProps: Partial<Record<keyof T, number>>, duration: number): Tween<T>;
+    sequence(): TweenSequence;
+    parallel(...tweens: Tween<Record<string, unknown>>[]): Promise<void>;
+    update(deltaTime: number): void;
+    get(id: TweenId): Tween<Record<string, unknown>> | undefined;
+    pauseAll(): void;
+    resumeAll(): void;
+    stopAll(): void;
+    setGlobalTimeScale(scale: number): void;
+    getActiveCount(): number;
+    destroy(): void;
+}
+export declare class TweenSequence {
+    private system;
+    private items;
+    private currentIndex;
+    private currentWait;
+    private running;
+    private paused;
+    private onCompleteCallback?;
+    constructor(system: NiceTween);
+    add<T extends Record<string, unknown>>(target: T, properties: Partial<Record<keyof T, number | string>>, duration: number, offset?: number): this;
+    call(callback: () => void): this;
+    wait(duration: number): this;
+    onComplete(callback: () => void): this;
+    play(): this;
+    pause(): this;
+    resume(): this;
+    stop(): this;
+    private processNext;
+}
+export declare function createTweenSystem(): NiceTween;
+export declare function lerpColor(from: RGB, to: RGB, t: number): RGB;
+export declare function hexToRgb(hex: string): RGB;
+export declare function rgbToHex(rgb: RGB): string;
+export declare function tweenPath(points: Array<{
+    x: number;
+    y: number;
+}>, t: number): {
+    x: number;
+    y: number;
+};
+export declare function bezierPoint(p0: {
+    x: number;
+    y: number;
+}, p1: {
+    x: number;
+    y: number;
+}, p2: {
+    x: number;
+    y: number;
+}, p3: {
+    x: number;
+    y: number;
+}, t: number): {
+    x: number;
+    y: number;
+};
+export { EASINGS as TWEEN_EASINGS };

package/dist/types/systems/NiceUI.d.ts

@@ -0,0 +1,364 @@
+/**
+ * NiceUI - Game Engine UI System
+ *
+ * Comprehensive game UI system supporting:
+ * - Widget hierarchy and layout
+ * - Anchoring and positioning
+ * - Input handling (mouse, touch, gamepad)
+ * - Animations and transitions
+ * - Theming and styling
+ * - HUD elements
+ * - Menus and dialogs
+ * - Health bars, minimaps, inventories
+ * - Focus and navigation
+ * - Localization integration
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+export type WidgetId = string;
+export type LayerId = string;
+export type StyleId = string;
+export type WidgetType = 'panel' | 'label' | 'button' | 'image' | 'progressBar' | 'slider' | 'checkbox' | 'textInput' | 'dropdown' | 'list' | 'scrollView' | 'grid' | 'window' | 'tooltip' | 'custom';
+export type AnchorPreset = 'topLeft' | 'topCenter' | 'topRight' | 'middleLeft' | 'middleCenter' | 'middleRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'stretchHorizontal' | 'stretchVertical' | 'stretchAll';
+export type LayoutType = 'none' | 'horizontal' | 'vertical' | 'grid';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface TextStyle {
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: 'normal' | 'bold' | 'light';
+    fontStyle?: 'normal' | 'italic';
+    color?: Color;
+    alignment?: 'left' | 'center' | 'right';
+    verticalAlignment?: 'top' | 'middle' | 'bottom';
+    lineHeight?: number;
+    letterSpacing?: number;
+    wordWrap?: boolean;
+    overflow?: 'visible' | 'hidden' | 'ellipsis';
+    shadow?: {
+        offset: Vec2;
+        blur: number;
+        color: Color;
+    };
+    outline?: {
+        width: number;
+        color: Color;
+    };
+}
+export interface BackgroundStyle {
+    color?: Color;
+    gradient?: {
+        type: 'linear' | 'radial';
+        colors: Color[];
+        stops?: number[];
+        angle?: number;
+    };
+    image?: string;
+    imageScale?: 'stretch' | 'fit' | 'fill' | 'tile' | 'none';
+    imageTint?: Color;
+}
+export interface BorderStyle {
+    width: number;
+    color: Color;
+    radius?: number | {
+        topLeft: number;
+        topRight: number;
+        bottomRight: number;
+        bottomLeft: number;
+    };
+}
+export interface WidgetStyle {
+    id?: StyleId;
+    name?: string;
+    width?: number | 'auto' | string;
+    height?: number | 'auto' | string;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    padding?: Padding | number;
+    margin?: Padding | number;
+    background?: BackgroundStyle;
+    border?: BorderStyle;
+    opacity?: number;
+    text?: TextStyle;
+    cursor?: 'default' | 'pointer' | 'text' | 'grab' | 'not-allowed' | 'none';
+    transition?: {
+        properties: string[];
+        duration: number;
+        easing?: string;
+        delay?: number;
+    };
+    hover?: Partial<WidgetStyle>;
+    active?: Partial<WidgetStyle>;
+    disabled?: Partial<WidgetStyle>;
+    focused?: Partial<WidgetStyle>;
+}
+export interface Theme {
+    id: string;
+    name: string;
+    styles: Map<StyleId, WidgetStyle>;
+    colors: {
+        primary: Color;
+        secondary: Color;
+        background: Color;
+        surface: Color;
+        error: Color;
+        success: Color;
+        warning: Color;
+        text: Color;
+        textSecondary: Color;
+    };
+    typography: {
+        fontFamily: string;
+        fontSizeBase: number;
+        fontSizeSmall: number;
+        fontSizeLarge: number;
+    };
+}
+export interface WidgetConfig {
+    id?: WidgetId;
+    type: WidgetType;
+    name?: string;
+    position?: Vec2;
+    size?: Vec2;
+    anchor?: AnchorPreset | {
+        min: Vec2;
+        max: Vec2;
+    };
+    pivot?: Vec2;
+    offset?: Rect;
+    layout?: {
+        type: LayoutType;
+        spacing?: number;
+        padding?: Padding | number;
+        childAlignment?: 'start' | 'center' | 'end' | 'stretch';
+        reverseOrder?: boolean;
+        gridColumns?: number;
+        gridCellSize?: Vec2;
+    };
+    style?: WidgetStyle;
+    styleId?: StyleId;
+    text?: string;
+    image?: string;
+    value?: number | string | boolean;
+    placeholder?: string;
+    visible?: boolean;
+    enabled?: boolean;
+    focusable?: boolean;
+    draggable?: boolean;
+    children?: WidgetConfig[];
+    onClick?: (widget: Widget) => void;
+    onHover?: (widget: Widget, hovering: boolean) => void;
+    onFocus?: (widget: Widget, focused: boolean) => void;
+    onChange?: (widget: Widget, value: unknown) => void;
+    onDrag?: (widget: Widget, delta: Vec2) => void;
+    data?: Record<string, unknown>;
+}
+export interface Widget {
+    id: WidgetId;
+    type: WidgetType;
+    name: string;
+    parent?: Widget;
+    children: Widget[];
+    layer: LayerId;
+    localPosition: Vec2;
+    globalPosition: Vec2;
+    size: Vec2;
+    pivot: Vec2;
+    scale: Vec2;
+    rotation: number;
+    computedRect: Rect;
+    contentRect: Rect;
+    layout?: WidgetConfig['layout'];
+    anchor: {
+        min: Vec2;
+        max: Vec2;
+    };
+    offset: Rect;
+    style: WidgetStyle;
+    computedStyle: WidgetStyle;
+    text: string;
+    image?: string;
+    value: unknown;
+    placeholder: string;
+    visible: boolean;
+    enabled: boolean;
+    focusable: boolean;
+    draggable: boolean;
+    isHovered: boolean;
+    isFocused: boolean;
+    isPressed: boolean;
+    isDragging: boolean;
+    onClick?: (widget: Widget) => void;
+    onHover?: (widget: Widget, hovering: boolean) => void;
+    onFocus?: (widget: Widget, focused: boolean) => void;
+    onChange?: (widget: Widget, value: unknown) => void;
+    onDrag?: (widget: Widget, delta: Vec2) => void;
+    data: Record<string, unknown>;
+}
+export interface UILayer {
+    id: LayerId;
+    name: string;
+    sortOrder: number;
+    visible: boolean;
+    widgets: WidgetId[];
+}
+export interface InputState {
+    mousePosition: Vec2;
+    mouseButtons: boolean[];
+    touches: Array<{
+        id: number;
+        position: Vec2;
+        phase: 'began' | 'moved' | 'ended';
+    }>;
+    hoveredWidget?: WidgetId;
+    focusedWidget?: WidgetId;
+    draggedWidget?: WidgetId;
+    dragStart?: Vec2;
+}
+export type EasingFunction = (t: number) => number;
+export interface UIAnimation {
+    id: string;
+    widgetId: WidgetId;
+    property: string;
+    from: unknown;
+    to: unknown;
+    duration: number;
+    elapsed: number;
+    easing: EasingFunction;
+    onComplete?: () => void;
+    isPlaying: boolean;
+}
+export type UIEventType = 'click' | 'double-click' | 'hover-enter' | 'hover-exit' | 'focus' | 'blur' | 'value-changed' | 'drag-start' | 'drag' | 'drag-end' | 'key-down' | 'key-up' | 'submit';
+export interface UIEvent {
+    type: UIEventType;
+    widget: Widget;
+    value?: unknown;
+    position?: Vec2;
+    delta?: Vec2;
+    key?: string;
+    timestamp: number;
+}
+export type UIEventCallback = (event: UIEvent) => void;
+export interface UIConfig {
+    screenWidth: number;
+    screenHeight: number;
+    pixelRatio: number;
+    defaultFontFamily: string;
+    defaultFontSize: number;
+    doubleClickTime: number;
+    dragThreshold: number;
+    tooltipDelay: number;
+    focusNavigation: boolean;
+    gamepadEnabled: boolean;
+}
+export declare const DEFAULT_UI_CONFIG: UIConfig;
+export declare const DEFAULT_STYLE: WidgetStyle;
+export declare const Easings: Record<string, EasingFunction>;
+export declare class NiceUI extends EventEmitter {
+    private config;
+    private widgets;
+    private layers;
+    private rootWidgets;
+    private themes;
+    private currentTheme?;
+    private styles;
+    private animations;
+    private inputState;
+    private lastClickTime;
+    private lastClickWidget?;
+    private tooltipTimer?;
+    private destroyed;
+    constructor(config?: Partial<UIConfig>);
+    createLayer(id: LayerId, sortOrder?: number): UILayer;
+    getLayer(layerId: LayerId): UILayer | undefined;
+    setLayerVisible(layerId: LayerId, visible: boolean): void;
+    removeLayer(layerId: LayerId): void;
+    createWidget(config: WidgetConfig, parentId?: WidgetId, layerId?: LayerId): Widget;
+    getWidget(widgetId: WidgetId): Widget | undefined;
+    getWidgetByName(name: string): Widget | undefined;
+    removeWidget(widgetId: WidgetId): void;
+    setWidgetPosition(widgetId: WidgetId, position: Vec2): void;
+    setWidgetSize(widgetId: WidgetId, size: Vec2): void;
+    setWidgetVisible(widgetId: WidgetId, visible: boolean): void;
+    setWidgetEnabled(widgetId: WidgetId, enabled: boolean): void;
+    setWidgetText(widgetId: WidgetId, text: string): void;
+    setWidgetValue(widgetId: WidgetId, value: unknown): void;
+    setWidgetStyle(widgetId: WidgetId, style: Partial<WidgetStyle>): void;
+    private updateWidgetLayout;
+    private applyLayout;
+    refreshLayout(): void;
+    registerStyle(id: StyleId, style: WidgetStyle): void;
+    getStyle(styleId: StyleId): WidgetStyle | undefined;
+    private mergeStyles;
+    private updateComputedStyle;
+    registerTheme(theme: Theme): void;
+    setTheme(themeId: string): void;
+    getTheme(): Theme | undefined;
+    handleMouseMove(x: number, y: number): void;
+    handleMouseDown(button?: number): void;
+    handleMouseUp(button?: number): void;
+    handleKeyDown(key: string): void;
+    handleKeyUp(key: string): void;
+    setFocus(widgetId: WidgetId): void;
+    clearFocus(): void;
+    focusNext(): void;
+    focusPrevious(): void;
+    hitTest(x: number, y: number): Widget | undefined;
+    private hitTestWidget;
+    animate(widgetId: WidgetId, property: string, to: unknown, duration: number, options?: {
+        easing?: string | EasingFunction;
+        onComplete?: () => void;
+    }): string;
+    stopAnimation(animationId: string): void;
+    stopAllAnimations(widgetId?: WidgetId): void;
+    private getWidgetProperty;
+    private setWidgetProperty;
+    update(deltaTime: number): void;
+    private interpolateValue;
+    private isVec2;
+    private isColor;
+    private emitEvent;
+    on(event: 'ui', callback: UIEventCallback): this;
+    off(event: 'ui', callback: UIEventCallback): this;
+    getAllWidgets(): Widget[];
+    getVisibleWidgets(): Widget[];
+    setScreenSize(width: number, height: number): void;
+    getStats(): {
+        widgets: number;
+        layers: number;
+        animations: number;
+        styles: number;
+        themes: number;
+    };
+    clear(): void;
+    destroy(): void;
+}
+export declare function createUISystem(config?: Partial<UIConfig>): NiceUI;
+export declare function createPanel(ui: NiceUI, config?: Partial<WidgetConfig>): Widget;
+export declare function createLabel(ui: NiceUI, text: string, config?: Partial<WidgetConfig>): Widget;
+export declare function createButton(ui: NiceUI, text: string, onClick: (widget: Widget) => void, config?: Partial<WidgetConfig>): Widget;
+export declare function createProgressBar(ui: NiceUI, value: number, config?: Partial<WidgetConfig>): Widget;
+export declare function createTextInput(ui: NiceUI, placeholder?: string, config?: Partial<WidgetConfig>): Widget;