@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,176 +0,0 @@
-export type LootTableId = string;
-export type LootItemId = string;
-export type RarityTier = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic';
-export interface LootItemDefinition {
-    id: LootItemId;
-    name: string;
-    rarity: RarityTier;
-    baseValue: number;
-    stackable: boolean;
-    maxStack: number;
-    icon?: string;
-    tags?: string[];
-    customData?: Record<string, unknown>;
-}
-export interface LootEntry {
-    /** Item ID or nested table ID */
-    id: string;
-    /** Is this a reference to another loot table? */
-    isTable?: boolean;
-    /** Base weight (higher = more common) */
-    weight: number;
-    /** Minimum quantity */
-    minQuantity: number;
-    /** Maximum quantity */
-    maxQuantity: number;
-    /** Required level to drop */
-    minLevel?: number;
-    /** Max level to drop */
-    maxLevel?: number;
-    /** Conditions that must be met */
-    conditions?: LootCondition[];
-    /** Modify weight based on luck */
-    luckModifier?: number;
-    /** Tags for filtering */
-    tags?: string[];
-}
-export interface LootCondition {
-    type: 'tag' | 'flag' | 'level' | 'luck' | 'time' | 'custom';
-    /** Condition check */
-    check: string;
-    /** Expected value */
-    value: unknown;
-    /** Comparison operator */
-    operator?: '==' | '!=' | '>' | '<' | '>=' | '<=';
-}
-export interface GuaranteedDrop {
-    itemId: LootItemId;
-    quantity: number;
-    chance?: number;
-}
-export interface LootTableDefinition {
-    id: LootTableId;
-    name: string;
-    description?: string;
-    /** Number of rolls on this table */
-    rolls: number;
-    /** Can same item drop multiple times per roll session */
-    allowDuplicates: boolean;
-    /** Bonus rolls based on luck */
-    bonusRollChance?: number;
-    /** Loot entries */
-    entries: LootEntry[];
-    /** Guaranteed drops (always included) */
-    guaranteed?: GuaranteedDrop[];
-    /** Tags for categorization */
-    tags?: string[];
-}
-export interface LootDrop {
-    itemId: LootItemId;
-    quantity: number;
-    rarity: RarityTier;
-    fromTable: LootTableId;
-    wasGuaranteed: boolean;
-    rollIndex: number;
-}
-export interface LootResult {
-    tableId: LootTableId;
-    drops: LootDrop[];
-    totalRolls: number;
-    bonusRolls: number;
-    luck: number;
-    timestamp: number;
-}
-export interface LootContext {
-    /** Player/character level */
-    level: number;
-    /** Luck/magic find value */
-    luck: number;
-    /** Active tags */
-    tags: string[];
-    /** Active flags */
-    flags: Record<string, boolean>;
-    /** Custom context data */
-    custom?: Record<string, unknown>;
-}
-export declare const DEFAULT_LOOT_CONTEXT: LootContext;
-export interface RarityConfig {
-    tier: RarityTier;
-    name: string;
-    color: string;
-    baseWeight: number;
-    luckBonus: number;
-    valueMultiplier: number;
-}
-export declare const DEFAULT_RARITY_CONFIG: RarityConfig[];
-export type LootEventType = 'drop' | 'rare-drop' | 'legendary-drop' | 'nothing';
-export interface LootEvent {
-    type: LootEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type LootEventCallback = (event: LootEvent) => void;
-export interface LootSystemConfig {
-    rarityConfig: RarityConfig[];
-    /** Max luck value */
-    maxLuck: number;
-    /** Track roll history */
-    trackHistory: boolean;
-    /** Max history entries */
-    maxHistorySize: number;
-    /** Pity system - increase rare drop chance after X rolls without one */
-    enablePity: boolean;
-    pityThreshold: number;
-    pityBonus: number;
-}
-export declare const DEFAULT_LOOT_CONFIG: LootSystemConfig;
-export declare class NiceLoot {
-    private config;
-    private items;
-    private tables;
-    private history;
-    private rollsSinceRare;
-    private eventListeners;
-    constructor(config?: Partial<LootSystemConfig>);
-    on(event: LootEventType, callback: LootEventCallback): () => void;
-    private emit;
-    registerItem(item: LootItemDefinition): void;
-    registerItems(items: LootItemDefinition[]): void;
-    getItem(id: LootItemId): LootItemDefinition | undefined;
-    getAllItems(): LootItemDefinition[];
-    getItemsByRarity(rarity: RarityTier): LootItemDefinition[];
-    registerTable(table: LootTableDefinition): void;
-    registerTables(tables: LootTableDefinition[]): void;
-    getTable(id: LootTableId): LootTableDefinition | undefined;
-    getAllTables(): LootTableDefinition[];
-    roll(tableId: LootTableId, context?: Partial<LootContext>): LootResult;
-    private checkEntryConditions;
-    private evaluateCondition;
-    private compareValues;
-    private calculateWeight;
-    private randomInt;
-    rollMultiple(tableId: LootTableId, count: number, context?: Partial<LootContext>): LootResult[];
-    simulate(tableId: LootTableId, iterations: number, context?: Partial<LootContext>): Map<LootItemId, {
-        count: number;
-        avgQuantity: number;
-        dropRate: number;
-    }>;
-    getHistory(): LootResult[];
-    clearHistory(): void;
-    getDropStatistics(): {
-        totalRolls: number;
-        totalDrops: number;
-        byRarity: Record<RarityTier, number>;
-    };
-    getRarityColor(rarity: RarityTier): string;
-    getRarityName(rarity: RarityTier): string;
-    getItemValue(itemId: LootItemId, quantity?: number): number;
-    createSimpleTable(id: LootTableId, name: string, items: {
-        itemId: LootItemId;
-        weight: number;
-        quantity?: number;
-    }[]): LootTableDefinition;
-    createTieredTable(id: LootTableId, name: string, itemsByRarity: Partial<Record<RarityTier, LootItemId[]>>): LootTableDefinition;
-    destroy(): void;
-}
-export declare function createLootSystem(config?: Partial<LootSystemConfig>): NiceLoot;

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

@@ -1,164 +0,0 @@
-export type MailId = string;
-export type FolderId = string;
-export type MailType = 'player' | 'system' | 'guild' | 'reward' | 'newsletter' | 'support';
-export type MailStatus = 'unread' | 'read' | 'archived' | 'deleted';
-export type MailPriority = 'low' | 'normal' | 'high' | 'urgent';
-export interface MailAttachment {
-    id: string;
-    type: 'item' | 'currency' | 'ticket' | 'custom';
-    itemId?: string;
-    currency?: string;
-    amount: number;
-    claimed: boolean;
-    claimedAt?: number;
-}
-export interface Mail {
-    id: MailId;
-    type: MailType;
-    senderId: string;
-    senderName: string;
-    recipientId: string;
-    recipientName?: string;
-    subject: string;
-    body: string;
-    templateId?: string;
-    templateData?: Record<string, unknown>;
-    status: MailStatus;
-    priority: MailPriority;
-    folderId?: FolderId;
-    attachments: MailAttachment[];
-    hasUnclaimedAttachments: boolean;
-    sentAt: number;
-    readAt?: number;
-    expiresAt?: number;
-    isStarred: boolean;
-    isLocked: boolean;
-    readReceipt?: boolean;
-    readReceiptSentAt?: number;
-    replyToId?: MailId;
-    threadId?: string;
-}
-export interface MailFolder {
-    id: FolderId;
-    name: string;
-    icon?: string;
-    isSystem: boolean;
-    sortOrder: number;
-    filters?: MailFilter[];
-}
-export interface MailFilter {
-    field: 'type' | 'senderId' | 'subject' | 'priority' | 'hasAttachments' | 'isStarred';
-    operator: 'equals' | 'contains' | 'startsWith' | 'exists' | 'notExists';
-    value: unknown;
-}
-export interface MailTemplate {
-    id: string;
-    name: string;
-    type: MailType;
-    subject: string;
-    body: string;
-    variables: string[];
-    attachmentTemplate?: Partial<MailAttachment>[];
-}
-export interface Mailbox {
-    playerId: string;
-    folders: Map<FolderId, MailFolder>;
-    mails: Map<MailId, Mail>;
-    totalUnread: number;
-    totalUnclaimedAttachments: number;
-    autoDeleteRead: boolean;
-    autoDeleteDays: number;
-    notifyOnReceive: boolean;
-    blockList: string[];
-    capacity: number;
-    usedCapacity: number;
-}
-export type MailEventType = 'mail-sent' | 'mail-received' | 'mail-read' | 'mail-deleted' | 'mail-archived' | 'mail-starred' | 'attachment-claimed' | 'all-attachments-claimed' | 'read-receipt' | 'folder-created' | 'folder-deleted' | 'mailbox-full' | 'mail-expired';
-export interface MailEvent {
-    type: MailEventType;
-    timestamp: number;
-    playerId: string;
-    mailId?: MailId;
-    data?: unknown;
-}
-export type MailEventCallback = (event: MailEvent) => void;
-export interface MailConfig {
-    defaultMailCapacity: number;
-    maxSubjectLength: number;
-    maxBodyLength: number;
-    maxAttachments: number;
-    defaultExpirationDays: number;
-    systemExpirationDays: number;
-    rewardExpirationDays: number;
-    allowPlayerMail: boolean;
-    storageKey: string;
-}
-export declare const DEFAULT_MAIL_CONFIG: MailConfig;
-export declare class NiceMail {
-    private config;
-    private mailboxes;
-    private templates;
-    private globalMails;
-    private eventListeners;
-    private idCounter;
-    constructor(config?: Partial<MailConfig>);
-    on(event: MailEventType, callback: MailEventCallback): () => void;
-    private emit;
-    registerTemplate(template: MailTemplate): void;
-    private getOrCreateMailbox;
-    createFolder(playerId: string, name: string, icon?: string): MailFolder | null;
-    deleteFolder(playerId: string, folderId: FolderId): boolean;
-    sendMail(senderId: string, recipientId: string, subject: string, body: string, options?: {
-        type?: MailType;
-        priority?: MailPriority;
-        attachments?: Omit<MailAttachment, 'id' | 'claimed'>[];
-        expiresIn?: number;
-        requestReadReceipt?: boolean;
-        replyToId?: MailId;
-    }): Mail | null;
-    sendSystemMail(recipientId: string, subject: string, body: string, attachments?: Omit<MailAttachment, 'id' | 'claimed'>[], expirationDays?: number): Mail | null;
-    sendRewardMail(recipientId: string, subject: string, body: string, rewards: Omit<MailAttachment, 'id' | 'claimed'>[]): Mail | null;
-    sendFromTemplate(recipientId: string, templateId: string, variables: Record<string, unknown>, attachments?: Omit<MailAttachment, 'id' | 'claimed'>[]): Mail | null;
-    broadcastMail(recipientIds: string[], subject: string, body: string, attachments?: Omit<MailAttachment, 'id' | 'claimed'>[]): number;
-    private getThreadId;
-    readMail(playerId: string, mailId: MailId): Mail | null;
-    claimAttachment(playerId: string, mailId: MailId, attachmentId: string): MailAttachment | null;
-    claimAllAttachments(playerId: string, mailId: MailId): MailAttachment[];
-    claimAllMailAttachments(playerId: string): MailAttachment[];
-    starMail(playerId: string, mailId: MailId, starred?: boolean): boolean;
-    moveMail(playerId: string, mailId: MailId, folderId: FolderId): boolean;
-    deleteMail(playerId: string, mailId: MailId, permanent?: boolean): boolean;
-    deleteAllRead(playerId: string): number;
-    emptyTrash(playerId: string): number;
-    processExpiredMails(): number;
-    getMail(playerId: string, mailId: MailId): Mail | undefined;
-    getMailbox(playerId: string): Mailbox | undefined;
-    getInbox(playerId: string, options?: {
-        folderId?: FolderId;
-        type?: MailType;
-        status?: MailStatus;
-        hasAttachments?: boolean;
-        isStarred?: boolean;
-        search?: string;
-        limit?: number;
-        offset?: number;
-        sortBy?: 'date' | 'priority' | 'sender';
-        sortOrder?: 'asc' | 'desc';
-    }): Mail[];
-    getUnreadCount(playerId: string): number;
-    getUnclaimedAttachmentCount(playerId: string): number;
-    getMailThread(playerId: string, threadId: string): Mail[];
-    updateSettings(playerId: string, settings: {
-        autoDeleteRead?: boolean;
-        autoDeleteDays?: number;
-        notifyOnReceive?: boolean;
-    }): void;
-    blockSender(playerId: string, senderId: string): boolean;
-    unblockSender(playerId: string, senderId: string): boolean;
-    private save;
-    private load;
-    reset(): void;
-    resetPlayer(playerId: string): void;
-    destroy(): void;
-}
-export declare function createMailSystem(config?: Partial<MailConfig>): NiceMail;

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

@@ -1,234 +0,0 @@
-export type ZoneId = string;
-export type MarkerId = string;
-export type LayerId = string;
-export type ZoneType = 'wilderness' | 'city' | 'dungeon' | 'raid' | 'pvp' | 'safe' | 'instance' | 'custom';
-export type MarkerType = 'quest' | 'vendor' | 'trainer' | 'waypoint' | 'npc' | 'poi' | 'player' | 'enemy' | 'resource' | 'custom';
-export interface MapPoint {
-    x: number;
-    y: number;
-    z?: number;
-}
-export interface MapBounds {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-export interface ZoneDefinition {
-    id: ZoneId;
-    name: string;
-    description?: string;
-    type: ZoneType;
-    level: {
-        min: number;
-        max: number;
-    };
-    bounds: MapBounds;
-    worldPosition: MapPoint;
-    parentZone?: ZoneId;
-    subZones?: ZoneId[];
-    connections: ZoneConnection[];
-    mapImage: string;
-    mapScale: number;
-    color?: string;
-    icon?: string;
-    pvpEnabled: boolean;
-    fastTravelEnabled: boolean;
-    respawnPoint?: MapPoint;
-    discoverable: boolean;
-    explorationXP?: number;
-    tags?: string[];
-}
-export interface ZoneConnection {
-    targetZone: ZoneId;
-    position: MapPoint;
-    type: 'portal' | 'path' | 'flight' | 'ship' | 'teleport';
-    bidirectional: boolean;
-    requirements?: string[];
-}
-export interface MarkerDefinition {
-    id: MarkerId;
-    name: string;
-    description?: string;
-    zone: ZoneId;
-    position: MapPoint;
-    type: MarkerType;
-    customType?: string;
-    icon: string;
-    color?: string;
-    size?: number;
-    visible: boolean;
-    clickable: boolean;
-    trackable: boolean;
-    visibleWhen?: string[];
-    tooltip?: string;
-    tooltipData?: Record<string, unknown>;
-}
-export interface MapLayer {
-    id: LayerId;
-    name: string;
-    visible: boolean;
-    opacity: number;
-    zIndex: number;
-    image?: string;
-    markers: MarkerId[];
-    toggleable: boolean;
-    defaultVisible: boolean;
-}
-export interface PlayerMapState {
-    playerId: string;
-    currentZone: ZoneId;
-    currentPosition: MapPoint;
-    discoveredZones: Set<ZoneId>;
-    exploredArea: Map<ZoneId, number>;
-    fogRevealed: Map<ZoneId, RevealedArea[]>;
-    customMarkers: CustomMarker[];
-    maxCustomMarkers: number;
-    trackedMarker?: MarkerId;
-    waypoints: WaypointMarker[];
-    maxWaypoints: number;
-    favoriteLocations: FavoriteLocation[];
-    settings: MapSettings;
-}
-export interface RevealedArea {
-    center: MapPoint;
-    radius: number;
-    revealedAt: number;
-}
-export interface CustomMarker {
-    id: string;
-    name: string;
-    zone: ZoneId;
-    position: MapPoint;
-    icon: string;
-    color: string;
-    createdAt: number;
-    notes?: string;
-}
-export interface WaypointMarker {
-    id: string;
-    zone: ZoneId;
-    position: MapPoint;
-    createdAt: number;
-}
-export interface FavoriteLocation {
-    name: string;
-    zone: ZoneId;
-    position: MapPoint;
-    icon?: string;
-    savedAt: number;
-}
-export interface MapSettings {
-    showQuestMarkers: boolean;
-    showPOIs: boolean;
-    showPlayers: boolean;
-    showEnemies: boolean;
-    showResources: boolean;
-    showCustomMarkers: boolean;
-    fogOfWar: boolean;
-    miniMapRotation: boolean;
-    miniMapZoom: number;
-    worldMapZoom: number;
-}
-export interface Route {
-    id: string;
-    start: {
-        zone: ZoneId;
-        position: MapPoint;
-    };
-    end: {
-        zone: ZoneId;
-        position: MapPoint;
-    };
-    waypoints: RouteWaypoint[];
-    totalDistance: number;
-    estimatedTime: number;
-    travelMethods: string[];
-}
-export interface RouteWaypoint {
-    zone: ZoneId;
-    position: MapPoint;
-    action?: 'walk' | 'fly' | 'teleport' | 'use_portal';
-    note?: string;
-}
-export type MapEventType = 'zone-discovered' | 'zone-entered' | 'zone-exited' | 'area-explored' | 'marker-clicked' | 'marker-tracked' | 'custom-marker-added' | 'custom-marker-removed' | 'waypoint-set' | 'route-calculated' | 'fog-revealed' | 'position-updated';
-export interface MapEvent {
-    type: MapEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type MapEventCallback = (event: MapEvent) => void;
-export interface MapConfig {
-    revealRadius: number;
-    maxCustomMarkers: number;
-    maxWaypoints: number;
-    fogEnabled: boolean;
-    autoReveal: boolean;
-    storageKey: string;
-}
-export declare const DEFAULT_MAP_CONFIG: MapConfig;
-export declare class NiceMap {
-    private config;
-    private zones;
-    private markers;
-    private layers;
-    private players;
-    private eventListeners;
-    constructor(config?: Partial<MapConfig>);
-    on(event: MapEventType, callback: MapEventCallback): () => void;
-    private emit;
-    registerZone(zone: ZoneDefinition): void;
-    registerZones(zones: ZoneDefinition[]): void;
-    registerMarker(marker: MarkerDefinition): void;
-    removeMarker(id: MarkerId): void;
-    private shouldMarkerBeInLayer;
-    registerLayer(layer: MapLayer): void;
-    toggleLayer(layerId: LayerId, visible?: boolean): void;
-    setLayerOpacity(layerId: LayerId, opacity: number): void;
-    getPlayer(playerId: string): PlayerMapState;
-    private createPlayerState;
-    updatePosition(playerId: string, zone: ZoneId, position: MapPoint): void;
-    discoverZone(playerId: string, zoneId: ZoneId): boolean;
-    isZoneDiscovered(playerId: string, zoneId: ZoneId): boolean;
-    private updateExploration;
-    revealFog(playerId: string, zoneId: ZoneId, center: MapPoint, radius: number): void;
-    revealFullZone(playerId: string, zoneId: ZoneId): void;
-    isFogRevealed(playerId: string, zoneId: ZoneId, point: MapPoint): boolean;
-    addCustomMarker(playerId: string, zone: ZoneId, position: MapPoint, name: string, icon?: string, color?: string, notes?: string): CustomMarker | null;
-    removeCustomMarker(playerId: string, markerId: string): boolean;
-    getCustomMarkers(playerId: string, zone?: ZoneId): CustomMarker[];
-    setWaypoint(playerId: string, zone: ZoneId, position: MapPoint): WaypointMarker | null;
-    clearWaypoints(playerId: string): void;
-    trackMarker(playerId: string, markerId: MarkerId): void;
-    stopTracking(playerId: string): void;
-    getTrackedMarker(playerId: string): MarkerDefinition | undefined;
-    addFavorite(playerId: string, name: string, zone: ZoneId, position: MapPoint, icon?: string): FavoriteLocation;
-    removeFavorite(playerId: string, name: string): boolean;
-    getFavorites(playerId: string): FavoriteLocation[];
-    calculateRoute(startZone: ZoneId, startPos: MapPoint, endZone: ZoneId, endPos: MapPoint): Route | null;
-    private findPath;
-    private connectionTypeToAction;
-    getZone(id: ZoneId): ZoneDefinition | undefined;
-    getAllZones(): ZoneDefinition[];
-    getZonesByType(type: ZoneType): ZoneDefinition[];
-    getMarker(id: MarkerId): MarkerDefinition | undefined;
-    getAllMarkers(): MarkerDefinition[];
-    getMarkersInZone(zoneId: ZoneId, type?: MarkerType): MarkerDefinition[];
-    getMarkersNearPoint(zoneId: ZoneId, point: MapPoint, radius: number): MarkerDefinition[];
-    getLayer(id: LayerId): MapLayer | undefined;
-    getAllLayers(): MapLayer[];
-    getVisibleLayers(): MapLayer[];
-    getExplorationProgress(playerId: string, zoneId?: ZoneId): number;
-    getDiscoveredZoneCount(playerId: string): number;
-    getTotalZoneCount(): number;
-    updateSettings(playerId: string, settings: Partial<MapSettings>): void;
-    getSettings(playerId: string): MapSettings;
-    distance(a: MapPoint, b: MapPoint): number;
-    isPointInZone(point: MapPoint, zoneId: ZoneId): boolean;
-    getZoneAtPoint(point: MapPoint): ZoneDefinition | undefined;
-    save(): void;
-    load(): void;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createMapSystem(config?: Partial<MapConfig>): NiceMap;