@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,240 @@
+/**
+ * @file NetworkingSystem.ts
+ * @description Networking System for Nice2Dev Game Engine
+ * PRO-1.11.6: Networking System
+ *
+ * Features:
+ * - WebSocket multiplayer
+ * - WebRTC peer-to-peer
+ * - State synchronization
+ * - Client-side prediction
+ * - Lag compensation
+ * - Matchmaking
+ * - Lobby system
+ */
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'disconnecting';
+export type NetworkRole = 'host' | 'client' | 'dedicated-server';
+export type SyncMode = 'reliable' | 'unreliable' | 'reliable-ordered' | 'unreliable-sequenced';
+export type MessageChannel = 'gameplay' | 'voice' | 'chat' | 'system';
+export interface NetworkConfig {
+    maxPlayers: number;
+    tickRate: number;
+    interpolationDelay: number;
+    predictionEnabled: boolean;
+    lagCompensationWindow: number;
+    reconciliationEnabled: boolean;
+    snapshotBufferSize: number;
+    heartbeatInterval: number;
+    timeoutDuration: number;
+    compressionEnabled: boolean;
+    encryptionEnabled: boolean;
+}
+export interface NetworkPlayer {
+    id: string;
+    name: string;
+    role: NetworkRole;
+    ping: number;
+    state: 'connecting' | 'connected' | 'ready' | 'playing' | 'disconnecting';
+    team?: string;
+    customData?: Record<string, unknown>;
+}
+export interface LocalPlayer extends NetworkPlayer {
+    inputSequence: number;
+    pendingInputs: PlayerInput[];
+}
+export interface PlayerInput {
+    sequence: number;
+    timestamp: number;
+    actions: Record<string, number | boolean>;
+}
+export interface NetworkMessage {
+    type: string;
+    channel: MessageChannel;
+    mode: SyncMode;
+    timestamp: number;
+    senderId: string;
+    data: unknown;
+}
+export interface StateSnapshot {
+    tick: number;
+    timestamp: number;
+    entities: EntityState[];
+    serverTime: number;
+}
+export interface EntityState {
+    id: string;
+    ownerId: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    velocity?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    customState?: Record<string, unknown>;
+}
+export interface NetworkEvents {
+    onConnected: () => void;
+    onDisconnected: (reason: string) => void;
+    onPlayerJoined: (player: NetworkPlayer) => void;
+    onPlayerLeft: (player: NetworkPlayer) => void;
+    onStateSync: (snapshot: StateSnapshot) => void;
+    onMessage: (message: NetworkMessage) => void;
+    onError: (error: Error) => void;
+    onPingUpdate: (ping: number) => void;
+}
+export declare class NetworkManager {
+    private config;
+    private connection;
+    private players;
+    private localPlayer;
+    private entities;
+    private snapshotBuffer;
+    private currentTick;
+    private serverTimeOffset;
+    private callbacks;
+    private messageHandlers;
+    constructor(config?: Partial<NetworkConfig>);
+    connectToServer(url: string, playerName: string): Promise<void>;
+    private waitForJoinResponse;
+    hostServer(port: number, playerName: string): Promise<void>;
+    disconnect(): void;
+    private cleanup;
+    isConnected(): boolean;
+    getConnectionState(): ConnectionState;
+    getLocalPlayer(): LocalPlayer | null;
+    getPlayer(id: string): NetworkPlayer | undefined;
+    getPlayers(): NetworkPlayer[];
+    getPlayerCount(): number;
+    registerEntity(entity: NetworkEntity): void;
+    unregisterEntity(entity: NetworkEntity): void;
+    getEntity(id: string): NetworkEntity | undefined;
+    isEntityOwner(entity: NetworkEntity): boolean;
+    sendMessage(message: Omit<NetworkMessage, 'timestamp' | 'senderId'>): void;
+    sendToPlayer(playerId: string, message: Omit<NetworkMessage, 'timestamp' | 'senderId'>): void;
+    broadcast(message: Omit<NetworkMessage, 'timestamp' | 'senderId'>, excludeSelf?: boolean): void;
+    private handleMessage;
+    private handlePlayerJoined;
+    private handlePlayerLeft;
+    private handleStateSync;
+    private handlePing;
+    sendInput(input: Record<string, number | boolean>): void;
+    update(_deltaTime: number): void;
+    private applyPrediction;
+    private interpolateEntity;
+    private lerpVec3;
+    private slerpQuat;
+    reconcileState(serverSequence: number, serverState: EntityState): void;
+    on<K extends keyof NetworkEvents>(event: K, callback: NetworkEvents[K]): void;
+    off<K extends keyof NetworkEvents>(event: K): void;
+    registerMessageHandler(type: string, handler: (msg: NetworkMessage) => void): void;
+    unregisterMessageHandler(type: string): void;
+}
+export declare abstract class NetworkEntity {
+    networkId: string;
+    ownerId: string;
+    type: string;
+    protected position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    protected rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    protected velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    protected customState: Record<string, unknown>;
+    constructor(networkId: string, ownerId: string, type: string);
+    getState(): EntityState;
+    applyState(state: EntityState): void;
+    abstract onNetworkUpdate(): void;
+}
+export interface LobbyConfig {
+    name: string;
+    maxPlayers: number;
+    isPublic: boolean;
+    password?: string;
+    gameMode?: string;
+    map?: string;
+    customData?: Record<string, unknown>;
+}
+export interface Lobby {
+    id: string;
+    config: LobbyConfig;
+    host: NetworkPlayer;
+    players: NetworkPlayer[];
+    state: 'waiting' | 'starting' | 'in-game';
+    createdAt: number;
+}
+export declare class LobbyManager {
+    private network;
+    private currentLobby;
+    private availableLobbies;
+    private callbacks;
+    constructor(network: NetworkManager);
+    private setupMessageHandlers;
+    createLobby(config: LobbyConfig): void;
+    joinLobby(lobbyId: string, password?: string): void;
+    leaveLobby(): void;
+    refreshLobbyList(): void;
+    startGame(): void;
+    updateLobbySettings(settings: Partial<LobbyConfig>): void;
+    kickPlayer(playerId: string): void;
+    getCurrentLobby(): Lobby | null;
+    getAvailableLobbies(): Lobby[];
+    isInLobby(): boolean;
+    isHost(): boolean;
+    on<K extends keyof typeof this.callbacks>(event: K, callback: (typeof this.callbacks)[K]): void;
+}
+export interface MatchmakingCriteria {
+    gameMode: string;
+    skillRange?: {
+        min: number;
+        max: number;
+    };
+    region?: string;
+    maxPing?: number;
+    teamSize?: number;
+    customFilters?: Record<string, unknown>;
+}
+export interface MatchmakingStatus {
+    state: 'idle' | 'searching' | 'found' | 'joining' | 'failed';
+    playersFound: number;
+    playersRequired: number;
+    estimatedWait: number;
+    matchId?: string;
+}
+export declare class MatchmakingManager {
+    private network;
+    private status;
+    private callbacks;
+    constructor(network: NetworkManager);
+    private setupMessageHandlers;
+    startMatchmaking(criteria: MatchmakingCriteria): void;
+    cancelMatchmaking(): void;
+    acceptMatch(): void;
+    declineMatch(): void;
+    getStatus(): MatchmakingStatus;
+    isSearching(): boolean;
+    on<K extends keyof typeof this.callbacks>(event: K, callback: (typeof this.callbacks)[K]): void;
+}
+export declare function createNetworkManager(config?: Partial<NetworkConfig>): NetworkManager;
+export declare function createLobbyManager(network: NetworkManager): LobbyManager;
+export declare function createMatchmakingManager(network: NetworkManager): MatchmakingManager;

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

