@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,502 @@
+/**
+ * NiceGesture - Touch Gesture Recognition System
+ *
+ * Comprehensive gesture recognition system for touch and
+ * mouse input with support for custom gestures.
+ *
+ * Features:
+ * - Multi-touch support
+ * - Built-in gestures (tap, swipe, pinch, rotate)
+ * - Custom gesture recognition
+ * - Gesture recording
+ * - Pattern matching
+ * - Gesture combos
+ * - Motion detection
+ * - Device orientation
+ * - Haptic feedback
+ * - Gesture visualization
+ *
+ * @packageDocumentation
+ */
+/** Local minimal EventEmitter wrapper that tolerates loose .on/.off signatures used by NiceGesture. */
+declare class NiceGestureEmitter {
+    private _emitter;
+    emit(event: string, ...args: unknown[]): boolean;
+    removeAllListeners(event?: string): void;
+}
+/** Unique gesture ID */
+export type GestureId = string;
+/** Touch ID */
+export type TouchId = number;
+/** Gesture type */
+export type GestureType = 'tap' | 'double_tap' | 'long_press' | 'swipe' | 'pan' | 'pinch' | 'rotate' | 'two_finger_tap' | 'three_finger_tap' | 'shake' | 'tilt' | 'custom';
+/** Gesture state */
+export type GestureState = 'possible' | 'began' | 'changed' | 'ended' | 'cancelled' | 'failed';
+/** Swipe direction */
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+/** Gesture priority */
+export type GesturePriority = 'low' | 'normal' | 'high' | 'exclusive';
+/** Point */
+export interface Point {
+    x: number;
+    y: number;
+}
+/** Touch point */
+export interface TouchPoint extends Point {
+    id: TouchId;
+    force: number;
+    radius: number;
+    timestamp: number;
+}
+/** Gesture data */
+export interface GestureData {
+    id: GestureId;
+    type: GestureType;
+    state: GestureState;
+    timestamp: number;
+    touches: TouchPoint[];
+    center: Point;
+    startCenter?: Point;
+    velocity: Point;
+    direction?: SwipeDirection;
+    scale?: number;
+    rotation?: number;
+    deltaX: number;
+    deltaY: number;
+    distance: number;
+    duration: number;
+    target?: Element;
+    metadata?: Record<string, unknown>;
+}
+/** Gesture recognizer config */
+export interface GestureRecognizerConfig {
+    id: string;
+    type: GestureType;
+    enabled: boolean;
+    priority: GesturePriority;
+    minTouches: number;
+    maxTouches: number;
+    threshold: number;
+    options: Record<string, unknown>;
+}
+/** Tap config */
+export interface TapConfig {
+    maxDuration: number;
+    maxMovement: number;
+    numberOfTaps: number;
+    numberOfTouches: number;
+    tapInterval: number;
+}
+/** Swipe config */
+export interface SwipeConfig {
+    minVelocity: number;
+    minDistance: number;
+    maxDuration: number;
+    direction: SwipeDirection | 'any' | 'horizontal' | 'vertical';
+}
+/** Pan config */
+export interface PanConfig {
+    minDistance: number;
+    direction: 'any' | 'horizontal' | 'vertical';
+}
+/** Pinch config */
+export interface PinchConfig {
+    minScale: number;
+}
+/** Rotate config */
+export interface RotateConfig {
+    minRotation: number;
+}
+/** Long press config */
+export interface LongPressConfig {
+    minDuration: number;
+    maxMovement: number;
+    numberOfTouches: number;
+}
+/** Custom gesture pattern */
+export interface CustomGesturePattern {
+    id: GestureId;
+    name: string;
+    points: Point[];
+    normalized: Point[];
+    direction?: number;
+    aspectRatio?: number;
+}
+/** Gesture combo */
+export interface GestureCombo {
+    id: string;
+    name: string;
+    gestures: GestureType[];
+    maxDelay: number;
+    callback?: (data: GestureData[]) => void;
+}
+/** Motion data */
+export interface MotionData {
+    acceleration: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    accelerationWithGravity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotationRate: {
+        alpha: number;
+        beta: number;
+        gamma: number;
+    };
+    interval: number;
+}
+/** Orientation data */
+export interface OrientationData {
+    alpha: number;
+    beta: number;
+    gamma: number;
+}
+/** Haptic pattern */
+export interface HapticPattern {
+    type: 'light' | 'medium' | 'heavy' | 'selection' | 'notification' | 'custom';
+    duration?: number;
+    intensity?: number;
+    pattern?: number[];
+}
+/** Gesture handler */
+export interface GestureHandler {
+    id: string;
+    type: GestureType | GestureType[];
+    target?: HTMLElement | string;
+    callback: (data: GestureData) => void;
+    priority?: GesturePriority;
+}
+/** Recorded gesture */
+export interface RecordedGesture {
+    id: string;
+    name: string;
+    points: Point[];
+    timestamps: number[];
+    duration: number;
+    recordedAt: number;
+}
+/** Gesture event types */
+export type GestureEventType = 'gesture_started' | 'gesture_changed' | 'gesture_ended' | 'gesture_cancelled' | 'gesture_recognized' | 'custom_gesture_matched' | 'combo_triggered' | 'motion_detected' | 'orientation_changed' | 'shake_detected';
+/** Gesture event */
+export interface GestureEvent {
+    type: GestureEventType;
+    timestamp: number;
+    gesture?: GestureData;
+    data?: unknown;
+}
+/** Gesture event callback */
+export type GestureEventCallback = (event: GestureEvent) => void;
+/** Gesture system configuration */
+export interface GestureConfig {
+    tap: TapConfig;
+    swipe: SwipeConfig;
+    pan: PanConfig;
+    pinch: PinchConfig;
+    rotate: RotateConfig;
+    longPress: LongPressConfig;
+    motionEnabled: boolean;
+    shakeThreshold: number;
+    shakeMinMotions: number;
+    orientationEnabled: boolean;
+    hapticEnabled: boolean;
+    debugMode: boolean;
+    preventDefaults: boolean;
+    touchSlop: number;
+}
+/** Default tap config */
+export declare const DEFAULT_TAP_CONFIG: TapConfig;
+/** Default swipe config */
+export declare const DEFAULT_SWIPE_CONFIG: SwipeConfig;
+/** Default pan config */
+export declare const DEFAULT_PAN_CONFIG: PanConfig;
+/** Default pinch config */
+export declare const DEFAULT_PINCH_CONFIG: PinchConfig;
+/** Default rotate config */
+export declare const DEFAULT_ROTATE_CONFIG: RotateConfig;
+/** Default long press config */
+export declare const DEFAULT_LONG_PRESS_CONFIG: LongPressConfig;
+/** Default configuration */
+export declare const DEFAULT_GESTURE_CONFIG: GestureConfig;
+/**
+ * Touch gesture recognition system
+ */
+export declare class NiceGesture extends NiceGestureEmitter {
+    private config;
+    private handlers;
+    private customPatterns;
+    private combos;
+    private targets;
+    private activeTouches;
+    private gestureState;
+    private startPosition;
+    private tapCount;
+    private lastTapTime;
+    private longPressTimer?;
+    private isLongPressActive;
+    private initialDistance;
+    private initialAngle;
+    private currentScale;
+    private currentRotation;
+    private recentGestures;
+    private recordedPoints;
+    private isRecording;
+    private recordingStartTime;
+    private shakeCount;
+    private lastShakeTime;
+    private lastMotion;
+    private lastOrientation;
+    private boundElement?;
+    constructor(config?: Partial<GestureConfig>);
+    /**
+     * Emit gesture event
+     */
+    private emitEvent;
+    /**
+     * Initialize gesture system
+     */
+    private initialize;
+    /**
+     * Bind to element
+     */
+    bind(element: HTMLElement | string): void;
+    /**
+     * Unbind from element
+     */
+    unbind(): void;
+    /**
+     * Register gesture handler
+     */
+    on(type: GestureType | GestureType[], callback: (data: GestureData) => void, options?: {
+        target?: HTMLElement | string;
+        priority?: GesturePriority;
+    }): string;
+    /**
+     * Unregister handler
+     */
+    off(handlerId: string): void;
+    /**
+     * Register tap handler
+     */
+    onTap(callback: (data: GestureData) => void, options?: {
+        numberOfTaps?: number;
+    }): string;
+    /**
+     * Register double tap handler
+     */
+    onDoubleTap(callback: (data: GestureData) => void): string;
+    /**
+     * Register long press handler
+     */
+    onLongPress(callback: (data: GestureData) => void): string;
+    /**
+     * Register swipe handler
+     */
+    onSwipe(callback: (data: GestureData) => void, direction?: SwipeDirection | 'horizontal' | 'vertical'): string;
+    /**
+     * Register pan handler
+     */
+    onPan(callback: (data: GestureData) => void): string;
+    /**
+     * Register pinch handler
+     */
+    onPinch(callback: (data: GestureData) => void): string;
+    /**
+     * Register rotate handler
+     */
+    onRotate(callback: (data: GestureData) => void): string;
+    /**
+     * Handle touch start
+     */
+    private handleTouchStart;
+    /**
+     * Handle touch move
+     */
+    private handleTouchMove;
+    /**
+     * Handle touch end
+     */
+    private handleTouchEnd;
+    /**
+     * Handle touch cancel
+     */
+    private handleTouchCancel;
+    private isMouseDown;
+    private mouseStartPoint?;
+    /**
+     * Handle mouse down
+     */
+    private handleMouseDown;
+    /**
+     * Handle mouse move
+     */
+    private handleMouseMove;
+    /**
+     * Handle mouse up
+     */
+    private handleMouseUp;
+    /**
+     * Process tap
+     */
+    private processTap;
+    /**
+     * Start long press timer
+     */
+    private startLongPressTimer;
+    /**
+     * Cancel long press
+     */
+    private cancelLongPress;
+    /**
+     * Process swipe
+     */
+    private processSwipe;
+    /**
+     * Get swipe direction
+     */
+    private getSwipeDirection;
+    /**
+     * Process pan
+     */
+    private processPan;
+    /**
+     * End pan
+     */
+    private endPan;
+    /**
+     * Process pinch
+     */
+    private processPinch;
+    /**
+     * End pinch
+     */
+    private endPinch;
+    /**
+     * Process rotate
+     */
+    private processRotate;
+    /**
+     * End rotate
+     */
+    private endRotate;
+    /**
+     * Start recording gesture
+     */
+    startRecording(): void;
+    /**
+     * Stop recording
+     */
+    stopRecording(): RecordedGesture | undefined;
+    /**
+     * Register custom gesture
+     */
+    registerCustomGesture(name: string, points: Point[]): CustomGesturePattern;
+    /**
+     * Unregister custom gesture
+     */
+    unregisterCustomGesture(gestureId: GestureId): void;
+    /**
+     * Match custom gesture
+     */
+    matchCustomGesture(points: Point[], threshold?: number): CustomGesturePattern | undefined;
+    /**
+     * Normalize points
+     */
+    private normalizePoints;
+    /**
+     * Compare patterns
+     */
+    private comparePatterns;
+    /**
+     * Resample points
+     */
+    private resample;
+    /**
+     * Register combo
+     */
+    registerCombo(name: string, gestures: GestureType[], callback: (data: GestureData[]) => void, maxDelay?: number): string;
+    /**
+     * Unregister combo
+     */
+    unregisterCombo(comboId: string): void;
+    /**
+     * Add to recent gestures and check combos
+     */
+    private addToRecentGestures;
+    /**
+     * Check combos
+     */
+    private checkCombos;
+    /**
+     * Match combo
+     */
+    private matchCombo;
+    /**
+     * Handle motion
+     */
+    private handleMotion;
+    /**
+     * Detect shake
+     */
+    private detectShake;
+    /**
+     * Handle orientation
+     */
+    private handleOrientation;
+    /**
+     * Get motion data
+     */
+    getMotionData(): MotionData | null;
+    /**
+     * Get orientation data
+     */
+    getOrientationData(): OrientationData | null;
+    /**
+     * Trigger haptic feedback
+     */
+    hapticFeedback(pattern: HapticPattern): void;
+    /**
+     * Get active touch points
+     */
+    private getActivePoints;
+    /**
+     * Calculate center
+     */
+    private calculateCenter;
+    /**
+     * Calculate distance
+     */
+    private calculateDistance;
+    /**
+     * Calculate angle
+     */
+    private calculateAngle;
+    /**
+     * Create gesture data
+     */
+    private createGestureData;
+    /**
+     * Trigger gesture handlers
+     */
+    private triggerGesture;
+    /**
+     * Get config
+     */
+    getConfig(): GestureConfig;
+    /**
+     * Update config
+     */
+    updateConfig(config: Partial<GestureConfig>): void;
+    /**
+     * Destroy gesture system
+     */
+    destroy(): void;
+}
+/**
+ * Create gesture system instance
+ */
+export declare function createGestureSystem(config?: Partial<GestureConfig>): NiceGesture;
+export default NiceGesture;

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

