@nice2dev/game-engine 1.1.5 → 1.1.7

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

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

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

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