@nice2dev/game-engine 1.3.13 → 1.3.15

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

@@ -1,115 +0,0 @@
-/** Local emitter wrapper tolerating loose .on/.off signatures. */
-declare class NiceMessageBusEmitter {
-    private _emitter;
-    emit(event: string, ...args: unknown[]): boolean;
-}
-export type MessageType = string;
-export type ChannelId = string;
-export type SubscriberId = string;
-export interface Message<T = unknown> {
-    id: string;
-    type: MessageType;
-    payload: T;
-    timestamp: number;
-    sender?: string;
-    channel?: ChannelId;
-    priority?: number;
-    metadata?: Record<string, unknown>;
-}
-export type MessageHandler<T = unknown> = (message: Message<T>) => void | Promise<void>;
-export type MessageFilter<T = unknown> = (message: Message<T>) => boolean;
-export type Middleware = (message: Message, next: () => void) => void | Promise<void>;
-export interface Subscription {
-    id: SubscriberId;
-    type: MessageType | '*';
-    channel?: ChannelId;
-    handler: MessageHandler;
-    filter?: MessageFilter;
-    priority: number;
-    once: boolean;
-}
-export interface Request<TReq = unknown, _TRes = unknown> extends Message<TReq> {
-    replyTo: string;
-    timeout?: number;
-}
-export interface Response<T = unknown> extends Message<T> {
-    requestId: string;
-    success: boolean;
-    error?: string;
-}
-export type MessageBusEventType = 'message-sent' | 'message-received' | 'subscriber-added' | 'subscriber-removed' | 'error';
-export interface MessageBusEvent {
-    type: MessageBusEventType;
-    messageId?: string;
-    subscriberId?: string;
-    error?: Error;
-}
-export interface MessageBusConfig {
-    maxQueueSize?: number;
-    defaultTimeout?: number;
-    async?: boolean;
-    middleware?: Middleware[];
-}
-export declare const DEFAULT_MESSAGE_BUS_CONFIG: MessageBusConfig;
-export declare class NiceMessageBus extends NiceMessageBusEmitter {
-    private subscriptions;
-    private typeIndex;
-    private channelIndex;
-    private wildcardSubscribers;
-    private messageQueue;
-    private pendingRequests;
-    private middleware;
-    private nextId;
-    private config;
-    private processing;
-    constructor(config?: Partial<MessageBusConfig>);
-    use(middleware: Middleware): void;
-    subscribe<T = unknown>(type: MessageType | '*', handler: MessageHandler<T>, options?: {
-        channel?: ChannelId;
-        filter?: MessageFilter<T>;
-        priority?: number;
-        once?: boolean;
-    }): SubscriberId;
-    once<T = unknown>(type: MessageType, handler: MessageHandler<T>, options?: Omit<Parameters<typeof this.subscribe>[2], 'once'>): SubscriberId;
-    unsubscribe(id: SubscriberId): boolean;
-    unsubscribeAll(channel?: ChannelId): void;
-    publish<T = unknown>(type: MessageType, payload: T, options?: {
-        channel?: ChannelId;
-        sender?: string;
-        priority?: number;
-        metadata?: Record<string, unknown>;
-    }): string;
-    private dispatchMessage;
-    private processQueue;
-    private deliverMessage;
-    private getMatchingSubscribers;
-    private matchesChannel;
-    request<TReq = unknown, TRes = unknown>(type: MessageType, payload: TReq, options?: {
-        channel?: ChannelId;
-        timeout?: number;
-        sender?: string;
-    }): Promise<TRes>;
-    respond<T>(request: Request, payload: T, success?: boolean, error?: string): void;
-    createChannel(id: ChannelId): void;
-    deleteChannel(id: ChannelId): void;
-    getChannels(): ChannelId[];
-    getSubscriberCount(): number;
-    getQueueSize(): number;
-    getPendingRequestCount(): number;
-    clear(): void;
-}
-export declare function createMessageBus(config?: Partial<MessageBusConfig>): NiceMessageBus;
-export interface TypedChannel<T> {
-    publish(payload: T, options?: {
-        sender?: string;
-        priority?: number;
-    }): string;
-    subscribe(handler: MessageHandler<T>, options?: {
-        filter?: MessageFilter<T>;
-        priority?: number;
-    }): SubscriberId;
-    once(handler: MessageHandler<T>): SubscriberId;
-    unsubscribeAll(): void;
-}
-export declare function createTypedChannel<T>(bus: NiceMessageBus, channelId: ChannelId, messageType: MessageType): TypedChannel<T>;
-export default NiceMessageBus;

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

