@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,333 @@
+export type VFXId = string;
+export type EffectType = 'shake' | 'flash' | 'fade' | 'blur' | 'vignette' | 'chromatic' | 'scanlines' | 'grain' | 'pixelate' | 'distort' | 'glow';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface BaseEffect {
+    id: VFXId;
+    type: string;
+    duration: number;
+    elapsed: number;
+    active: boolean;
+    layer: number;
+    blend: 'normal' | 'additive' | 'multiply' | 'screen';
+}
+export interface ShakeEffect extends BaseEffect {
+    type: 'shake';
+    intensity: number;
+    frequency: number;
+    decay: number;
+    offset: Vec2;
+    rotation: number;
+    seed: number;
+}
+export interface ShakeConfig {
+    intensity?: number;
+    duration?: number;
+    frequency?: number;
+    decay?: number;
+    rotational?: boolean;
+}
+export interface FlashEffect extends BaseEffect {
+    type: 'flash';
+    color: Color;
+    fadeIn: number;
+    fadeOut: number;
+    hold: number;
+    currentAlpha: number;
+}
+export interface FlashConfig {
+    color?: Color;
+    duration?: number;
+    fadeIn?: number;
+    fadeOut?: number;
+    hold?: number;
+}
+export interface FadeEffect extends BaseEffect {
+    type: 'fade';
+    color: Color;
+    from: number;
+    to: number;
+    currentAlpha: number;
+    easing: (t: number) => number;
+}
+export interface FadeConfig {
+    color?: Color;
+    duration?: number;
+    from?: number;
+    to?: number;
+    easing?: (t: number) => number;
+}
+export interface BlurEffect extends BaseEffect {
+    type: 'blur';
+    strength: number;
+    maxStrength: number;
+}
+export interface VignetteEffect extends BaseEffect {
+    type: 'vignette';
+    intensity: number;
+    maxIntensity: number;
+    color: Color;
+}
+export interface ChromaticEffect extends BaseEffect {
+    type: 'chromatic';
+    intensity: number;
+    maxIntensity: number;
+}
+export interface ScanlinesEffect extends BaseEffect {
+    type: 'scanlines';
+    intensity: number;
+    count: number;
+    speed: number;
+    offset: number;
+}
+export interface GrainEffect extends BaseEffect {
+    type: 'grain';
+    intensity: number;
+    size: number;
+    animated: boolean;
+    seed: number;
+}
+export interface PixelateEffect extends BaseEffect {
+    type: 'pixelate';
+    size: number;
+    maxSize: number;
+}
+export interface DistortEffect extends BaseEffect {
+    type: 'distort';
+    amplitude: number;
+    frequency: number;
+    speed: number;
+    time: number;
+}
+export interface GlowEffect extends BaseEffect {
+    type: 'glow';
+    intensity: number;
+    color: Color;
+    radius: number;
+}
+export type ScreenEffect = ShakeEffect | FlashEffect | FadeEffect | BlurEffect | VignetteEffect | ChromaticEffect | ScanlinesEffect | GrainEffect | PixelateEffect | DistortEffect | GlowEffect;
+export interface TrailPoint {
+    position: Vec2;
+    time: number;
+    width: number;
+    color: Color;
+}
+export interface TrailEffect {
+    id: VFXId;
+    points: TrailPoint[];
+    maxPoints: number;
+    lifetime: number;
+    width: number;
+    color: Color;
+    fadeOut: boolean;
+    emitting: boolean;
+}
+export interface TrailConfig {
+    maxPoints?: number;
+    lifetime?: number;
+    width?: number;
+    color?: Color;
+    fadeOut?: boolean;
+}
+export interface TextPopup {
+    id: VFXId;
+    text: string;
+    position: Vec2;
+    velocity: Vec2;
+    color: Color;
+    fontSize: number;
+    font: string;
+    duration: number;
+    elapsed: number;
+    fadeStart: number;
+    scale: number;
+    targetScale: number;
+    rotation: number;
+    shadow?: boolean;
+    outline?: Color;
+}
+export interface TextPopupConfig {
+    text: string;
+    position: Vec2;
+    color?: Color;
+    fontSize?: number;
+    font?: string;
+    duration?: number;
+    velocity?: Vec2;
+    fadeStart?: number;
+    scale?: number;
+    shadow?: boolean;
+    outline?: Color;
+}
+export interface ImpactEffect {
+    id: VFXId;
+    position: Vec2;
+    type: 'explosion' | 'hit' | 'slash' | 'spark' | 'shockwave';
+    radius: number;
+    duration: number;
+    elapsed: number;
+    color: Color;
+    particles: Array<{
+        position: Vec2;
+        velocity: Vec2;
+        life: number;
+        maxLife: number;
+        size: number;
+        color: Color;
+    }>;
+}
+export interface ImpactConfig {
+    position: Vec2;
+    type?: 'explosion' | 'hit' | 'slash' | 'spark' | 'shockwave';
+    radius?: number;
+    duration?: number;
+    color?: Color;
+    particleCount?: number;
+}
+export interface CompositeEffect {
+    id: VFXId;
+    effects: VFXId[];
+    sequential: boolean;
+    currentIndex: number;
+    active: boolean;
+}
+export type VFXEventType = 'effect-started' | 'effect-updated' | 'effect-completed' | 'effect-cancelled';
+export interface VFXEvent {
+    type: VFXEventType;
+    timestamp: number;
+    effectId: VFXId;
+    data?: unknown;
+}
+export type VFXEventCallback = (event: VFXEvent) => void;
+export interface VFXConfig {
+    maxEffects: number;
+    defaultBlend: 'normal' | 'additive' | 'multiply' | 'screen';
+    enablePostProcessing: boolean;
+}
+export declare const DEFAULT_VFX_CONFIG: VFXConfig;
+export declare const VFX_COLORS: {
+    white: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    black: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    red: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    green: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    blue: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    yellow: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    orange: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    purple: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    cyan: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    gold: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+};
+export declare class NiceVFX {
+    private config;
+    private screenEffects;
+    private trails;
+    private textPopups;
+    private impacts;
+    private composites;
+    private eventListeners;
+    private idCounter;
+    private shakeOffset;
+    private shakeRotation;
+    private fadeAlpha;
+    private fadeColor;
+    constructor(config?: Partial<VFXConfig>);
+    on(event: VFXEventType, callback: VFXEventCallback): () => void;
+    private emit;
+    private nextId;
+    shake(config?: ShakeConfig): VFXId;
+    flash(config?: FlashConfig): VFXId;
+    fadeIn(duration?: number, color?: Color): VFXId;
+    fadeOut(duration?: number, color?: Color): VFXId;
+    fade(config?: FadeConfig): VFXId;
+    blur(strength: number, duration?: number): VFXId;
+    vignette(intensity: number, color?: Color, duration?: number): VFXId;
+    chromatic(intensity: number, duration?: number): VFXId;
+    createTrail(config?: TrailConfig): VFXId;
+    updateTrailPosition(id: VFXId, position: Vec2): void;
+    stopTrail(id: VFXId): void;
+    textPopup(config: TextPopupConfig): VFXId;
+    damageNumber(value: number, position: Vec2, critical?: boolean): VFXId;
+    healNumber(value: number, position: Vec2): VFXId;
+    impact(config: ImpactConfig): VFXId;
+    explosion(position: Vec2, radius?: number): VFXId;
+    hit(position: Vec2, color?: Color): VFXId;
+    composite(effects: VFXId[], sequential?: boolean): VFXId;
+    update(deltaTime: number): void;
+    private updateScreenEffects;
+    private updateTrails;
+    private updateTextPopups;
+    private updateImpacts;
+    private updateComposites;
+    private calculateCombinedShake;
+    private calculateCombinedFade;
+    getShakeOffset(): Vec2;
+    getShakeRotation(): number;
+    getFadeAlpha(): number;
+    getFadeColor(): Color;
+    getTrails(): TrailEffect[];
+    getTextPopups(): TextPopup[];
+    getImpacts(): ImpactEffect[];
+    getScreenEffects(): ScreenEffect[];
+    cancel(id: VFXId): void;
+    clearAll(): void;
+    destroy(): void;
+}
+export declare function createVFXSystem(config?: Partial<VFXConfig>): NiceVFX;

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

