@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,173 +0,0 @@
-import { EventEmitter } from 'events';
-export type AssetId = string;
-export type ChunkId = string;
-export type BundleId = string;
-export type RequestId = string;
-export type AssetType = 'texture' | 'model' | 'audio' | 'animation' | 'material' | 'shader' | 'script' | 'data' | 'scene' | 'prefab' | 'font' | 'video' | 'custom';
-export type AssetState = 'unloaded' | 'queued' | 'loading' | 'loaded' | 'streaming' | 'error' | 'unloading';
-export type LoadPriority = 'critical' | 'high' | 'normal' | 'low' | 'background';
-export interface Asset {
-    id: AssetId;
-    type: AssetType;
-    url: string;
-    state: AssetState;
-    size: number;
-    loadedSize: number;
-    data?: unknown;
-    bundle?: BundleId;
-    dependencies: AssetId[];
-    dependents: AssetId[];
-    refCount: number;
-    lastAccessTime: number;
-    priority: LoadPriority;
-    version: number;
-    checksum?: string;
-    metadata: Record<string, unknown>;
-}
-export interface AssetBundle {
-    id: BundleId;
-    url: string;
-    assets: AssetId[];
-    state: AssetState;
-    size: number;
-    loadedSize: number;
-    version: number;
-    download?: BundleDownload;
-}
-export interface BundleDownload {
-    progress: number;
-    bytesLoaded: number;
-    bytesTotal: number;
-    speed: number;
-    startTime: number;
-    estimatedTimeRemaining: number;
-}
-export interface StreamingChunk {
-    id: ChunkId;
-    bounds: {
-        min: Vector3;
-        max: Vector3;
-    };
-    assets: AssetId[];
-    state: AssetState;
-    priority: number;
-    distance: number;
-    lastActiveTime: number;
-}
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface LoadRequest {
-    id: RequestId;
-    assetId: AssetId;
-    priority: LoadPriority;
-    callback?: (asset: Asset) => void;
-    errorCallback?: (error: Error) => void;
-    startTime: number;
-    retryCount: number;
-}
-export interface MemoryInfo {
-    used: number;
-    reserved: number;
-    limit: number;
-    textureMemory: number;
-    audioMemory: number;
-    meshMemory: number;
-}
-export type StreamingEventType = 'asset-queued' | 'asset-loading' | 'asset-loaded' | 'asset-error' | 'asset-unloaded' | 'bundle-queued' | 'bundle-progress' | 'bundle-loaded' | 'bundle-error' | 'chunk-loaded' | 'chunk-unloaded' | 'memory-warning' | 'memory-critical';
-export interface StreamingEvent {
-    type: StreamingEventType;
-    assetId?: AssetId;
-    bundleId?: BundleId;
-    chunkId?: ChunkId;
-    data?: Record<string, unknown>;
-}
-export interface StreamingSystemConfig {
-    maxConcurrentLoads?: number;
-    memoryLimit?: number;
-    memoryWarningThreshold?: number;
-    memoryCriticalThreshold?: number;
-    defaultPriority?: LoadPriority;
-    retryAttempts?: number;
-    retryDelay?: number;
-    cacheEnabled?: boolean;
-    preloadRadius?: number;
-    unloadRadius?: number;
-    backgroundLoadingEnabled?: boolean;
-    maxBackgroundLoads?: number;
-}
-export declare const DEFAULT_STREAMING_CONFIG: StreamingSystemConfig;
-export declare class NiceStreaming extends EventEmitter {
-    private assets;
-    private bundles;
-    private chunks;
-    private loadQueue;
-    private activeLoads;
-    private config;
-    private requestIdCounter;
-    private memory;
-    private playerPosition;
-    private loaderFunctions;
-    constructor(config?: Partial<StreamingSystemConfig>);
-    registerAsset(options: {
-        id: AssetId;
-        type: AssetType;
-        url: string;
-        size?: number;
-        bundle?: BundleId;
-        dependencies?: AssetId[];
-        metadata?: Record<string, unknown>;
-    }): Asset;
-    unregisterAsset(assetId: AssetId): void;
-    getAsset(assetId: AssetId): Asset | undefined;
-    registerBundle(options: {
-        id: BundleId;
-        url: string;
-        size?: number;
-        version?: number;
-    }): AssetBundle;
-    getBundle(bundleId: BundleId): AssetBundle | undefined;
-    loadBundle(bundleId: BundleId): Promise<void>;
-    private downloadBundle;
-    registerChunk(options: {
-        id: ChunkId;
-        bounds: {
-            min: Vector3;
-            max: Vector3;
-        };
-        assets: AssetId[];
-    }): StreamingChunk;
-    unregisterChunk(chunkId: ChunkId): void;
-    getChunk(chunkId: ChunkId): StreamingChunk | undefined;
-    setPlayerPosition(position: Vector3): void;
-    loadAsset(assetId: AssetId, priority?: LoadPriority): Promise<Asset>;
-    loadAssets(assetIds: AssetId[], priority?: LoadPriority): Promise<Asset[]>;
-    private queueRequest;
-    private processQueue;
-    private startLoad;
-    private defaultLoad;
-    registerLoader(type: AssetType, loader: (asset: Asset) => Promise<unknown>): void;
-    unloadAsset(assetId: AssetId): void;
-    private doUnload;
-    forceUnload(assetId: AssetId): void;
-    private updateMemoryUsage;
-    private emergencyUnload;
-    private cleanupUnused;
-    getMemoryInfo(): MemoryInfo;
-    preload(assetIds: AssetId[]): void;
-    preloadChunk(chunkId: ChunkId): void;
-    update(_deltaTime: number): void;
-    private updateChunks;
-    private loadChunk;
-    private unloadChunk;
-    isLoaded(assetId: AssetId): boolean;
-    isLoading(assetId: AssetId): boolean;
-    getLoadProgress(assetId: AssetId): number;
-    getQueueLength(): number;
-    getActiveLoadsCount(): number;
-    private calculateDistance;
-}
-export declare function createStreamingSystem(config?: Partial<StreamingSystemConfig>): NiceStreaming;
-export default NiceStreaming;

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