@@ -0,0 +1,154 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type HookId = string;
+export type AnchorId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export type HookType = 'grapple' | 'pull' | 'swing' | 'zip_line' | 'tether' | 'harpoon' | 'custom';
+export type HookState = 'ready' | 'firing' | 'extending' | 'attached' | 'retracting' | 'swinging' | 'cooldown';
+export interface GrapplingHook {
+    id: HookId;
+    type: HookType;
+    ownerId: EntityId;
+    state: HookState;
+    position: Vector3;
+    target?: Vector3;
+    velocity: Vector3;
+    attachedTo?: AnchorId;
+    ropeLength: number;
+    maxRopeLength: number;
+    ropeSpeed: number;
+    pullForce: number;
+    durability: number;
+    maxDurability: number;
+    cooldown: number;
+    currentCooldown: number;
+    canPullObjects: boolean;
+    canPullSelf: boolean;
+    swingEnabled: boolean;
+}
+export interface HookData {
+    type: HookType;
+    maxRopeLength: number;
+    ropeSpeed: number;
+    pullForce: number;
+    durability: number;
+    cooldown: number;
+    canPullObjects: boolean;
+    canPullSelf: boolean;
+    swingEnabled: boolean;
+}
+export type AnchorType = 'surface' | 'ring' | 'beam' | 'entity' | 'dynamic' | 'breakable';
+export interface GrappleAnchor {
+    id: AnchorId;
+    type: AnchorType;
+    position: Vector3;
+    normal: Vector3;
+    isEnabled: boolean;
+    strength: number;
+    maxLoad?: number;
+    entityId?: EntityId;
+    pullable?: boolean;
+    breakOnDetach?: boolean;
+}
+export interface RopeSegment {
+    index: number;
+    position: Vector3;
+    previousPosition: Vector3;
+    velocity: Vector3;
+}
+export interface RopePhysics {
+    segments: RopeSegment[];
+    stiffness: number;
+    damping: number;
+    gravity: number;
+    maxStretch: number;
+    collisionEnabled: boolean;
+}
+export interface Grappler {
+    entityId: EntityId;
+    position: Vector3;
+    velocity: Vector3;
+    mass: number;
+    hooks: HookId[];
+    maxHooks: number;
+    activeSwing?: HookId;
+    skills: GrapplerSkills;
+}
+export interface GrapplerSkills {
+    accuracy: number;
+    swingControl: number;
+    ropeClimbing: number;
+    momentum: number;
+}
+export type GrapplingEventType = 'hook-fired' | 'hook-attached' | 'hook-detached' | 'hook-missed' | 'hook-retracted' | 'swing-started' | 'swing-ended' | 'pull-started' | 'pull-completed' | 'object-pulled' | 'rope-broke' | 'anchor-destroyed';
+export interface GrapplingEvent {
+    type: GrapplingEventType;
+    entityId: EntityId;
+    hookId?: HookId;
+    anchorId?: AnchorId;
+    data?: Record<string, unknown>;
+}
+export interface GrapplingSystemConfig {
+    defaultMaxRopeLength?: number;
+    defaultRopeSpeed?: number;
+    defaultPullForce?: number;
+    ropeGravity?: number;
+    ropeSegmentCount?: number;
+    ropeStiffness?: number;
+    ropeDamping?: number;
+    maxHooksPerEntity?: number;
+    swingDamping?: number;
+    autoDetachOnLand?: boolean;
+    hookDetectionRadius?: number;
+}
+export declare const DEFAULT_GRAPPLING_CONFIG: GrapplingSystemConfig;
+export declare class NiceGrappling extends EventEmitter {
+    private hooks;
+    private anchors;
+    private grapplers;
+    private ropes;
+    private config;
+    private hookIdCounter;
+    constructor(config?: Partial<GrapplingSystemConfig>);
+    registerAnchor(anchor: GrappleAnchor): void;
+    unregisterAnchor(id: AnchorId): void;
+    getAnchor(id: AnchorId): GrappleAnchor | undefined;
+    findAnchorsInRange(position: Vector3, range: number): GrappleAnchor[];
+    updateAnchorPosition(id: AnchorId, position: Vector3): void;
+    registerGrappler(entityId: EntityId, position: Vector3, skills?: Partial<GrapplerSkills>): void;
+    unregisterGrappler(entityId: EntityId): void;
+    getGrappler(entityId: EntityId): Grappler | undefined;
+    updateGrapplerPosition(entityId: EntityId, position: Vector3): void;
+    createHook(entityId: EntityId, data?: Partial<HookData>): HookId | null;
+    getHook(id: HookId): GrapplingHook | undefined;
+    fireHook(hookId: HookId, targetPosition: Vector3): boolean;
+    fireAtAnchor(hookId: HookId, anchorId: AnchorId): boolean;
+    retractHook(hookId: HookId): void;
+    detachHook(hookId: HookId): void;
+    startSwing(hookId: HookId): boolean;
+    applySwingForce(entityId: EntityId, direction: Vector3, force: number): void;
+    pullSelf(hookId: HookId): boolean;
+    pullObject(hookId: HookId): boolean;
+    climbRope(hookId: HookId, direction: number): boolean;
+    adjustRopeLength(hookId: HookId, delta: number): void;
+    update(deltaTime: number): void;
+    private updateHook;
+    private attachHook;
+    private breakAnchor;
+    private updateSwingingGrappler;
+    private initializeRope;
+    private updateRopePhysics;
+    getRopePositions(hookId: HookId): Vector3[];
+    private findAnchorAtPosition;
+    private calculateDistance;
+    private normalizeVector;
+    private getTangentVector;
+}
+export declare function createGrapplingSystem(config?: Partial<GrapplingSystemConfig>): NiceGrappling;
+export declare function defineGrappleAnchor(options: GrappleAnchor): GrappleAnchor;
+export declare function defineHookType(options: HookData): HookData;
+export default NiceGrappling;