@nice2dev/game-engine 1.1.5 → 1.1.7

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

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

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

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

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