@@ -1,258 +0,0 @@
-export type EntityId = string;
-export type MarkerId = string;
-export type ZoneId = string;
-export type WaypointId = string;
-export type PingId = string;
-export type OverlayId = string;
-export interface Vector2 {
-    x: number;
-    y: number;
-}
-export interface Bounds {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-export type MinimapMode = 'fixed' | 'rotating' | 'follow' | 'full';
-export type MarkerType = 'player' | 'ally' | 'enemy' | 'neutral' | 'objective' | 'quest' | 'poi' | 'resource' | 'building' | 'vehicle' | 'custom';
-export interface MinimapMarker {
-    id: MarkerId;
-    entityId?: EntityId;
-    type: MarkerType;
-    position: Vector2;
-    rotation?: number;
-    icon?: string;
-    color?: string;
-    size?: number;
-    label?: string;
-    priority?: number;
-    visible: boolean;
-    trackRotation?: boolean;
-    blinkRate?: number;
-    pulseEffect?: boolean;
-    /** Custom render data */
-    customData?: Record<string, unknown>;
-}
-export type ZoneShape = 'rectangle' | 'circle' | 'polygon';
-export interface MinimapZone {
-    id: ZoneId;
-    name?: string;
-    shape: ZoneShape;
-    /** For rectangle */
-    bounds?: Bounds;
-    /** For circle */
-    center?: Vector2;
-    radius?: number;
-    /** For polygon */
-    points?: Vector2[];
-    color?: string;
-    fillOpacity?: number;
-    borderColor?: string;
-    borderWidth?: number;
-    visible: boolean;
-    layer?: number;
-}
-export interface MinimapWaypoint {
-    id: WaypointId;
-    position: Vector2;
-    targetPosition?: Vector2;
-    icon?: string;
-    color?: string;
-    label?: string;
-    showPath?: boolean;
-    pathPoints?: Vector2[];
-    showDistance?: boolean;
-    createdBy?: EntityId;
-    expires?: number;
-    visible: boolean;
-}
-export type PingType = 'alert' | 'attack' | 'defend' | 'help' | 'omw' | 'caution' | 'custom';
-export interface MinimapPing {
-    id: PingId;
-    type: PingType;
-    position: Vector2;
-    color?: string;
-    icon?: string;
-    label?: string;
-    sound?: string;
-    createdBy?: EntityId;
-    createdAt: number;
-    duration: number;
-    animation?: 'pulse' | 'expand' | 'flash';
-}
-export interface MinimapOverlay {
-    id: OverlayId;
-    imageUrl?: string;
-    bounds: Bounds;
-    opacity?: number;
-    visible: boolean;
-    zIndex?: number;
-}
-export interface FogOfWarConfig {
-    enabled: boolean;
-    /** Grid cell size */
-    cellSize: number;
-    /** Fog color */
-    fogColor: string;
-    /** Explored but not visible color */
-    exploredColor: string;
-    /** Unexplored fully hidden */
-    hideUnexplored: boolean;
-}
-export interface FogCell {
-    x: number;
-    y: number;
-    state: 'unexplored' | 'explored' | 'visible';
-    lastVisibleTime?: number;
-}
-export interface MinimapView {
-    center: Vector2;
-    zoom: number;
-    rotation: number;
-    mode: MinimapMode;
-    followEntityId?: EntityId;
-}
-export type MinimapEventType = 'marker-added' | 'marker-removed' | 'marker-updated' | 'zone-added' | 'zone-removed' | 'waypoint-added' | 'waypoint-removed' | 'ping-created' | 'ping-expired' | 'fog-revealed' | 'view-changed' | 'click' | 'hover';
-export interface MinimapEvent {
-    type: MinimapEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type MinimapEventCallback = (event: MinimapEvent) => void;
-export interface MinimapConfig {
-    /** World bounds */
-    worldBounds: Bounds;
-    /** Default minimap size */
-    size: {
-        width: number;
-        height: number;
-    };
-    /** Default zoom */
-    defaultZoom: number;
-    /** Min/max zoom */
-    minZoom: number;
-    maxZoom: number;
-    /** Default mode */
-    defaultMode: MinimapMode;
-    /** Background color */
-    backgroundColor: string;
-    /** Border color */
-    borderColor: string;
-    /** Show compass */
-    showCompass: boolean;
-    /** Show scale */
-    showScale: boolean;
-    /** Enable fog of war */
-    fogOfWar: FogOfWarConfig;
-    /** Ping duration */
-    pingDuration: number;
-    /** Max pings */
-    maxPings: number;
-    /** Click to move */
-    enableClickToMove: boolean;
-    /** Enable panning */
-    enablePanning: boolean;
-    /** Enable zooming */
-    enableZooming: boolean;
-}
-export declare const DEFAULT_MINIMAP_CONFIG: MinimapConfig;
-export interface MinimapRenderData {
-    view: MinimapView;
-    size: {
-        width: number;
-        height: number;
-    };
-    markers: MinimapMarker[];
-    zones: MinimapZone[];
-    waypoints: MinimapWaypoint[];
-    pings: MinimapPing[];
-    overlays: MinimapOverlay[];
-    fogCells?: FogCell[];
-    worldToScreen: (worldPos: Vector2) => Vector2;
-    screenToWorld: (screenPos: Vector2) => Vector2;
-}
-export declare class NiceMinimap {
-    private config;
-    private markers;
-    private zones;
-    private waypoints;
-    private pings;
-    private overlays;
-    private fogGrid;
-    private revealedEntities;
-    private view;
-    private idCounter;
-    private eventListeners;
-    constructor(config?: Partial<MinimapConfig>);
-    private getWorldCenter;
-    private initializeFogGrid;
-    on(event: MinimapEventType, callback: MinimapEventCallback): () => void;
-    private emit;
-    addMarker(marker: Omit<MinimapMarker, 'id' | 'visible'> & {
-        id?: MarkerId;
-        visible?: boolean;
-    }): MarkerId;
-    updateMarker(id: MarkerId, updates: Partial<MinimapMarker>): void;
-    removeMarker(id: MarkerId): void;
-    getMarker(id: MarkerId): MinimapMarker | undefined;
-    getMarkersByType(type: MarkerType): MinimapMarker[];
-    getMarkerByEntityId(entityId: EntityId): MinimapMarker | undefined;
-    addZone(zone: Omit<MinimapZone, 'id' | 'visible'> & {
-        id?: ZoneId;
-        visible?: boolean;
-    }): ZoneId;
-    updateZone(id: ZoneId, updates: Partial<MinimapZone>): void;
-    removeZone(id: ZoneId): void;
-    addWaypoint(waypoint: Omit<MinimapWaypoint, 'id' | 'visible'> & {
-        id?: WaypointId;
-        visible?: boolean;
-    }): WaypointId;
-    updateWaypoint(id: WaypointId, updates: Partial<MinimapWaypoint>): void;
-    removeWaypoint(id: WaypointId): void;
-    clearWaypoints(): void;
-    createPing(ping: Omit<MinimapPing, 'id' | 'createdAt'>): PingId;
-    removePing(id: PingId): void;
-    addOverlay(overlay: Omit<MinimapOverlay, 'id' | 'visible'> & {
-        id?: OverlayId;
-        visible?: boolean;
-    }): OverlayId;
-    updateOverlay(id: OverlayId, updates: Partial<MinimapOverlay>): void;
-    removeOverlay(id: OverlayId): void;
-    revealFog(position: Vector2, radius: number): void;
-    updateFogVisibility(visiblePositions: Array<{
-        position: Vector2;
-        radius: number;
-    }>): void;
-    isFogRevealed(position: Vector2): boolean;
-    isFogVisible(position: Vector2): boolean;
-    setView(view: Partial<MinimapView>): void;
-    setCenter(center: Vector2): void;
-    setZoom(zoom: number): void;
-    setRotation(rotation: number): void;
-    setMode(mode: MinimapMode): void;
-    followEntity(entityId: EntityId): void;
-    stopFollowing(): void;
-    getView(): MinimapView;
-    worldToScreen(worldPos: Vector2): Vector2;
-    screenToWorld(screenPos: Vector2): Vector2;
-    handleClick(screenPos: Vector2): Vector2;
-    handleHover(screenPos: Vector2): {
-        marker?: MinimapMarker;
-        zone?: MinimapZone;
-        worldPos: Vector2;
-    };
-    private isPointInZone;
-    private isPointInPolygon;
-    update(_deltaTime: number): void;
-    getRenderData(): MinimapRenderData;
-    getDistance(from: Vector2, to: Vector2): number;
-    getDirection(from: Vector2, to: Vector2): number;
-    isInBounds(position: Vector2): boolean;
-    clampToBounds(position: Vector2): Vector2;
-    setConfig(config: Partial<MinimapConfig>): void;
-    getConfig(): MinimapConfig;
-    clear(): void;
-    destroy(): void;
-}
-export declare function createMinimapSystem(config?: Partial<MinimapConfig>): NiceMinimap;

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

@@ -1,175 +0,0 @@
-import { EventEmitter } from 'events';
-export type EntityId = string;
-export type NodeId = string;
-export type ResourceId = string;
-export type ToolId = string;
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export type ResourceRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-export interface ResourceType {
-    id: ResourceId;
-    name: string;
-    rarity: ResourceRarity;
-    baseValue: number;
-    weight: number;
-    stackSize: number;
-    minSkillLevel: number;
-    toolTypes: ToolType[];
-    processingTime?: number;
-    processedOutput?: ResourceId;
-    processedRatio?: number;
-}
-export type NodeState = 'available' | 'being-mined' | 'depleted' | 'respawning';
-export interface MiningNode {
-    id: NodeId;
-    position: Vector3;
-    resourceType: ResourceId;
-    state: NodeState;
-    hardness: number;
-    totalResources: number;
-    remainingResources: number;
-    currentProgress: number;
-    quality: number;
-    respawnTime: number;
-    respawnTimer: number;
-    bonusLootTable?: LootEntry[];
-    requiredToolLevel: number;
-    minerId?: EntityId;
-    lastMineTime?: number;
-}
-export interface LootEntry {
-    resourceId: ResourceId;
-    chance: number;
-    minAmount: number;
-    maxAmount: number;
-    requiredSkill?: number;
-}
-export type ToolType = 'pickaxe' | 'drill' | 'explosive' | 'laser' | 'hammer';
-export interface MiningTool {
-    id: ToolId;
-    name: string;
-    type: ToolType;
-    level: number;
-    efficiency: number;
-    power: number;
-    durabilityMax: number;
-    durabilityCurrent: number;
-    durabilityLossPerUse: number;
-    bonusYield: number;
-    bonusQuality: number;
-    aoeRadius?: number;
-}
-export interface MinerProfile {
-    entityId: EntityId;
-    skillLevel: number;
-    experience: number;
-    experienceToNextLevel: number;
-    equippedTool?: MiningTool;
-    bonuses: {
-        speed: number;
-        yield: number;
-        quality: number;
-        rareFind: number;
-    };
-    stats: {
-        totalMined: number;
-        nodesCleared: number;
-        rareFinds: number;
-        highestQuality: number;
-    };
-    knownDeposits: Set<NodeId>;
-    activeOperation?: MiningOperation;
-}
-export interface MiningOperation {
-    id: string;
-    type: 'single' | 'continuous' | 'blast';
-    nodeId: NodeId;
-    minerId: EntityId;
-    startTime: number;
-    progress: number;
-    targetProgress: number;
-    yieldAccumulated: ResourceYield[];
-}
-export interface ResourceYield {
-    resourceId: ResourceId;
-    amount: number;
-    quality: number;
-}
-export type MiningEventType = 'mining-started' | 'mining-progress' | 'mining-completed' | 'mining-cancelled' | 'resource-extracted' | 'rare-find' | 'node-depleted' | 'node-respawned' | 'tool-damaged' | 'tool-broken' | 'skill-increased' | 'deposit-discovered';
-export interface MiningEvent {
-    type: MiningEventType;
-    entityId?: EntityId;
-    nodeId?: NodeId;
-    data?: Record<string, unknown>;
-}
-export interface MiningSystemConfig {
-    baseExtractionTime?: number;
-    baseMiningSpeed?: number;
-    skillLevelCap?: number;
-    experiencePerResource?: number;
-    qualityLevels?: {
-        name: string;
-        minQuality: number;
-    }[];
-    rareFindBaseChance?: number;
-    discoveryRadius?: number;
-}
-export declare const DEFAULT_MINING_CONFIG: MiningSystemConfig;
-export declare class NiceMining extends EventEmitter {
-    private resourceTypes;
-    private nodes;
-    private miners;
-    private tools;
-    private nextNodeId;
-    private nextOpId;
-    private config;
-    constructor(config?: Partial<MiningSystemConfig>);
-    defineResourceType(resource: ResourceType): void;
-    getResourceType(id: ResourceId): ResourceType | undefined;
-    createNode(position: Vector3, resourceId: ResourceId, options?: {
-        totalResources?: number;
-        hardness?: number;
-        quality?: number;
-        respawnTime?: number;
-        bonusLoot?: LootEntry[];
-    }): NodeId;
-    getNode(id: NodeId): MiningNode | undefined;
-    removeNode(id: NodeId): void;
-    findNodesInRadius(position: Vector3, radius: number): MiningNode[];
-    discoverNearbyNodes(entityId: EntityId, position: Vector3): MiningNode[];
-    registerMiner(entityId: EntityId): void;
-    getMiner(entityId: EntityId): MinerProfile | undefined;
-    equipTool(entityId: EntityId, tool: MiningTool): void;
-    startMining(entityId: EntityId, nodeId: NodeId): boolean;
-    cancelMining(entityId: EntityId): void;
-    update(deltaTime: number): void;
-    private updateMiningOperation;
-    private completeMiningCycle;
-    private checkRareFind;
-    private awardExperience;
-    private damageTool;
-    private depleteNode;
-    private respawnNode;
-    createTool(options: Partial<MiningTool> & {
-        id: ToolId;
-        name: string;
-    }): MiningTool;
-    repairTool(toolId: ToolId, amount: number): void;
-    getAvailableNodes(): MiningNode[];
-    getNodesByResource(resourceId: ResourceId): MiningNode[];
-    canMine(entityId: EntityId, nodeId: NodeId): {
-        canMine: boolean;
-        reason?: string;
-    };
-    getQualityName(quality: number): string;
-}
-export declare function createMiningSystem(config?: Partial<MiningSystemConfig>): NiceMining;
-export declare function defineResourceType(options: ResourceType): ResourceType;
-export declare function createMiningTool(options: Partial<MiningTool> & {
-    id: ToolId;
-    name: string;
-}): MiningTool;
-export default NiceMining;