@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,270 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type PhotoId = string;
+export type FilterId = string;
+export type FrameId = string;
+export type PoseId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface CameraSettings {
+    position: Vector3;
+    rotation: Quaternion;
+    target?: Vector3;
+    fov: number;
+    focalLength: number;
+    aperture: number;
+    focusDistance: number;
+    depthOfField: boolean;
+    dofStrength: number;
+    roll: number;
+    zoom: number;
+    exposure: number;
+    contrast: number;
+    saturation: number;
+    brightness: number;
+}
+export type FilterCategory = 'color' | 'vintage' | 'artistic' | 'dramatic' | 'black_white' | 'custom';
+export interface PhotoFilter {
+    id: FilterId;
+    name: string;
+    category: FilterCategory;
+    thumbnail?: string;
+    adjustments: FilterAdjustments;
+    lut?: string;
+}
+export interface FilterAdjustments {
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    hue?: number;
+    temperature?: number;
+    tint?: number;
+    highlights?: number;
+    shadows?: number;
+    vibrance?: number;
+    gamma?: number;
+    vignette?: number;
+    vignetteColor?: string;
+    grain?: number;
+    sharpen?: number;
+    blur?: number;
+    chromatic?: number;
+    sepia?: number;
+    fade?: number;
+}
+export type FrameCategory = 'simple' | 'decorative' | 'polaroid' | 'film' | 'seasonal' | 'custom';
+export interface PhotoFrame {
+    id: FrameId;
+    name: string;
+    category: FrameCategory;
+    thumbnail?: string;
+    image: string;
+    padding: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+export interface Overlay {
+    id: string;
+    name: string;
+    image: string;
+    blendMode: 'normal' | 'multiply' | 'screen' | 'overlay';
+    opacity: number;
+    position: {
+        x: number;
+        y: number;
+    };
+    scale: number;
+    rotation: number;
+}
+export type PoseCategory = 'idle' | 'action' | 'emotional' | 'social' | 'combat' | 'silly';
+export interface Pose {
+    id: PoseId;
+    name: string;
+    category: PoseCategory;
+    thumbnail?: string;
+    animationId: string;
+    holdable: boolean;
+    expression?: string;
+}
+export interface Expression {
+    id: string;
+    name: string;
+    thumbnail?: string;
+    morphTargets: Map<string, number>;
+}
+export type LightType = 'directional' | 'point' | 'spot' | 'ambient';
+export interface PhotoLight {
+    id: string;
+    type: LightType;
+    color: string;
+    intensity: number;
+    position: Vector3;
+    rotation?: Vector3;
+    range?: number;
+    angle?: number;
+    castShadows: boolean;
+}
+export interface LightingPreset {
+    id: string;
+    name: string;
+    thumbnail?: string;
+    lights: PhotoLight[];
+    ambientColor: string;
+    ambientIntensity: number;
+    fogEnabled: boolean;
+    fogColor?: string;
+    fogDensity?: number;
+}
+export interface PhotoMetadata {
+    id: PhotoId;
+    filename: string;
+    capturedAt: number;
+    resolution: {
+        width: number;
+        height: number;
+    };
+    location?: string;
+    characters?: EntityId[];
+    tags: string[];
+    isFavorite: boolean;
+    filter?: FilterId;
+    frame?: FrameId;
+    settings: CameraSettings;
+}
+export interface PhotoModeState {
+    isActive: boolean;
+    isPaused: boolean;
+    camera: CameraSettings;
+    currentFilter?: FilterId;
+    customAdjustments: FilterAdjustments;
+    currentFrame?: FrameId;
+    overlays: Overlay[];
+    lights: PhotoLight[];
+    hiddenUI: boolean;
+    hiddenCharacters: Set<EntityId>;
+    characterPoses: Map<EntityId, PoseId>;
+    characterExpressions: Map<EntityId, string>;
+    timeOfDay?: number;
+    weatherOverride?: string;
+}
+export type PhotoModeEventType = 'mode-entered' | 'mode-exited' | 'photo-captured' | 'photo-deleted' | 'filter-applied' | 'frame-applied' | 'pose-changed' | 'lighting-changed' | 'camera-moved' | 'settings-changed';
+export interface PhotoModeEvent {
+    type: PhotoModeEventType;
+    photoId?: PhotoId;
+    entityId?: EntityId;
+    data?: Record<string, unknown>;
+}
+export interface PhotoModeConfig {
+    maxPhotos?: number;
+    defaultResolution?: {
+        width: number;
+        height: number;
+    };
+    maxResolution?: {
+        width: number;
+        height: number;
+    };
+    maxOverlays?: number;
+    maxLights?: number;
+    cameraSpeed?: number;
+    rotationSpeed?: number;
+    minFov?: number;
+    maxFov?: number;
+    maxZoom?: number;
+    captureFormat?: 'png' | 'jpg' | 'webp';
+    captureQuality?: number;
+}
+export declare const DEFAULT_PHOTO_CONFIG: PhotoModeConfig;
+export declare function getDefaultCameraSettings(): CameraSettings;
+export declare class NicePhotoMode extends EventEmitter {
+    private state;
+    private filters;
+    private frames;
+    private poses;
+    private expressions;
+    private lightingPresets;
+    private photos;
+    private nextPhotoId;
+    private config;
+    constructor(config?: Partial<PhotoModeConfig>);
+    private initializeBuiltInAssets;
+    enter(pauseGame?: boolean): void;
+    exit(): void;
+    isActive(): boolean;
+    moveCamera(delta: Vector3): void;
+    orbitCamera(_yaw: number, _pitch: number): void;
+    setCameraPosition(position: Vector3): void;
+    setCameraRotation(rotation: Quaternion): void;
+    setCameraTarget(target: Vector3): void;
+    setFov(fov: number): void;
+    setZoom(zoom: number): void;
+    setRoll(roll: number): void;
+    setDepthOfField(enabled: boolean, focusDistance?: number, strength?: number): void;
+    setExposure(value: number): void;
+    getCameraSettings(): CameraSettings;
+    registerFilter(filter: PhotoFilter): void;
+    applyFilter(filterId: FilterId): void;
+    setCustomAdjustment<K extends keyof FilterAdjustments>(key: K, value: FilterAdjustments[K]): void;
+    resetAdjustments(): void;
+    getFilters(): PhotoFilter[];
+    getActiveFilter(): PhotoFilter | undefined;
+    registerFrame(frame: PhotoFrame): void;
+    applyFrame(frameId: FrameId | null): void;
+    getFrames(): PhotoFrame[];
+    addOverlay(overlay: Omit<Overlay, 'id'>): string | null;
+    updateOverlay(overlayId: string, updates: Partial<Omit<Overlay, 'id'>>): void;
+    removeOverlay(overlayId: string): void;
+    clearOverlays(): void;
+    registerPose(pose: Pose): void;
+    registerExpression(expression: Expression): void;
+    setCharacterPose(entityId: EntityId, poseId: PoseId): void;
+    setCharacterExpression(entityId: EntityId, expressionId: string): void;
+    hideCharacter(entityId: EntityId, hidden: boolean): void;
+    getPoses(category?: PoseCategory): Pose[];
+    getExpressions(): Expression[];
+    registerLightingPreset(preset: LightingPreset): void;
+    applyLightingPreset(presetId: string): void;
+    addLight(light: Omit<PhotoLight, 'id'>): string | null;
+    updateLight(lightId: string, updates: Partial<Omit<PhotoLight, 'id'>>): void;
+    removeLight(lightId: string): void;
+    clearLights(): void;
+    getLightingPresets(): LightingPreset[];
+    setTimeOfDay(hour: number): void;
+    setWeatherOverride(weatherId: string | null): void;
+    capture(options?: {
+        resolution?: {
+            width: number;
+            height: number;
+        };
+        location?: string;
+        tags?: string[];
+    }): PhotoId | null;
+    getPhoto(photoId: PhotoId): PhotoMetadata | undefined;
+    getAllPhotos(): PhotoMetadata[];
+    getFavorites(): PhotoMetadata[];
+    getPhotosByTag(tag: string): PhotoMetadata[];
+    setFavorite(photoId: PhotoId, isFavorite: boolean): void;
+    addTag(photoId: PhotoId, tag: string): void;
+    removeTag(photoId: PhotoId, tag: string): void;
+    deletePhoto(photoId: PhotoId): boolean;
+    setUIHidden(hidden: boolean): void;
+    isUIHidden(): boolean;
+    getState(): Readonly<PhotoModeState>;
+}
+export declare function createPhotoModeSystem(config?: Partial<PhotoModeConfig>): NicePhotoMode;
+export declare function definePhotoFilter(options: PhotoFilter): PhotoFilter;
+export declare function definePhotoFrame(options: PhotoFrame): PhotoFrame;
+export declare function definePose(options: Pose): Pose;
+export default NicePhotoMode;

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

@@ -0,0 +1,326 @@
+/**
+ * NicePhysics - Game Engine Physics System
+ *
+ * Comprehensive physics simulation supporting:
+ * - Rigid body dynamics (2D/3D)
+ * - Multiple collider types
+ * - Collision detection and response
+ * - Joints and constraints
+ * - Raycasting and queries
+ * - Forces, impulses, and torques
+ * - Continuous collision detection
+ * - Material properties (friction, restitution)
+ * - Physics layers and masks
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+export type BodyId = string;
+export type ColliderId = string;
+export type JointId = string;
+export type BodyType = 'dynamic' | 'kinematic' | 'static';
+export type ColliderType = 'box' | 'circle' | 'capsule' | 'polygon' | 'sphere' | 'plane';
+export type JointType = 'fixed' | 'distance' | 'spring' | 'revolute' | 'prismatic' | 'rope';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface PhysicsMaterial {
+    name?: string;
+    friction: number;
+    restitution: number;
+    density: number;
+    frictionCombine?: 'average' | 'minimum' | 'maximum' | 'multiply';
+    restitutionCombine?: 'average' | 'minimum' | 'maximum' | 'multiply';
+}
+export declare const DEFAULT_MATERIAL: PhysicsMaterial;
+export interface BaseCollider {
+    id: ColliderId;
+    bodyId: BodyId;
+    offset: Vec3;
+    rotation: Quaternion;
+    material: PhysicsMaterial;
+    isTrigger: boolean;
+    layer: number;
+    mask: number;
+    userData?: unknown;
+}
+export interface BoxCollider extends BaseCollider {
+    type: 'box';
+    size: Vec3;
+}
+export interface CircleCollider extends BaseCollider {
+    type: 'circle';
+    radius: number;
+}
+export interface SphereCollider extends BaseCollider {
+    type: 'sphere';
+    radius: number;
+}
+export interface CapsuleCollider extends BaseCollider {
+    type: 'capsule';
+    radius: number;
+    height: number;
+}
+export interface PolygonCollider extends BaseCollider {
+    type: 'polygon';
+    vertices: Vec2[];
+}
+export interface PlaneCollider extends BaseCollider {
+    type: 'plane';
+    normal: Vec3;
+}
+export type Collider = BoxCollider | CircleCollider | SphereCollider | CapsuleCollider | PolygonCollider | PlaneCollider;
+export interface RigidBodyConfig {
+    id?: BodyId;
+    type: BodyType;
+    position: Vec3;
+    rotation?: Quaternion;
+    linearVelocity?: Vec3;
+    angularVelocity?: Vec3;
+    mass?: number;
+    inertia?: number;
+    linearDamping?: number;
+    angularDamping?: number;
+    gravityScale?: number;
+    fixedRotation?: boolean;
+    isBullet?: boolean;
+    isSleeping?: boolean;
+    canSleep?: boolean;
+    userData?: unknown;
+}
+export interface RigidBody {
+    id: BodyId;
+    type: BodyType;
+    position: Vec3;
+    rotation: Quaternion;
+    scale: Vec3;
+    linearVelocity: Vec3;
+    angularVelocity: Vec3;
+    mass: number;
+    inverseMass: number;
+    inertia: number;
+    inverseInertia: number;
+    linearDamping: number;
+    angularDamping: number;
+    force: Vec3;
+    torque: Vec3;
+    gravityScale: number;
+    fixedRotation: boolean;
+    isBullet: boolean;
+    isSleeping: boolean;
+    canSleep: boolean;
+    sleepTime: number;
+    colliders: Collider[];
+    userData?: unknown;
+}
+export interface BaseJoint {
+    id: JointId;
+    bodyA: BodyId;
+    bodyB: BodyId;
+    anchorA: Vec3;
+    anchorB: Vec3;
+    collideConnected: boolean;
+}
+export interface FixedJoint extends BaseJoint {
+    type: 'fixed';
+}
+export interface DistanceJoint extends BaseJoint {
+    type: 'distance';
+    distance: number;
+    minDistance?: number;
+    maxDistance?: number;
+    stiffness?: number;
+    damping?: number;
+}
+export interface SpringJoint extends BaseJoint {
+    type: 'spring';
+    restLength: number;
+    stiffness: number;
+    damping: number;
+}
+export interface RevoluteJoint extends BaseJoint {
+    type: 'revolute';
+    enableLimits?: boolean;
+    lowerAngle?: number;
+    upperAngle?: number;
+    enableMotor?: boolean;
+    motorSpeed?: number;
+    maxMotorTorque?: number;
+}
+export interface PrismaticJoint extends BaseJoint {
+    type: 'prismatic';
+    axis: Vec3;
+    enableLimits?: boolean;
+    lowerLimit?: number;
+    upperLimit?: number;
+    enableMotor?: boolean;
+    motorSpeed?: number;
+    maxMotorForce?: number;
+}
+export interface RopeJoint extends BaseJoint {
+    type: 'rope';
+    maxLength: number;
+}
+export type Joint = FixedJoint | DistanceJoint | SpringJoint | RevoluteJoint | PrismaticJoint | RopeJoint;
+export interface ContactPoint {
+    position: Vec3;
+    normal: Vec3;
+    penetration: number;
+}
+export interface CollisionInfo {
+    bodyA: RigidBody;
+    bodyB: RigidBody;
+    colliderA: Collider;
+    colliderB: Collider;
+    contacts: ContactPoint[];
+    relativeVelocity: Vec3;
+    isTrigger: boolean;
+}
+export interface RaycastHit {
+    body: RigidBody;
+    collider: Collider;
+    point: Vec3;
+    normal: Vec3;
+    distance: number;
+    fraction: number;
+}
+export interface RaycastOptions {
+    origin: Vec3;
+    direction: Vec3;
+    maxDistance?: number;
+    layers?: number;
+    ignoreTriggers?: boolean;
+    ignoreBodies?: BodyId[];
+}
+export interface OverlapResult {
+    body: RigidBody;
+    collider: Collider;
+}
+export type PhysicsEventType = 'collision-start' | 'collision-stay' | 'collision-end' | 'trigger-enter' | 'trigger-stay' | 'trigger-exit' | 'body-sleep' | 'body-wake';
+export interface PhysicsEvent {
+    type: PhysicsEventType;
+    collision?: CollisionInfo;
+    body?: RigidBody;
+    timestamp: number;
+}
+export type PhysicsEventCallback = (event: PhysicsEvent) => void;
+export interface PhysicsConfig {
+    gravity: Vec3;
+    is2D: boolean;
+    fixedTimeStep: number;
+    maxSubSteps: number;
+    velocityIterations: number;
+    positionIterations: number;
+    allowSleep: boolean;
+    sleepLinearThreshold: number;
+    sleepAngularThreshold: number;
+    sleepTimeThreshold: number;
+    defaultMaterial: PhysicsMaterial;
+    continuousDetection: boolean;
+    baumgarte: number;
+    penetrationSlop: number;
+}
+export declare const DEFAULT_PHYSICS_CONFIG: PhysicsConfig;
+export declare class NicePhysics extends EventEmitter {
+    private config;
+    private bodies;
+    private colliders;
+    private joints;
+    private nextColliderId;
+    private activeCollisions;
+    private accumulator;
+    private destroyed;
+    constructor(config?: Partial<PhysicsConfig>);
+    createBody(config: RigidBodyConfig): RigidBody;
+    getBody(bodyId: BodyId): RigidBody | undefined;
+    removeBody(bodyId: BodyId): void;
+    setBodyType(bodyId: BodyId, type: BodyType): void;
+    setPosition(bodyId: BodyId, position: Vec3): void;
+    setRotation(bodyId: BodyId, rotation: Quaternion): void;
+    setLinearVelocity(bodyId: BodyId, velocity: Vec3): void;
+    setAngularVelocity(bodyId: BodyId, velocity: Vec3): void;
+    addCollider(bodyId: BodyId, colliderConfig: Partial<Collider> & {
+        type: ColliderType;
+    }): Collider | undefined;
+    removeCollider(colliderId: ColliderId): void;
+    private updateMassProperties;
+    createJoint(config: Omit<Joint, 'id'> & {
+        id?: JointId;
+    }): Joint;
+    getJoint(jointId: JointId): Joint | undefined;
+    removeJoint(jointId: JointId): void;
+    applyForce(bodyId: BodyId, force: Vec3, worldPoint?: Vec3): void;
+    applyForceAtCenter(bodyId: BodyId, force: Vec3): void;
+    applyTorque(bodyId: BodyId, torque: Vec3): void;
+    applyImpulse(bodyId: BodyId, impulse: Vec3, worldPoint?: Vec3): void;
+    applyImpulseAtCenter(bodyId: BodyId, impulse: Vec3): void;
+    applyAngularImpulse(bodyId: BodyId, impulse: Vec3): void;
+    private wakeBody;
+    private sleepBody;
+    wakeAll(): void;
+    update(deltaTime: number): void;
+    private step;
+    private integrateForces;
+    private integrateVelocities;
+    private clearForces;
+    private broadPhase;
+    private aabbOverlap;
+    private getBodyAABB;
+    private getColliderAABB;
+    private narrowPhase;
+    private checkCollision;
+    private checkCircleCircle;
+    private checkSphereSphere;
+    private checkBoxBox;
+    private checkCircleBox;
+    private solveVelocities;
+    private solveCollisionVelocity;
+    private solveJointVelocity;
+    private solvePositions;
+    private solveCollisionPosition;
+    private combineValues;
+    private updateSleeping;
+    private updateCollisionEvents;
+    private getCollisionKey;
+    raycast(options: RaycastOptions): RaycastHit | null;
+    raycastAll(options: RaycastOptions): RaycastHit[];
+    private raycastCollider;
+    overlapPoint(point: Vec3, layers?: number): OverlapResult[];
+    overlapSphere(center: Vec3, radius: number, layers?: number): OverlapResult[];
+    private pointInCollider;
+    private sphereOverlapsCollider;
+    getAllBodies(): RigidBody[];
+    getDynamicBodies(): RigidBody[];
+    getStaticBodies(): RigidBody[];
+    getAwakeBodies(): RigidBody[];
+    getStats(): {
+        bodies: number;
+        dynamicBodies: number;
+        sleepingBodies: number;
+        colliders: number;
+        joints: number;
+        activeCollisions: number;
+    };
+    setGravity(gravity: Vec3): void;
+    getGravity(): Vec3;
+    on(event: 'physics', callback: PhysicsEventCallback): this;
+    off(event: 'physics', callback: PhysicsEventCallback): this;
+    clear(): void;
+    destroy(): void;
+}
+export declare function createPhysicsWorld(config?: Partial<PhysicsConfig>): NicePhysics;
+export declare function createDynamicBody(physics: NicePhysics, position: Vec3, options?: Partial<RigidBodyConfig>): RigidBody;
+export declare function createStaticBody(physics: NicePhysics, position: Vec3, options?: Partial<RigidBodyConfig>): RigidBody;
+export declare function createKinematicBody(physics: NicePhysics, position: Vec3, options?: Partial<RigidBodyConfig>): RigidBody;