@@ -0,0 +1,176 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type VehicleId = string;
+export type VehicleTypeId = string;
+export type PartId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export type VehicleCategory = 'ground' | 'air' | 'water' | 'amphibious' | 'space' | 'mech' | 'hover';
+export type PropulsionType = 'wheels' | 'tracks' | 'legs' | 'propeller' | 'jet' | 'rocket' | 'hover' | 'sail' | 'none';
+export interface VehicleType {
+    id: VehicleTypeId;
+    name: string;
+    category: VehicleCategory;
+    propulsion: PropulsionType;
+    maxHealth: number;
+    armor: number;
+    mass: number;
+    drag: number;
+    seats: SeatConfig[];
+    fuelCapacity: number;
+    fuelConsumption: number;
+    maxSpeed: number;
+    acceleration: number;
+    turnRate: number;
+    brakeForce: number;
+    canReverse: boolean;
+    partSlots: PartSlot[];
+    abilities?: VehicleAbility[];
+}
+export type SeatRole = 'driver' | 'gunner' | 'passenger' | 'engineer';
+export interface SeatConfig {
+    id: string;
+    role: SeatRole;
+    position: Vector3;
+    entryPoint: Vector3;
+    exitPoint: Vector3;
+    canControl: boolean;
+    animations?: string[];
+}
+export interface OccupiedSeat {
+    seatId: string;
+    occupantId: EntityId;
+    enteredAt: number;
+}
+export type PartCategory = 'engine' | 'armor' | 'weapon' | 'utility' | 'cosmetic' | 'fuel' | 'navigation';
+export interface PartSlot {
+    id: string;
+    category: PartCategory;
+    position: Vector3;
+    rotation?: Quaternion;
+    maxSize: number;
+}
+export interface VehiclePart {
+    id: PartId;
+    name: string;
+    category: PartCategory;
+    size: number;
+    weight: number;
+    health: number;
+    modifiers: {
+        speed?: number;
+        acceleration?: number;
+        armor?: number;
+        fuelEfficiency?: number;
+        turnRate?: number;
+    };
+    abilities?: VehicleAbility[];
+}
+export interface VehicleAbility {
+    id: string;
+    name: string;
+    cooldown: number;
+    energyCost: number;
+    effects: {
+        type: string;
+        value: number;
+    }[];
+}
+export interface Vehicle {
+    id: VehicleId;
+    typeId: VehicleTypeId;
+    ownerId?: EntityId;
+    position: Vector3;
+    rotation: Quaternion;
+    velocity: Vector3;
+    angularVelocity: Vector3;
+    health: number;
+    maxHealth: number;
+    fuel: number;
+    maxFuel: number;
+    seats: OccupiedSeat[];
+    installedParts: Map<string, VehiclePart>;
+    state: VehicleState;
+    isEngineOn: boolean;
+    throttle: number;
+    steering: number;
+    brake: number;
+    handbrake: boolean;
+    abilityCooldowns: Map<string, number>;
+    damagedParts: Set<string>;
+}
+export type VehicleState = 'idle' | 'moving' | 'stopped' | 'damaged' | 'destroyed' | 'submerged' | 'airborne';
+export type VehicleEventType = 'vehicle-spawned' | 'vehicle-destroyed' | 'entered-vehicle' | 'exited-vehicle' | 'seat-changed' | 'engine-started' | 'engine-stopped' | 'fuel-depleted' | 'part-damaged' | 'part-destroyed' | 'part-installed' | 'part-removed' | 'ability-used' | 'collision';
+export interface VehicleEvent {
+    type: VehicleEventType;
+    vehicleId: VehicleId;
+    entityId?: EntityId;
+    data?: Record<string, unknown>;
+}
+export interface VehicleSystemConfig {
+    maxVehicles?: number;
+    physicsEnabled?: boolean;
+    fuelEnabled?: boolean;
+    damageEnabled?: boolean;
+    autoEjectOnDestroy?: boolean;
+    collisionDamageMultiplier?: number;
+    gravityScale?: number;
+}
+export declare const DEFAULT_VEHICLE_CONFIG: VehicleSystemConfig;
+export declare class NiceVehicle extends EventEmitter {
+    private vehicleTypes;
+    private vehicles;
+    private parts;
+    private entityToVehicle;
+    private nextVehicleId;
+    private config;
+    constructor(config?: Partial<VehicleSystemConfig>);
+    defineVehicleType(type: VehicleType): void;
+    getVehicleType(id: VehicleTypeId): VehicleType | undefined;
+    definePart(part: VehiclePart): void;
+    getPart(id: PartId): VehiclePart | undefined;
+    spawnVehicle(typeId: VehicleTypeId, position: Vector3, rotation?: Quaternion, ownerId?: EntityId): VehicleId | null;
+    despawnVehicle(vehicleId: VehicleId): void;
+    getVehicle(id: VehicleId): Vehicle | undefined;
+    enterVehicle(entityId: EntityId, vehicleId: VehicleId, seatId?: string): boolean;
+    exitVehicle(entityId: EntityId): boolean;
+    changeSeat(entityId: EntityId, targetSeatId: string): boolean;
+    getOccupants(vehicleId: VehicleId): EntityId[];
+    getDriver(vehicleId: VehicleId): EntityId | null;
+    setThrottle(vehicleId: VehicleId, value: number): void;
+    setSteering(vehicleId: VehicleId, value: number): void;
+    setBrake(vehicleId: VehicleId, value: number): void;
+    setHandbrake(vehicleId: VehicleId, engaged: boolean): void;
+    startEngine(vehicleId: VehicleId): boolean;
+    stopEngine(vehicleId: VehicleId): void;
+    installPart(vehicleId: VehicleId, slotId: string, partId: PartId): boolean;
+    removePart(vehicleId: VehicleId, slotId: string): VehiclePart | null;
+    damage(vehicleId: VehicleId, amount: number, _source?: string): void;
+    repair(vehicleId: VehicleId, amount: number): void;
+    private destroyVehicle;
+    refuel(vehicleId: VehicleId, amount: number): void;
+    getFuel(vehicleId: VehicleId): number;
+    useAbility(vehicleId: VehicleId, abilityId: string): boolean;
+    update(deltaTime: number): void;
+    private updateVehicle;
+    private getForwardVector;
+    private rotateY;
+    private getSpeed;
+    getEntityVehicle(entityId: EntityId): Vehicle | null;
+    getAllVehicles(): Vehicle[];
+    getNearbyVehicles(position: Vector3, radius: number): Vehicle[];
+    getAvailableSeats(vehicleId: VehicleId): SeatConfig[];
+}
+export declare function createVehicleSystem(config?: Partial<VehicleSystemConfig>): NiceVehicle;
+export declare function defineVehicleType(options: VehicleType): VehicleType;
+export declare function defineVehiclePart(options: VehiclePart): VehiclePart;
+export default NiceVehicle;