@@ -0,0 +1,341 @@
+/**
+ * @file PhysicsEngine.ts
+ * @description Physics Engine for Nice2Dev Game Engine
+ * PRO-1.11.2: Physics Engine
+ *
+ * Features:
+ * - 3D Physics (Rapier.js integration)
+ * - 2D Physics (Box2D/Matter.js integration)
+ * - Rigid bodies, colliders, joints
+ * - Character controller
+ * - Raycasting, shapecasting
+ * - Trigger volumes
+ */
+export type RigidBodyType = 'dynamic' | 'kinematic' | 'static';
+export type ColliderShape = 'box' | 'sphere' | 'capsule' | 'cylinder' | 'cone' | 'convex' | 'trimesh' | 'heightfield';
+export type JointType = 'fixed' | 'revolute' | 'prismatic' | 'spherical' | 'distance' | 'rope' | 'motor';
+export type CollisionEvent = 'start' | 'stay' | 'end';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface PhysicsConfig {
+    gravity: Vec3;
+    timestep: number;
+    substeps: number;
+    maxVelocity: number;
+    maxAngularVelocity: number;
+    sleepThreshold: number;
+    defaultRestitution: number;
+    defaultFriction: number;
+    defaultDensity: number;
+    contactOffset: number;
+    separationOffset: number;
+    maxStabilizationIterations: number;
+    ccdEnabled: boolean;
+    ccdThreshold: number;
+}
+export interface RigidBodyDescriptor {
+    type: RigidBodyType;
+    position: Vec3;
+    rotation: Quaternion;
+    linearVelocity?: Vec3;
+    angularVelocity?: Vec3;
+    linearDamping?: number;
+    angularDamping?: number;
+    gravityScale?: number;
+    canSleep?: boolean;
+    ccdEnabled?: boolean;
+    userData?: unknown;
+}
+export interface RigidBody {
+    id: number;
+    type: RigidBodyType;
+    getPosition(): Vec3;
+    setPosition(position: Vec3): void;
+    getRotation(): Quaternion;
+    setRotation(rotation: Quaternion): void;
+    getTransform(): {
+        position: Vec3;
+        rotation: Quaternion;
+    };
+    setTransform(position: Vec3, rotation: Quaternion): void;
+    getLinearVelocity(): Vec3;
+    setLinearVelocity(velocity: Vec3): void;
+    getAngularVelocity(): Vec3;
+    setAngularVelocity(velocity: Vec3): void;
+    applyForce(force: Vec3, wakeUp?: boolean): void;
+    applyForceAtPoint(force: Vec3, point: Vec3, wakeUp?: boolean): void;
+    applyImpulse(impulse: Vec3, wakeUp?: boolean): void;
+    applyImpulseAtPoint(impulse: Vec3, point: Vec3, wakeUp?: boolean): void;
+    applyTorque(torque: Vec3, wakeUp?: boolean): void;
+    applyTorqueImpulse(impulse: Vec3, wakeUp?: boolean): void;
+    getMass(): number;
+    setMass(mass: number): void;
+    getInertia(): Vec3;
+    setCenterOfMass(center: Vec3): void;
+    isSleeping(): boolean;
+    wakeUp(): void;
+    sleep(): void;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    getLinearDamping(): number;
+    setLinearDamping(damping: number): void;
+    getAngularDamping(): number;
+    setAngularDamping(damping: number): void;
+    getGravityScale(): number;
+    setGravityScale(scale: number): void;
+    getColliders(): Collider[];
+    addCollider(collider: ColliderDescriptor): Collider;
+    removeCollider(collider: Collider): void;
+    getUserData(): unknown;
+    setUserData(data: unknown): void;
+}
+export interface ColliderDescriptor {
+    shape: ColliderShape;
+    offset?: Vec3;
+    rotation?: Quaternion;
+    halfExtents?: Vec3;
+    radius?: number;
+    halfHeight?: number;
+    vertices?: Float32Array;
+    indices?: Uint32Array;
+    heights?: Float32Array;
+    rows?: number;
+    columns?: number;
+    scale?: Vec3;
+    friction?: number;
+    restitution?: number;
+    density?: number;
+    isSensor?: boolean;
+    collisionGroups?: number;
+    collisionMask?: number;
+    userData?: unknown;
+}
+export interface Collider {
+    id: number;
+    shape: ColliderShape;
+    getOffset(): Vec3;
+    setOffset(offset: Vec3): void;
+    getRotation(): Quaternion;
+    setRotation(rotation: Quaternion): void;
+    getFriction(): number;
+    setFriction(friction: number): void;
+    getRestitution(): number;
+    setRestitution(restitution: number): void;
+    getDensity(): number;
+    setDensity(density: number): void;
+    isSensor(): boolean;
+    setSensor(isSensor: boolean): void;
+    getCollisionGroups(): number;
+    setCollisionGroups(groups: number): void;
+    getCollisionMask(): number;
+    setCollisionMask(mask: number): void;
+    getAABB(): {
+        min: Vec3;
+        max: Vec3;
+    };
+    getParentBody(): RigidBody | null;
+    getUserData(): unknown;
+    setUserData(data: unknown): void;
+}
+export interface JointDescriptor {
+    type: JointType;
+    body1: RigidBody;
+    body2: RigidBody;
+    anchor1: Vec3;
+    anchor2: Vec3;
+    axis1?: Vec3;
+    axis2?: Vec3;
+    enableLimit?: boolean;
+    lowerLimit?: number;
+    upperLimit?: number;
+    enableMotor?: boolean;
+    targetVelocity?: number;
+    maxForce?: number;
+    stiffness?: number;
+    damping?: number;
+    breakForce?: number;
+    breakTorque?: number;
+    collideConnected?: boolean;
+    userData?: unknown;
+}
+export interface Joint {
+    id: number;
+    type: JointType;
+    getBody1(): RigidBody;
+    getBody2(): RigidBody;
+    isLimitEnabled(): boolean;
+    enableLimit(enable: boolean): void;
+    getLimits(): {
+        lower: number;
+        upper: number;
+    };
+    setLimits(lower: number, upper: number): void;
+    isMotorEnabled(): boolean;
+    enableMotor(enable: boolean): void;
+    getMotorTargetVelocity(): number;
+    setMotorTargetVelocity(velocity: number): void;
+    getMotorMaxForce(): number;
+    setMotorMaxForce(force: number): void;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    isBroken(): boolean;
+    getUserData(): unknown;
+    setUserData(data: unknown): void;
+}
+export interface RaycastHit {
+    collider: Collider;
+    point: Vec3;
+    normal: Vec3;
+    distance: number;
+    triangleIndex?: number;
+}
+export interface ShapecastHit extends RaycastHit {
+    timeOfImpact: number;
+}
+export interface OverlapResult {
+    collider: Collider;
+}
+export interface ContactPoint {
+    point: Vec3;
+    normal: Vec3;
+    depth: number;
+    impulse: number;
+}
+export interface ContactPair {
+    collider1: Collider;
+    collider2: Collider;
+    contacts: ContactPoint[];
+}
+export interface CharacterControllerDescriptor {
+    height: number;
+    radius: number;
+    slopeLimit: number;
+    stepOffset: number;
+    skinWidth: number;
+    minMoveDistance: number;
+    offset?: Vec3;
+    upDirection?: Vec3;
+    gravityScale?: number;
+    collisionGroups?: number;
+    collisionMask?: number;
+    userData?: unknown;
+}
+export interface CharacterController {
+    id: number;
+    getPosition(): Vec3;
+    setPosition(position: Vec3): void;
+    move(displacement: Vec3): CharacterMovementFlags;
+    isGrounded(): boolean;
+    getGroundNormal(): Vec3 | null;
+    getGroundDistance(): number;
+    getSlidingNormal(): Vec3 | null;
+    getHeight(): number;
+    setHeight(height: number): void;
+    getRadius(): number;
+    setRadius(radius: number): void;
+    getSlopeLimit(): number;
+    setSlopeLimit(angle: number): void;
+    getStepOffset(): number;
+    setStepOffset(offset: number): void;
+    getVelocity(): Vec3;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    getUserData(): unknown;
+    setUserData(data: unknown): void;
+}
+export interface CharacterMovementFlags {
+    movedDown: boolean;
+    movedUp: boolean;
+    movedSides: boolean;
+    hitGround: boolean;
+    hitCeiling: boolean;
+    hitWall: boolean;
+    slideOnSlope: boolean;
+}
+export declare class PhysicsWorld {
+    private config;
+    private bodies;
+    private colliders;
+    private joints;
+    private controllers;
+    private eventQueue;
+    private callbacks;
+    private nextId;
+    constructor(config?: Partial<PhysicsConfig>);
+    step(deltaTime?: number): void;
+    private stepInternal;
+    private processEvents;
+    createRigidBody(descriptor: RigidBodyDescriptor): RigidBody;
+    private createRigidBodyInternal;
+    removeRigidBody(body: RigidBody): void;
+    getRigidBody(id: number): RigidBody | undefined;
+    createCollider(descriptor: ColliderDescriptor, body?: RigidBody): Collider;
+    private createColliderInternal;
+    removeCollider(collider: Collider): void;
+    getCollider(id: number): Collider | undefined;
+    createJoint(descriptor: JointDescriptor): Joint;
+    private createJointInternal;
+    removeJoint(joint: Joint): void;
+    getJoint(id: number): Joint | undefined;
+    createCharacterController(descriptor: CharacterControllerDescriptor): CharacterController;
+    private createCharacterControllerInternal;
+    removeCharacterController(controller: CharacterController): void;
+    raycast(origin: Vec3, direction: Vec3, maxDistance?: number, groups?: number, mask?: number): RaycastHit | null;
+    raycastAll(origin: Vec3, direction: Vec3, maxDistance?: number, groups?: number, mask?: number): RaycastHit[];
+    private raycastCollider;
+    spherecast(origin: Vec3, radius: number, direction: Vec3, maxDistance?: number): ShapecastHit | null;
+    boxcast(origin: Vec3, halfExtents: Vec3, rotation: Quaternion, direction: Vec3, maxDistance?: number): ShapecastHit | null;
+    shapecast(_shape: ShapeDescriptor, _origin: Vec3, _direction: Vec3, _maxDistance: number): ShapecastHit | null;
+    overlapSphere(center: Vec3, radius: number, groups?: number, mask?: number): OverlapResult[];
+    overlapBox(center: Vec3, halfExtents: Vec3, rotation: Quaternion, groups?: number, mask?: number): OverlapResult[];
+    overlapShape(_shape: ShapeDescriptor, _groups?: number, _mask?: number): OverlapResult[];
+    getContactPairs(): ContactPair[];
+    getContactsForCollider(_collider: Collider): ContactPair[];
+    setGravity(gravity: Vec3): void;
+    getGravity(): Vec3;
+    setTimestep(timestep: number): void;
+    getTimestep(): number;
+    setCallbacks(callbacks: PhysicsCallbacks): void;
+    getDebugLines(): DebugLine[];
+    private getAABBLines;
+    dispose(): void;
+}
+interface PhysicsCallbacks {
+    onCollisionStart?: (collider1: Collider, collider2: Collider, contacts: ContactPoint[]) => void;
+    onCollisionEnd?: (collider1: Collider, collider2: Collider) => void;
+    onTriggerEnter?: (trigger: Collider, other: Collider) => void;
+    onTriggerExit?: (trigger: Collider, other: Collider) => void;
+    onJointBroken?: (joint: Joint) => void;
+}
+interface ShapeDescriptor {
+    type: 'sphere' | 'box' | 'capsule';
+    center?: Vec3;
+    radius?: number;
+    halfExtents?: Vec3;
+    rotation?: Quaternion;
+    halfHeight?: number;
+}
+interface DebugLine {
+    start: Vec3;
+    end: Vec3;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export declare function createPhysicsWorld(config?: Partial<PhysicsConfig>): PhysicsWorld;
+export {};