@@ -1,166 +0,0 @@
-import { EventEmitter } from 'events';
-export type EntityId = string;
-export type WaterBodyId = string;
-export type CurrentId = string;
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export type WaterType = 'pool' | 'lake' | 'river' | 'ocean' | 'swamp' | 'hot_spring' | 'acid' | 'lava' | 'custom';
-export interface WaterBody {
-    id: WaterBodyId;
-    type: WaterType;
-    bounds: {
-        min: Vector3;
-        max: Vector3;
-    };
-    surfaceLevel: number;
-    depth: number;
-    temperature: number;
-    visibility: number;
-    density: number;
-    currents: Current[];
-    hazards: WaterHazard[];
-    isSwimmable: boolean;
-    damagePerSecond?: number;
-    effects: WaterEffect[];
-}
-export interface Current {
-    id: CurrentId;
-    direction: Vector3;
-    strength: number;
-    area: {
-        min: Vector3;
-        max: Vector3;
-    };
-    type: 'constant' | 'oscillating' | 'vortex';
-    frequency?: number;
-}
-export interface WaterHazard {
-    id: string;
-    type: 'whirlpool' | 'undertow' | 'jellyfish' | 'sharp_rocks' | 'creature';
-    position: Vector3;
-    radius: number;
-    damage: number;
-    effectId?: string;
-}
-export type WaterEffectType = 'slow' | 'poison' | 'heal' | 'buff' | 'debuff' | 'transform';
-export interface WaterEffect {
-    type: WaterEffectType;
-    strength: number;
-    duration?: number;
-    effectId: string;
-}
-export type SwimmingState = 'idle' | 'surface_idle' | 'surface_swimming' | 'diving' | 'underwater_swimming' | 'ascending' | 'drowning' | 'dead';
-export type SwimmingStyle = 'freestyle' | 'breaststroke' | 'backstroke' | 'butterfly' | 'doggy_paddle' | 'diving';
-export interface Swimmer {
-    entityId: EntityId;
-    state: SwimmingState;
-    style: SwimmingStyle;
-    position: Vector3;
-    velocity: Vector3;
-    currentWaterBody?: WaterBodyId;
-    depth: number;
-    breath: number;
-    maxBreath: number;
-    breathRate: number;
-    stamina: number;
-    maxStamina: number;
-    swimSpeed: number;
-    diveSpeed: number;
-    buoyancy: number;
-    waterResistance: number;
-    skills: SwimmingSkills;
-    equipment: SwimmingEquipment;
-    activeEffects: ActiveWaterEffect[];
-}
-export interface SwimmingSkills {
-    swimming: number;
-    diving: number;
-    breathHolding: number;
-    currentResistance: number;
-}
-export interface SwimmingEquipment {
-    hasFlippers: boolean;
-    hasSnorkel: boolean;
-    hasScuba: boolean;
-    hasWetsuit: boolean;
-    oxygenTank?: {
-        capacity: number;
-        remaining: number;
-    };
-}
-export interface ActiveWaterEffect {
-    effectId: string;
-    type: WaterEffectType;
-    strength: number;
-    startTime: number;
-    duration?: number;
-}
-export type SwimmingEventType = 'entered-water' | 'exited-water' | 'started-diving' | 'surfaced' | 'breath-warning' | 'drowning-started' | 'drowned' | 'current-entered' | 'current-exited' | 'hazard-hit' | 'effect-applied' | 'effect-removed';
-export interface SwimmingEvent {
-    type: SwimmingEventType;
-    entityId: EntityId;
-    waterBodyId?: WaterBodyId;
-    data?: Record<string, unknown>;
-}
-export interface SwimmingSystemConfig {
-    defaultMaxBreath?: number;
-    breathDepletionRate?: number;
-    breathRecoveryRate?: number;
-    breathWarningThreshold?: number;
-    drowningDamageRate?: number;
-    baseSwimSpeed?: number;
-    baseDiveSpeed?: number;
-    baseBuoyancy?: number;
-    surfaceDragMultiplier?: number;
-    underwaterDragMultiplier?: number;
-    currentResistanceBase?: number;
-    temperatureEffects?: boolean;
-}
-export declare const DEFAULT_SWIMMING_CONFIG: SwimmingSystemConfig;
-export declare class NiceSwimming extends EventEmitter {
-    private waterBodies;
-    private swimmers;
-    private config;
-    constructor(config?: Partial<SwimmingSystemConfig>);
-    createWaterBody(definition: WaterBody): WaterBody;
-    removeWaterBody(id: WaterBodyId): void;
-    getWaterBody(id: WaterBodyId): WaterBody | undefined;
-    addCurrent(waterBodyId: WaterBodyId, current: Current): void;
-    removeCurrent(waterBodyId: WaterBodyId, currentId: CurrentId): void;
-    addHazard(waterBodyId: WaterBodyId, hazard: WaterHazard): void;
-    registerSwimmer(entityId: EntityId, skills?: Partial<SwimmingSkills>, equipment?: Partial<SwimmingEquipment>): void;
-    unregisterSwimmer(entityId: EntityId): void;
-    getSwimmer(entityId: EntityId): Swimmer | undefined;
-    equipItem(entityId: EntityId, item: keyof SwimmingEquipment): void;
-    enterWater(entityId: EntityId, waterBodyId: WaterBodyId, position: Vector3): boolean;
-    exitWater(entityId: EntityId): void;
-    swim(entityId: EntityId, direction: Vector3, intensity?: number): void;
-    dive(entityId: EntityId, targetDepth: number): boolean;
-    surface(entityId: EntityId): void;
-    setSwimmingStyle(entityId: EntityId, style: SwimmingStyle): void;
-    update(deltaTime: number): void;
-    private updateSwimmer;
-    private applyCurrents;
-    private updateBreathing;
-    private checkHazards;
-    private applyWaterEffect;
-    private updateEffects;
-    isSwimming(entityId: EntityId): boolean;
-    isUnderwater(entityId: EntityId): boolean;
-    getDepth(entityId: EntityId): number;
-    getBreath(entityId: EntityId): {
-        current: number;
-        max: number;
-    } | undefined;
-    getWaterBodyAtPosition(position: Vector3): WaterBodyId | undefined;
-    private isInBounds;
-    private isInArea;
-    private calculateDistance;
-}
-export declare function createSwimmingSystem(config?: Partial<SwimmingSystemConfig>): NiceSwimming;
-export declare function defineWaterBody(options: WaterBody): WaterBody;
-export declare function defineCurrent(options: Current): Current;
-export default NiceSwimming;

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

