@nice2dev/game-engine 1.1.5 → 1.1.6

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

@@ -0,0 +1,115 @@
+/** 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

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

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