@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,252 @@
+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

@@ -0,0 +1,171 @@
+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;