@@ -1,154 +0,0 @@
-export type TalentTreeId = string;
-export type TalentId = string;
-export type TalentTierId = string;
-export type SpecId = string;
-export interface TalentTree {
-    id: TalentTreeId;
-    name: string;
-    description?: string;
-    icon: string;
-    background?: string;
-    color?: string;
-    tiers: TalentTier[];
-    classRequired?: string[];
-    levelRequired?: number;
-    maxPoints: number;
-    pointsPerLevel?: number;
-    startingLevel?: number;
-}
-export interface TalentTier {
-    id: TalentTierId;
-    treeId: TalentTreeId;
-    index: number;
-    name?: string;
-    pointsRequired: number;
-    talents: TalentId[];
-    columns?: number;
-}
-export interface TalentDefinition {
-    id: TalentId;
-    treeId: TalentTreeId;
-    tierId: TalentTierId;
-    name: string;
-    description: string;
-    maxRanks: number;
-    rankDescriptions?: string[];
-    row: number;
-    column: number;
-    icon: string;
-    prerequisites?: TalentPrerequisite[];
-    effects: TalentEffect[];
-    exclusiveWith?: TalentId[];
-    type: 'passive' | 'active' | 'proc' | 'modifier';
-    grantedAbility?: string;
-    tags?: string[];
-}
-export interface TalentPrerequisite {
-    type: 'talent' | 'tree_points' | 'level' | 'class';
-    talentId?: TalentId;
-    requiredRanks?: number;
-    pointsRequired?: number;
-    levelRequired?: number;
-    classRequired?: string[];
-}
-export interface TalentEffect {
-    type: 'stat_bonus' | 'damage_increase' | 'cooldown_reduction' | 'cost_reduction' | 'chance_proc' | 'unlock_ability' | 'modify_ability' | 'custom';
-    target?: string;
-    values: number[];
-    stat?: string;
-    isPercentage?: boolean;
-    abilityId?: string;
-    effectData?: Record<string, unknown>;
-}
-export interface PlayerTalentData {
-    playerId: string;
-    specs: Map<SpecId, PlayerSpec>;
-    activeSpecId: SpecId;
-    availablePoints: number;
-    totalPointsSpent: number;
-    lastRespec: number;
-    totalRespecs: number;
-}
-export interface PlayerSpec {
-    id: SpecId;
-    name: string;
-    treePoints: Map<TalentTreeId, number>;
-    talents: Map<TalentId, number>;
-    activeEffects: ComputedTalentEffect[];
-    createdAt: number;
-    lastModified: number;
-}
-export interface ComputedTalentEffect {
-    talentId: TalentId;
-    effectIndex: number;
-    effect: TalentEffect;
-    currentValue: number;
-    currentRank: number;
-}
-export type TalentEventType = 'talent-allocated' | 'talent-unallocated' | 'points-gained' | 'spec-created' | 'spec-switched' | 'spec-reset' | 'effects-updated';
-export interface TalentEvent {
-    type: TalentEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type TalentEventCallback = (event: TalentEvent) => void;
-export interface TalentConfig {
-    maxSpecs: number;
-    freeRespecUntilLevel: number;
-    respecCostBase: number;
-    respecCostPerPoint: number;
-    respecCooldown: number;
-    pointsPerLevel: number;
-    startingLevel: number;
-    storageKey: string;
-}
-export declare const DEFAULT_TALENT_CONFIG: TalentConfig;
-export declare class NiceTalent {
-    private config;
-    private trees;
-    private talents;
-    private playerData;
-    private eventListeners;
-    private onDeductCost?;
-    constructor(config?: Partial<TalentConfig>);
-    on(event: TalentEventType, callback: TalentEventCallback): () => void;
-    private emit;
-    setCostHandler(handler: typeof this.onDeductCost): void;
-    registerTree(tree: TalentTree): void;
-    registerTalent(talent: TalentDefinition): void;
-    grantPoints(playerId: string, amount: number): void;
-    getAvailablePoints(playerId: string): number;
-    calculatePointsForLevel(level: number): number;
-    syncPointsWithLevel(playerId: string, level: number): void;
-    allocateTalent(playerId: string, talentId: TalentId): boolean;
-    unallocateTalent(playerId: string, talentId: TalentId): boolean;
-    private canUnallocate;
-    private checkPrerequisites;
-    createSpec(playerId: string, name: string): PlayerSpec | null;
-    switchSpec(playerId: string, specId: SpecId): boolean;
-    resetSpec(playerId: string, specId?: SpecId, playerLevel?: number): boolean;
-    renameSpec(playerId: string, specId: SpecId, name: string): boolean;
-    deleteSpec(playerId: string, specId: SpecId): boolean;
-    private updateSpecEffects;
-    getTree(id: TalentTreeId): TalentTree | undefined;
-    getAllTrees(): TalentTree[];
-    getTalent(id: TalentId): TalentDefinition | undefined;
-    getAllTalents(): TalentDefinition[];
-    getTalentsByTree(treeId: TalentTreeId): TalentDefinition[];
-    getPlayerData(playerId: string): PlayerTalentData | undefined;
-    getActiveSpec(playerId: string): PlayerSpec | undefined;
-    getSpecs(playerId: string): PlayerSpec[];
-    getTalentRanks(playerId: string, talentId: TalentId): number;
-    getTreePoints(playerId: string, treeId: TalentTreeId): number;
-    getActiveEffects(playerId: string): ComputedTalentEffect[];
-    getEffectsByType(playerId: string, effectType: TalentEffect['type']): ComputedTalentEffect[];
-    getTotalStatBonus(playerId: string, stat: string): number;
-    canAllocate(playerId: string, talentId: TalentId): boolean;
-    getRespecCost(playerId: string, specId?: SpecId): number;
-    private getOrCreatePlayerData;
-    private save;
-    private load;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createTalentSystem(config?: Partial<TalentConfig>): NiceTalent;

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

@@ -1,121 +0,0 @@
-import { EventEmitter } from 'events';
-export type EntityId = string;
-export type TargetGroupId = string;
-export type FactionId = string;
-export interface Vector2 {
-    x: number;
-    y: number;
-}
-export interface TargetableEntity {
-    id: EntityId;
-    position: Vector2;
-    faction: FactionId;
-    targetable: boolean;
-    health?: number;
-    maxHealth?: number;
-    priority?: number;
-    tags?: string[];
-    threatTable?: Map<EntityId, number>;
-}
-export interface TargetFilter {
-    factions?: FactionId[];
-    excludeFactions?: FactionId[];
-    tags?: string[];
-    excludeTags?: string[];
-    minHealth?: number;
-    maxHealth?: number;
-    minHealthPercent?: number;
-    maxHealthPercent?: number;
-    maxDistance?: number;
-    minDistance?: number;
-    requireLOS?: boolean;
-    custom?: (entity: TargetableEntity) => boolean;
-}
-export type TargetPriority = 'nearest' | 'farthest' | 'lowest-health' | 'highest-health' | 'lowest-health-percent' | 'highest-health-percent' | 'highest-threat' | 'lowest-threat' | 'random' | 'highest-priority' | 'custom';
-export interface TargetingRules {
-    priority: TargetPriority;
-    maxTargets?: number;
-    requireLOS?: boolean;
-    stickyTarget?: boolean;
-    stickyThreshold?: number;
-    customSort?: (a: TargetableEntity, b: TargetableEntity, source: Vector2) => number;
-}
-export type FactionRelation = 'friendly' | 'neutral' | 'hostile';
-export interface FactionConfig {
-    id: FactionId;
-    name: string;
-    relations: Map<FactionId, FactionRelation>;
-}
-export interface TargetLock {
-    sourceId: EntityId;
-    targetId: EntityId;
-    lockTime: number;
-    lockDuration: number;
-    breakOnLOS?: boolean;
-    breakOnDistance?: number;
-}
-export type TargetEventType = 'target-acquired' | 'target-lost' | 'target-changed' | 'target-locked' | 'target-unlocked' | 'threat-changed' | 'los-gained' | 'los-lost';
-export interface TargetEvent {
-    type: TargetEventType;
-    sourceId: EntityId;
-    targetId?: EntityId;
-    previousTargetId?: EntityId;
-    threat?: number;
-}
-export interface TargetingConfig {
-    defaultMaxDistance?: number;
-    defaultLOSRequired?: boolean;
-    threatDecayRate?: number;
-    threatDecayInterval?: number;
-    maxThreatTableSize?: number;
-}
-export declare const DEFAULT_TARGETING_CONFIG: TargetingConfig;
-export declare class NiceTarget extends EventEmitter {
-    private entities;
-    private factions;
-    private currentTargets;
-    private targetLocks;
-    private losCache;
-    private losCacheTime;
-    private config;
-    private losChecker?;
-    constructor(config?: Partial<TargetingConfig>);
-    setLOSChecker(checker: (from: Vector2, to: Vector2) => boolean): void;
-    registerFaction(faction: FactionConfig): void;
-    unregisterFaction(factionId: FactionId): boolean;
-    setRelation(faction1: FactionId, faction2: FactionId, relation: FactionRelation): void;
-    getRelation(faction1: FactionId, faction2: FactionId): FactionRelation;
-    isHostile(faction1: FactionId, faction2: FactionId): boolean;
-    isFriendly(faction1: FactionId, faction2: FactionId): boolean;
-    registerEntity(entity: TargetableEntity): void;
-    unregisterEntity(entityId: EntityId): void;
-    updateEntity(entityId: EntityId, updates: Partial<TargetableEntity>): void;
-    setPosition(entityId: EntityId, position: Vector2): void;
-    findTargets(sourceId: EntityId, filter?: TargetFilter, rules?: TargetingRules): TargetableEntity[];
-    private matchesFilter;
-    private sortByPriority;
-    acquireTarget(sourceId: EntityId, filter?: TargetFilter, rules?: TargetingRules): EntityId | null;
-    clearTarget(sourceId: EntityId): void;
-    getCurrentTarget(sourceId: EntityId): EntityId | null;
-    lockTarget(sourceId: EntityId, targetId: EntityId, duration: number, options?: {
-        breakOnLOS?: boolean;
-        breakOnDistance?: number;
-    }): void;
-    unlockTarget(sourceId: EntityId): void;
-    isTargetLocked(sourceId: EntityId): boolean;
-    hasLOS(from: Vector2, to: Vector2): boolean;
-    checkLOS(sourceId: EntityId, targetId: EntityId): boolean;
-    clearLOSCache(): void;
-    addThreat(sourceId: EntityId, targetId: EntityId, amount: number): void;
-    getThreat(sourceId: EntityId, targetId: EntityId): number;
-    getHighestThreat(sourceId: EntityId): EntityId | null;
-    clearThreat(sourceId: EntityId, targetId?: EntityId): void;
-    getDistance(from: Vector2, to: Vector2): number;
-    getDistanceBetween(entityId1: EntityId, entityId2: EntityId): number;
-    isInRange(sourceId: EntityId, targetId: EntityId, range: number): boolean;
-    update(_deltaTime: number): void;
-}
-export declare function createTargetingSystem(config?: Partial<TargetingConfig>): NiceTarget;
-export declare function createFaction(id: FactionId, name: string, relations?: Map<FactionId, FactionRelation>): FactionConfig;
-export declare function createTargetFilter(filter: TargetFilter): TargetFilter;
-export default NiceTarget;