@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,167 +0,0 @@
-export interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export type BulletType = 'instant' | 'projectile' | 'beam' | 'arc' | 'homing';
-export interface BulletDefinition {
-    id: string;
-    type: BulletType;
-    speed: number;
-    damage: number;
-    range: number;
-    gravity: number;
-    drag: number;
-    radius: number;
-    penetration: number;
-    ricochetChance: number;
-    maxRicochets: number;
-    lifetime: number;
-    tracerColor?: string;
-    tracerWidth?: number;
-    impactEffect?: string;
-    onHit?: (hit: BulletHit) => void;
-}
-export interface HomingConfig {
-    target: string | null;
-    turnRate: number;
-    maxAngle: number;
-    lockOnDelay: number;
-    proximityFuse: number;
-}
-export interface ArcConfig {
-    arcHeight: number;
-    bounces: number;
-    bounceDecay: number;
-}
-export interface Bullet {
-    id: string;
-    definitionId: string;
-    position: Vec3;
-    velocity: Vec3;
-    direction: Vec3;
-    owner: string;
-    spawnTime: number;
-    distanceTraveled: number;
-    ricochets: number;
-    penetrations: number;
-    active: boolean;
-    homing?: HomingConfig;
-    arc?: ArcConfig;
-}
-export interface BulletHit {
-    bulletId: string;
-    targetId: string;
-    position: Vec3;
-    normal: Vec3;
-    damage: number;
-    penetrated: boolean;
-    ricocheted: boolean;
-    distance: number;
-}
-export interface Collider {
-    id: string;
-    position: Vec3;
-    radius: number;
-    height?: number;
-    type: 'sphere' | 'capsule' | 'box';
-    layer: number;
-    solid: boolean;
-    damageMultiplier: number;
-}
-export interface RaycastHit {
-    colliderId: string;
-    position: Vec3;
-    normal: Vec3;
-    distance: number;
-    layer: number;
-}
-export interface Tracer {
-    id: string;
-    bulletId: string;
-    startPosition: Vec3;
-    endPosition: Vec3;
-    color: string;
-    width: number;
-    lifetime: number;
-    spawnTime: number;
-}
-export type BulletEventType = 'bullet-spawned' | 'bullet-hit' | 'bullet-destroyed' | 'bullet-ricochet' | 'bullet-penetrate' | 'tracer-spawned' | 'impact-effect';
-export interface BulletEvent {
-    type: BulletEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type BulletEventCallback = (event: BulletEvent) => void;
-export interface BulletConfig {
-    /** Maximum bullets */
-    maxBullets: number;
-    /** Maximum tracers */
-    maxTracers: number;
-    /** Physics timestep */
-    physicsTimestep: number;
-    /** Gravity */
-    gravity: Vec3;
-    /** Default tracer lifetime */
-    tracerLifetime: number;
-    /** Collision layers */
-    collisionMask: number;
-    /** Bullet time scale */
-    timeScale: number;
-    /** Enable pooling */
-    pooling: boolean;
-}
-export declare const DEFAULT_BULLET_CONFIG: BulletConfig;
-export declare const DEFAULT_BULLET_DEFINITIONS: BulletDefinition[];
-export declare class NiceBullet {
-    private config;
-    private definitions;
-    private bullets;
-    private bulletPool;
-    private tracers;
-    private colliders;
-    private eventListeners;
-    private nextBulletId;
-    constructor(config?: Partial<BulletConfig>);
-    on(event: BulletEventType, callback: BulletEventCallback): () => void;
-    private emit;
-    registerDefinition(definition: BulletDefinition): void;
-    getDefinition(id: string): BulletDefinition | undefined;
-    registerCollider(collider: Collider): void;
-    updateCollider(id: string, position: Vec3): void;
-    removeCollider(id: string): void;
-    fire(definitionId: string, position: Vec3, direction: Vec3, owner: string, options?: {
-        target?: string;
-        damageMultiplier?: number;
-        speedMultiplier?: number;
-    }): string | null;
-    private processHitscan;
-    update(deltaTime: number): void;
-    private updateBulletPhysics;
-    private updateHomingBullet;
-    private checkBulletCollisions;
-    private raycast;
-    private raySphereIntersect;
-    private createTracer;
-    private updateTracers;
-    getTracers(): Tracer[];
-    setTimeScale(scale: number): void;
-    getTimeScale(): number;
-    getBullet(id: string): Bullet | undefined;
-    getAllBullets(): Bullet[];
-    getBulletsByOwner(owner: string): Bullet[];
-    destroyBullet(id: string): void;
-    clearAll(): void;
-    private normalize;
-    private vec3Length;
-    private vec3Distance;
-    private dot;
-    private addVec3;
-    private subVec3;
-    private scaleVec3;
-    private lerpVec3;
-    private reflect;
-    private generateId;
-    destroy(): void;
-}
-export declare function createBulletSystem(config?: Partial<BulletConfig>): NiceBullet;

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

@@ -1,252 +0,0 @@
-export type CameraId = string;
-export type CameraMode = 'follow' | 'orbit' | 'free' | 'fixed' | 'firstPerson' | 'cinematic' | 'isometric';
-export interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface Quaternion {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}
-export interface Bounds {
-    min: Vec3;
-    max: Vec3;
-}
-export interface CameraDefinition {
-    id: CameraId;
-    name: string;
-    mode: CameraMode;
-    /** Field of view in degrees */
-    fov: number;
-    /** Near clipping plane */
-    nearClip: number;
-    /** Far clipping plane */
-    farClip: number;
-    /** Initial position */
-    position: Vec3;
-    /** Initial rotation (euler angles) */
-    rotation: Vec3;
-    /** Follow target settings */
-    follow?: CameraFollowSettings;
-    /** Orbit settings */
-    orbit?: CameraOrbitSettings;
-    /** Isometric settings */
-    isometric?: CameraIsometricSettings;
-    /** Movement constraints */
-    bounds?: Bounds;
-    /** Custom data */
-    customData?: Record<string, unknown>;
-}
-export interface CameraFollowSettings {
-    /** Offset from target */
-    offset: Vec3;
-    /** Look-at offset */
-    lookAtOffset: Vec3;
-    /** Smoothing factor (0-1, 1 = instant) */
-    smoothing: number;
-    /** Dead zone size */
-    deadZone: Vec3;
-    /** Allow rotation with target */
-    rotateWithTarget: boolean;
-    /** Lead the target based on velocity */
-    leadAmount: number;
-    /** Max lead distance */
-    maxLead: number;
-}
-export interface CameraOrbitSettings {
-    /** Target to orbit around */
-    target: Vec3;
-    /** Distance from target */
-    distance: number;
-    /** Min/max distance */
-    minDistance: number;
-    maxDistance: number;
-    /** Rotation speed (degrees per pixel) */
-    rotationSpeed: number;
-    /** Zoom speed */
-    zoomSpeed: number;
-    /** Vertical angle limits (degrees) */
-    minPitch: number;
-    maxPitch: number;
-    /** Enable auto-rotation */
-    autoRotate: boolean;
-    autoRotateSpeed: number;
-    /** Smoothing */
-    smoothing: number;
-}
-export interface CameraIsometricSettings {
-    /** Pitch angle (degrees) */
-    pitch: number;
-    /** Yaw angle (degrees) */
-    yaw: number;
-    /** Zoom level */
-    zoom: number;
-    minZoom: number;
-    maxZoom: number;
-    /** Orthographic size */
-    orthoSize: number;
-}
-export interface CameraState {
-    id: CameraId;
-    position: Vec3;
-    rotation: Vec3;
-    fov: number;
-    zoom: number;
-    target?: Vec3;
-    velocity: Vec3;
-    active: boolean;
-}
-export interface CameraShake {
-    id: string;
-    intensity: number;
-    frequency: number;
-    duration: number;
-    elapsed: number;
-    decay: boolean;
-    axes: {
-        x: boolean;
-        y: boolean;
-        z: boolean;
-    };
-}
-export interface CameraTransition {
-    id: string;
-    fromCamera: CameraId;
-    toCamera: CameraId;
-    duration: number;
-    elapsed: number;
-    easing: EasingFunction;
-    onComplete?: () => void;
-}
-export type EasingFunction = (t: number) => number;
-export interface CameraKeyframe {
-    time: number;
-    position: Vec3;
-    rotation: Vec3;
-    fov: number;
-    easing?: EasingFunction;
-}
-export interface CinematicSequence {
-    id: string;
-    name: string;
-    duration: number;
-    keyframes: CameraKeyframe[];
-    loop: boolean;
-    onComplete?: () => void;
-}
-export interface ScreenEffect {
-    id: string;
-    type: 'vignette' | 'blur' | 'chromatic' | 'grain' | 'letterbox' | 'flash' | 'fade';
-    intensity: number;
-    duration: number;
-    elapsed: number;
-    params?: Record<string, unknown>;
-}
-export type CameraEventType = 'camera-changed' | 'mode-changed' | 'transition-start' | 'transition-end' | 'shake-start' | 'shake-end' | 'sequence-start' | 'sequence-end' | 'keyframe-reached' | 'update';
-export interface CameraEvent {
-    type: CameraEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type CameraEventCallback = (event: CameraEvent) => void;
-export interface CameraSystemConfig {
-    /** Default camera settings */
-    defaultFov: number;
-    defaultNearClip: number;
-    defaultFarClip: number;
-    /** Update rate (Hz) */
-    updateRate: number;
-    /** Max active cameras (for split-screen) */
-    maxActiveCameras: number;
-    /** Enable post-processing effects */
-    enableEffects: boolean;
-}
-export declare const DEFAULT_CAMERA_CONFIG: CameraSystemConfig;
-export declare const EASING: {
-    linear: (t: number) => number;
-    easeInQuad: (t: number) => number;
-    easeOutQuad: (t: number) => number;
-    easeInOutQuad: (t: number) => number;
-    easeInCubic: (t: number) => number;
-    easeOutCubic: (t: number) => number;
-    easeInOutCubic: (t: number) => number;
-    easeInExpo: (t: number) => number;
-    easeOutExpo: (t: number) => number;
-    easeInOutExpo: (t: number) => number;
-    smoothstep: (t: number) => number;
-    smootherstep: (t: number) => number;
-};
-export declare class NiceCamera {
-    private config;
-    private cameras;
-    private cameraStates;
-    private activeCamera;
-    private activeCameras;
-    private shakes;
-    private transitions;
-    private effects;
-    private currentSequence;
-    private sequenceTime;
-    private eventListeners;
-    private updateTimer;
-    private lastUpdateTime;
-    private inputState;
-    constructor(config?: Partial<CameraSystemConfig>);
-    on(event: CameraEventType, callback: CameraEventCallback): () => void;
-    private emit;
-    createCamera(definition: CameraDefinition): CameraId;
-    removeCamera(id: CameraId): boolean;
-    getCamera(id: CameraId): CameraDefinition | undefined;
-    getCameraState(id: CameraId): CameraState | undefined;
-    getAllCameras(): CameraDefinition[];
-    setActiveCamera(id: CameraId, transition?: {
-        duration: number;
-        easing?: EasingFunction;
-    }): void;
-    getActiveCamera(): CameraId | null;
-    getActiveCameraState(): CameraState | undefined;
-    setActiveCameras(ids: CameraId[]): void;
-    getActiveCameras(): CameraState[];
-    setCameraMode(id: CameraId, mode: CameraMode): void;
-    setPosition(id: CameraId, position: Vec3): void;
-    setRotation(id: CameraId, rotation: Vec3): void;
-    setTarget(id: CameraId, target: Vec3): void;
-    setZoom(id: CameraId, zoom: number): void;
-    setFov(id: CameraId, fov: number): void;
-    handleMouseMove(deltaX: number, deltaY: number): void;
-    handleScroll(delta: number): void;
-    handleKeyDown(key: string): void;
-    handleKeyUp(key: string): void;
-    shake(intensity?: number, duration?: number, options?: Partial<{
-        frequency: number;
-        decay: boolean;
-        axes: {
-            x: boolean;
-            y: boolean;
-            z: boolean;
-        };
-    }>): string;
-    stopShake(id?: string): void;
-    private calculateShakeOffset;
-    private startTransition;
-    playSequence(sequence: CinematicSequence): void;
-    stopSequence(): void;
-    private updateSequence;
-    addEffect(type: ScreenEffect['type'], intensity: number, duration?: number, params?: Record<string, unknown>): string;
-    removeEffect(id: string): boolean;
-    getActiveEffects(): ScreenEffect[];
-    private startUpdateLoop;
-    update(dt: number): void;
-    private updateCameraModes;
-    private updateFollowCamera;
-    private updateOrbitCamera;
-    private updateFreeCamera;
-    private updateIsometricCamera;
-    lookAt(cameraId: CameraId, target: Vec3): void;
-    getViewMatrix(cameraId: CameraId): number[];
-    destroy(): void;
-}
-export declare function createCameraSystem(config?: Partial<CameraSystemConfig>): NiceCamera;

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

@@ -1,171 +0,0 @@
-export type CardType = 'creature' | 'spell' | 'artifact' | 'enchantment' | 'land' | 'instant' | 'equipment' | 'action';
-export type CardRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-export type CardSuit = 'hearts' | 'diamonds' | 'clubs' | 'spades' | 'fire' | 'water' | 'earth' | 'air' | 'light' | 'dark' | 'neutral';
-export type ZoneType = 'deck' | 'hand' | 'discard' | 'battlefield' | 'exile' | 'graveyard';
-export interface CardEffect {
-    id: string;
-    trigger: 'onPlay' | 'onDraw' | 'onDiscard' | 'onDestroy' | 'passive' | 'activated';
-    target: 'self' | 'opponent' | 'all' | 'choose';
-    action: string;
-    value?: number;
-    duration?: number;
-    description: string;
-}
-export interface CardDefinition {
-    id: string;
-    name: string;
-    description: string;
-    type: CardType;
-    rarity: CardRarity;
-    suit?: CardSuit;
-    cost: number;
-    attack?: number;
-    defense?: number;
-    health?: number;
-    effects: CardEffect[];
-    keywords: string[];
-    artId?: string;
-    frameId?: string;
-    maxInDeck: number;
-    set?: string;
-    collectible: boolean;
-}
-export interface CardInstance {
-    id: string;
-    definitionId: string;
-    ownerId: string;
-    zone: ZoneType;
-    position: number;
-    isFaceUp: boolean;
-    isTapped: boolean;
-    currentAttack?: number;
-    currentDefense?: number;
-    currentHealth?: number;
-    modifiers: CardModifier[];
-    canAct: boolean;
-    turnsInPlay: number;
-    damageDealt: number;
-    damageTaken: number;
-    metadata: Record<string, unknown>;
-}
-export interface CardModifier {
-    id: string;
-    source: string;
-    stat: 'attack' | 'defense' | 'health' | 'cost';
-    value: number;
-    duration: number;
-    expiresAt?: number;
-}
-export interface Deck {
-    id: string;
-    name: string;
-    ownerId: string;
-    cards: string[];
-    maxSize: number;
-    minSize: number;
-    isValid: boolean;
-}
-export interface CardPlayerState {
-    id: string;
-    name: string;
-    health: number;
-    maxHealth: number;
-    mana: number;
-    maxMana: number;
-    deck: string[];
-    hand: string[];
-    battlefield: string[];
-    discard: string[];
-    exile: string[];
-    cardsDrawnThisTurn: number;
-    cardsPlayedThisTurn: number;
-    manaSpentThisTurn: number;
-    maxHandSize: number;
-    drawsPerTurn: number;
-}
-export type CardEventType = 'card-draw' | 'card-play' | 'card-discard' | 'card-move' | 'card-tap' | 'card-untap' | 'card-destroy' | 'card-attack' | 'card-damage' | 'card-heal' | 'card-buff' | 'card-debuff' | 'shuffle' | 'turn-start' | 'turn-end' | 'game-over';
-export interface CardEvent {
-    type: CardEventType;
-    timestamp: number;
-    playerId: string;
-    cardId?: string;
-    data: unknown;
-}
-export type CardEventCallback = (event: CardEvent) => void;
-export interface CardConfig {
-    /** Default deck size */
-    defaultDeckSize: number;
-    /** Minimum deck size */
-    minDeckSize: number;
-    /** Maximum deck size */
-    maxDeckSize: number;
-    /** Starting hand size */
-    startingHandSize: number;
-    /** Maximum hand size */
-    maxHandSize: number;
-    /** Cards drawn per turn */
-    drawsPerTurn: number;
-    /** Starting health */
-    startingHealth: number;
-    /** Starting mana */
-    startingMana: number;
-    /** Maximum mana */
-    maxMana: number;
-    /** Mana gain per turn */
-    manaGainPerTurn: number;
-    /** Mill damage (deck empty) */
-    millDamage: number;
-}
-export declare const DEFAULT_CARD_CONFIG: CardConfig;
-export declare const DEFAULT_CARD_DEFINITIONS: CardDefinition[];
-export declare class NiceCard {
-    private config;
-    private definitions;
-    private cards;
-    private decks;
-    private players;
-    private eventListeners;
-    private nextId;
-    constructor(config?: Partial<CardConfig>);
-    on(event: CardEventType, callback: CardEventCallback): () => void;
-    private emit;
-    registerCard(definition: CardDefinition): void;
-    getDefinition(id: string): CardDefinition | undefined;
-    createPlayer(id: string, name: string): CardPlayerState;
-    getPlayer(id: string): CardPlayerState | undefined;
-    createDeck(ownerId: string, name: string): string;
-    addCardToDeck(deckId: string, cardDefId: string): string | null;
-    removeCardFromDeck(deckId: string, cardId: string): boolean;
-    private validateDeck;
-    private createCardInstance;
-    getCard(id: string): CardInstance | undefined;
-    initializeGame(playerIds: string[]): void;
-    setPlayerDeck(playerId: string, deckId: string): boolean;
-    shuffleDeck(playerId: string): void;
-    draw(playerId: string): string | null;
-    drawMultiple(playerId: string, count: number): string[];
-    playCard(playerId: string, cardId: string, targetId?: string): boolean;
-    private getCardCost;
-    private triggerEffects;
-    private executeEffect;
-    private applyEffect;
-    attack(attackerId: string, defenderId: string): boolean;
-    attackPlayer(attackerId: string, targetPlayerId: string): boolean;
-    private checkDeath;
-    tap(cardId: string): boolean;
-    untap(cardId: string): boolean;
-    untapAll(playerId: string): void;
-    startTurn(playerId: string): void;
-    endTurn(playerId: string): void;
-    discard(playerId: string, cardId: string): boolean;
-    getHandSize(playerId: string): number;
-    getDeckSize(playerId: string): number;
-    getBattlefieldCards(playerId: string): CardInstance[];
-    getHandCards(playerId: string): CardInstance[];
-    getPlayableCards(playerId: string): CardInstance[];
-    addModifier(cardId: string, modifier: Omit<CardModifier, 'id'>): string | null;
-    removeModifier(cardId: string, modifierId: string): boolean;
-    update(_deltaTime: number): void;
-    destroy(): void;
-}
-export declare function createCardSystem(config?: Partial<CardConfig>): NiceCard;