@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,238 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type ItemId = string;
+export type MerchantId = string;
+export type ShopId = string;
+export type AuctionId = string;
+export type CurrencyId = string;
+export type TradeRouteId = string;
+export interface Currency {
+    id: CurrencyId;
+    name: string;
+    symbol: string;
+    exchangeRate: number;
+    divisor?: number;
+    maxStack?: number;
+}
+export interface Wallet {
+    entityId: EntityId;
+    balances: Map<CurrencyId, number>;
+}
+export interface TradeItem {
+    id: ItemId;
+    name: string;
+    baseValue: number;
+    weight: number;
+    stackable: boolean;
+    maxStack: number;
+    categories: string[];
+    quality?: number;
+    rarity?: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+}
+export interface ItemListing {
+    itemId: ItemId;
+    quantity: number;
+    quality?: number;
+    price: number;
+    currencyId: CurrencyId;
+    stock: number;
+    maxStock: number;
+    restockRate: number;
+    lastRestock: number;
+}
+export type MerchantDisposition = 'friendly' | 'neutral' | 'hostile' | 'blackmarket';
+export interface Merchant {
+    id: MerchantId;
+    name: string;
+    shopId: ShopId;
+    disposition: MerchantDisposition;
+    buyModifier: number;
+    sellModifier: number;
+    haggleThreshold: number;
+    wealth: number;
+    specialties: string[];
+    factionId?: string;
+}
+export interface Shop {
+    id: ShopId;
+    name: string;
+    merchantId: MerchantId;
+    inventory: Map<ItemId, ItemListing>;
+    baseCurrency: CurrencyId;
+    acceptedCurrencies: Set<CurrencyId>;
+    reputation: Map<EntityId, number>;
+    isOpen: boolean;
+    openHours?: {
+        start: number;
+        end: number;
+    };
+    restockInterval: number;
+    lastRestock: number;
+}
+export type TradeStatus = 'pending' | 'accepted' | 'rejected' | 'cancelled' | 'completed';
+export interface TradeOffer {
+    id: string;
+    initiatorId: EntityId;
+    targetId: EntityId;
+    initiatorItems: {
+        itemId: ItemId;
+        quantity: number;
+        quality?: number;
+    }[];
+    targetItems: {
+        itemId: ItemId;
+        quantity: number;
+        quality?: number;
+    }[];
+    initiatorMoney: Map<CurrencyId, number>;
+    targetMoney: Map<CurrencyId, number>;
+    status: TradeStatus;
+    initiatorConfirmed: boolean;
+    targetConfirmed: boolean;
+    createdAt: number;
+    expiresAt?: number;
+}
+export type AuctionStatus = 'pending' | 'active' | 'ended' | 'cancelled';
+export interface AuctionBid {
+    bidderId: EntityId;
+    amount: number;
+    timestamp: number;
+}
+export interface Auction {
+    id: AuctionId;
+    sellerId: EntityId;
+    itemId: ItemId;
+    quantity: number;
+    quality?: number;
+    startingPrice: number;
+    buyoutPrice?: number;
+    currencyId: CurrencyId;
+    currentBid?: AuctionBid;
+    bidHistory: AuctionBid[];
+    status: AuctionStatus;
+    startTime: number;
+    endTime: number;
+    minBidIncrement: number;
+}
+export interface MarketData {
+    itemId: ItemId;
+    avgPrice: number;
+    minPrice: number;
+    maxPrice: number;
+    supply: number;
+    demand: number;
+    priceHistory: {
+        timestamp: number;
+        price: number;
+    }[];
+    volumeHistory: {
+        timestamp: number;
+        volume: number;
+    }[];
+}
+export interface TradeRoute {
+    id: TradeRouteId;
+    name: string;
+    startLocation: string;
+    endLocation: string;
+    distance: number;
+    risk: number;
+    profitMargin: number;
+    exportItems: ItemId[];
+    importItems: ItemId[];
+    travelTime: number;
+    isActive: boolean;
+}
+export type TradingEventType = 'item-purchased' | 'item-sold' | 'trade-initiated' | 'trade-completed' | 'trade-cancelled' | 'auction-created' | 'auction-bid' | 'auction-ended' | 'price-changed' | 'shop-restocked' | 'route-completed' | 'reputation-changed';
+export interface TradingEvent {
+    type: TradingEventType;
+    entityId?: EntityId;
+    shopId?: ShopId;
+    auctionId?: AuctionId;
+    data?: Record<string, unknown>;
+}
+export interface TradingSystemConfig {
+    baseCurrencyId?: CurrencyId;
+    maxTradeOfferAge?: number;
+    auctionMinDuration?: number;
+    auctionMaxDuration?: number;
+    priceFluctuation?: number;
+    demandImpact?: number;
+    supplyImpact?: number;
+    haggleSuccessBase?: number;
+    reputationDecayRate?: number;
+}
+export declare const DEFAULT_TRADING_CONFIG: TradingSystemConfig;
+export declare class NiceTrading extends EventEmitter {
+    private currencies;
+    private items;
+    private merchants;
+    private shops;
+    private wallets;
+    private tradeOffers;
+    private auctions;
+    private marketData;
+    private tradeRoutes;
+    private nextTradeId;
+    private nextAuctionId;
+    private config;
+    constructor(config?: Partial<TradingSystemConfig>);
+    defineCurrency(currency: Currency): void;
+    getCurrency(id: CurrencyId): Currency | undefined;
+    createWallet(entityId: EntityId): void;
+    getBalance(entityId: EntityId, currencyId?: CurrencyId): number;
+    addMoney(entityId: EntityId, amount: number, currencyId?: CurrencyId): void;
+    removeMoney(entityId: EntityId, amount: number, currencyId?: CurrencyId): boolean;
+    exchangeCurrency(entityId: EntityId, fromCurrency: CurrencyId, toCurrency: CurrencyId, amount: number): boolean;
+    defineItem(item: TradeItem): void;
+    getItem(id: ItemId): TradeItem | undefined;
+    registerMerchant(merchant: Merchant): void;
+    createShop(shop: Shop): void;
+    getShop(id: ShopId): Shop | undefined;
+    addListing(shopId: ShopId, listing: ItemListing): void;
+    buyFromShop(buyerId: EntityId, shopId: ShopId, itemId: ItemId, quantity: number): {
+        success: boolean;
+        totalCost?: number;
+        reason?: string;
+    };
+    sellToShop(sellerId: EntityId, shopId: ShopId, itemId: ItemId, quantity: number): {
+        success: boolean;
+        totalValue?: number;
+        reason?: string;
+    };
+    calculateBuyPrice(listing: ItemListing, merchant: Merchant, shop: Shop, buyerId: EntityId): number;
+    calculateSellPrice(item: TradeItem, merchant: Merchant, shop: Shop, sellerId: EntityId): number;
+    private modifyReputation;
+    createTradeOffer(initiatorId: EntityId, targetId: EntityId): string;
+    addItemToTrade(tradeId: string, entityId: EntityId, itemId: ItemId, quantity: number): boolean;
+    addMoneyToTrade(tradeId: string, entityId: EntityId, amount: number, currencyId?: CurrencyId): boolean;
+    confirmTrade(tradeId: string, entityId: EntityId): boolean;
+    private executeTrade;
+    cancelTrade(tradeId: string, entityId: EntityId): boolean;
+    createAuction(sellerId: EntityId, itemId: ItemId, quantity: number, options: {
+        startingPrice: number;
+        buyoutPrice?: number;
+        duration: number;
+        quality?: number;
+        currencyId?: CurrencyId;
+    }): AuctionId;
+    placeBid(auctionId: AuctionId, bidderId: EntityId, amount: number): boolean;
+    private concludeAuction;
+    private recordTransaction;
+    getMarketData(itemId: ItemId): MarketData | undefined;
+    registerTradeRoute(route: TradeRoute): void;
+    getTradeRoute(id: TradeRouteId): TradeRoute | undefined;
+    getProfitableRoutes(): TradeRoute[];
+    update(_deltaTime: number): void;
+    private restockShop;
+    getActiveAuctions(itemId?: ItemId): Auction[];
+    searchShops(itemId: ItemId): {
+        shop: Shop;
+        listing: ItemListing;
+    }[];
+}
+export declare function createTradingSystem(config?: Partial<TradingSystemConfig>): NiceTrading;
+export declare function defineCurrency(options: Currency): Currency;
+export declare function defineTradeItem(options: TradeItem): TradeItem;
+export declare function createMerchant(options: Merchant): Merchant;
+export default NiceTrading;

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

@@ -0,0 +1,142 @@
+export type AppearanceId = string;
+export type OutfitId = string;
+export type DyeId = string;
+export type SlotType = 'head' | 'shoulders' | 'chest' | 'back' | 'hands' | 'waist' | 'legs' | 'feet' | 'main_hand' | 'off_hand' | 'ranged' | 'tabard';
+export interface AppearanceDefinition {
+    id: AppearanceId;
+    name: string;
+    description?: string;
+    slot: SlotType;
+    sourceItemIds: string[];
+    modelId: string;
+    textures?: string[];
+    defaultDye?: DyeId;
+    supportsDye: boolean;
+    dyeChannels?: number;
+    classRestrictions?: string[];
+    raceRestrictions?: string[];
+    factionRequired?: string;
+    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+    tags?: string[];
+    setId?: string;
+    hidden?: boolean;
+}
+export interface DyeDefinition {
+    id: DyeId;
+    name: string;
+    primaryColor: string;
+    secondaryColor?: string;
+    metallic?: boolean;
+    unlockMethod: 'default' | 'item' | 'quest' | 'achievement' | 'vendor' | 'event';
+    sourceId?: string;
+    cost?: number;
+    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+}
+export interface AppliedTransmog {
+    slot: SlotType;
+    appearanceId: AppearanceId;
+    dyeId?: DyeId;
+    hidden: boolean;
+    appliedAt: number;
+}
+export interface OutfitPreset {
+    id: OutfitId;
+    name: string;
+    icon?: string;
+    slots: Map<SlotType, {
+        appearanceId: AppearanceId;
+        dyeId?: DyeId;
+        hidden: boolean;
+    }>;
+    createdAt: number;
+    lastUsed?: number;
+}
+export interface PlayerTransmogData {
+    playerId: string;
+    unlockedAppearances: Set<AppearanceId>;
+    unlockedDyes: Set<DyeId>;
+    currentTransmogs: Map<SlotType, AppliedTransmog>;
+    outfits: Map<OutfitId, OutfitPreset>;
+    activeOutfitId?: OutfitId;
+    totalCollected: number;
+    totalApplied: number;
+    unlockHistory: Array<{
+        type: 'appearance' | 'dye';
+        id: string;
+        timestamp: number;
+        source?: string;
+    }>;
+}
+export type TransmogEventType = 'appearance-unlocked' | 'dye-unlocked' | 'transmog-applied' | 'transmog-removed' | 'outfit-created' | 'outfit-applied' | 'outfit-deleted' | 'slot-hidden' | 'slot-shown';
+export interface TransmogEvent {
+    type: TransmogEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export type TransmogEventCallback = (event: TransmogEvent) => void;
+export interface TransmogConfig {
+    maxOutfits: number;
+    transmogCost: number;
+    dyeCost: number;
+    freeRemoval: boolean;
+    autoUnlockOnEquip: boolean;
+    storageKey: string;
+}
+export declare const DEFAULT_TRANSMOG_CONFIG: TransmogConfig;
+export declare class NiceTransmog {
+    private config;
+    private appearances;
+    private dyes;
+    private playerData;
+    private eventListeners;
+    private onDeductCost?;
+    constructor(config?: Partial<TransmogConfig>);
+    on(event: TransmogEventType, callback: TransmogEventCallback): () => void;
+    private emit;
+    setCostHandler(handler: typeof this.onDeductCost): void;
+    registerAppearance(appearance: AppearanceDefinition): void;
+    registerDye(dye: DyeDefinition): void;
+    unlockAppearance(playerId: string, appearanceId: AppearanceId, source?: string): boolean;
+    unlockAppearanceFromItem(playerId: string, itemId: string): AppearanceDefinition | null;
+    unlockDye(playerId: string, dyeId: DyeId, source?: string): boolean;
+    applyTransmog(playerId: string, slot: SlotType, appearanceId: AppearanceId, dyeId?: DyeId): boolean;
+    removeTransmog(playerId: string, slot: SlotType): boolean;
+    applyDye(playerId: string, slot: SlotType, dyeId: DyeId): boolean;
+    hideSlot(playerId: string, slot: SlotType): boolean;
+    showSlot(playerId: string, slot: SlotType): boolean;
+    createOutfit(playerId: string, name: string): OutfitPreset | null;
+    applyOutfit(playerId: string, outfitId: OutfitId): boolean;
+    updateOutfit(playerId: string, outfitId: OutfitId): boolean;
+    renameOutfit(playerId: string, outfitId: OutfitId, name: string): boolean;
+    deleteOutfit(playerId: string, outfitId: OutfitId): boolean;
+    getAppearance(id: AppearanceId): AppearanceDefinition | undefined;
+    getAllAppearances(): AppearanceDefinition[];
+    getAppearancesBySlot(slot: SlotType): AppearanceDefinition[];
+    getAppearancesBySet(setId: string): AppearanceDefinition[];
+    getDye(id: DyeId): DyeDefinition | undefined;
+    getAllDyes(): DyeDefinition[];
+    getPlayerData(playerId: string): PlayerTransmogData | undefined;
+    getUnlockedAppearances(playerId: string): AppearanceDefinition[];
+    getUnlockedAppearancesForSlot(playerId: string, slot: SlotType): AppearanceDefinition[];
+    getUnlockedDyes(playerId: string): DyeDefinition[];
+    getCurrentTransmog(playerId: string, slot: SlotType): AppliedTransmog | undefined;
+    getAllCurrentTransmogs(playerId: string): AppliedTransmog[];
+    getOutfits(playerId: string): OutfitPreset[];
+    getCollectionProgress(playerId: string): {
+        total: number;
+        unlocked: number;
+        percent: number;
+        bySlot: Record<SlotType, {
+            total: number;
+            unlocked: number;
+        }>;
+    };
+    isAppearanceUnlocked(playerId: string, appearanceId: AppearanceId): boolean;
+    isDyeUnlocked(playerId: string, dyeId: DyeId): boolean;
+    private getOrCreatePlayerData;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createTransmogSystem(config?: Partial<TransmogConfig>): NiceTransmog;

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

@@ -0,0 +1,248 @@
+export type TutorialId = string;
+export type StepId = string;
+export type HintId = string;
+export type TooltipId = string;
+export type StepType = 'message' | 'highlight' | 'action' | 'input' | 'choice' | 'wait' | 'checkpoint';
+export type HighlightShape = 'rectangle' | 'circle' | 'custom';
+export interface StepPosition {
+    x: number;
+    y: number;
+}
+export interface StepHighlight {
+    targetId?: string;
+    targetSelector?: string;
+    position?: StepPosition;
+    size?: {
+        width: number;
+        height: number;
+    };
+    shape: HighlightShape;
+    padding?: number;
+    pulseAnimation?: boolean;
+}
+export interface TutorialStep {
+    id: StepId;
+    type: StepType;
+    /** Title displayed */
+    title?: string;
+    /** Message content (supports markdown) */
+    message?: string;
+    /** Image URL */
+    image?: string;
+    /** Video URL */
+    video?: string;
+    /** Highlight configuration */
+    highlight?: StepHighlight;
+    /** Arrow pointing to target */
+    arrow?: boolean;
+    /** Position of the tutorial dialog */
+    dialogPosition?: 'top' | 'bottom' | 'left' | 'right' | 'center' | 'auto';
+    /** Required action to proceed */
+    requiredAction?: {
+        type: string;
+        target?: string;
+        value?: unknown;
+    };
+    /** Wait duration for 'wait' type (ms) */
+    waitDuration?: number;
+    /** Choices for 'choice' type */
+    choices?: Array<{
+        id: string;
+        label: string;
+        nextStepId?: StepId;
+    }>;
+    /** Allow skipping this step */
+    skippable: boolean;
+    /** Auto-proceed after delay */
+    autoProceed?: number;
+    /** On enter callback */
+    onEnter?: () => void | Promise<void>;
+    /** On exit callback */
+    onExit?: () => void | Promise<void>;
+    /** Condition to show step */
+    condition?: () => boolean;
+    /** Tags for filtering */
+    tags?: string[];
+}
+export interface TutorialDefinition {
+    id: TutorialId;
+    name: string;
+    description?: string;
+    /** Tutorial version (for migration) */
+    version: number;
+    /** Steps in order */
+    steps: TutorialStep[];
+    /** Required prerequisite tutorials */
+    prerequisites: TutorialId[];
+    /** Priority (higher = shown first) */
+    priority: number;
+    /** Auto-start when conditions met */
+    autoStart: boolean;
+    /** Condition to trigger */
+    triggerCondition?: () => boolean;
+    /** Allow replay */
+    replayable: boolean;
+    /** Category for grouping */
+    category?: string;
+    /** Estimated completion time (minutes) */
+    estimatedTime?: number;
+    /** Rewards on completion */
+    rewards?: Array<{
+        type: string;
+        value: unknown;
+    }>;
+    /** On complete callback */
+    onComplete?: () => void | Promise<void>;
+    /** On skip callback */
+    onSkip?: () => void | Promise<void>;
+}
+export interface TooltipDefinition {
+    id: TooltipId;
+    targetId?: string;
+    targetSelector?: string;
+    message: string;
+    title?: string;
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+    showOnHover?: boolean;
+    showOnce?: boolean;
+    delay?: number;
+    duration?: number;
+    dismissible?: boolean;
+}
+export interface HintDefinition {
+    id: HintId;
+    message: string;
+    icon?: string;
+    priority: number;
+    condition?: () => boolean;
+    showOnce?: boolean;
+    category?: string;
+}
+export interface TutorialProgress {
+    tutorialId: TutorialId;
+    currentStepIndex: number;
+    completedSteps: StepId[];
+    startedAt: number;
+    completedAt?: number;
+    skipped: boolean;
+    choicesMade: Record<StepId, string>;
+}
+export interface TutorialState {
+    activeTutorial?: TutorialId;
+    activeStep?: StepId;
+    activeTooltips: TooltipId[];
+    queuedTutorials: TutorialId[];
+    completedTutorials: TutorialId[];
+    skippedTutorials: TutorialId[];
+    progress: Map<TutorialId, TutorialProgress>;
+    shownHints: Set<HintId>;
+    shownTooltips: Set<TooltipId>;
+    isLocked: boolean;
+}
+export type TutorialEventType = 'tutorial-started' | 'tutorial-completed' | 'tutorial-skipped' | 'tutorial-paused' | 'tutorial-resumed' | 'step-enter' | 'step-exit' | 'step-action' | 'choice-made' | 'tooltip-shown' | 'tooltip-hidden' | 'hint-shown' | 'hint-dismissed' | 'progress-saved';
+export interface TutorialEvent {
+    type: TutorialEventType;
+    timestamp: number;
+    tutorialId?: TutorialId;
+    stepId?: StepId;
+    data?: unknown;
+}
+export type TutorialEventCallback = (event: TutorialEvent) => void;
+export interface TutorialConfig {
+    /** Storage key for progress */
+    storageKey: string;
+    /** Show skip button */
+    showSkipButton: boolean;
+    /** Show progress indicator */
+    showProgress: boolean;
+    /** Dim background during tutorials */
+    dimBackground: boolean;
+    /** Dim opacity */
+    dimOpacity: number;
+    /** Block input outside highlight */
+    blockInput: boolean;
+    /** Default dialog position */
+    defaultDialogPosition: 'top' | 'bottom' | 'left' | 'right' | 'center';
+    /** Auto-save progress */
+    autoSave: boolean;
+    /** Pause on blur */
+    pauseOnBlur: boolean;
+    /** Enable keyboard navigation */
+    keyboardNavigation: boolean;
+}
+export declare const DEFAULT_TUTORIAL_CONFIG: TutorialConfig;
+export interface TutorialRenderData {
+    isActive: boolean;
+    tutorial?: TutorialDefinition;
+    step?: TutorialStep;
+    stepIndex: number;
+    totalSteps: number;
+    progress: number;
+    highlight?: StepHighlight;
+    dialogPosition: {
+        x: number;
+        y: number;
+    } | string;
+    activeTooltips: Array<TooltipDefinition & {
+        visible: boolean;
+    }>;
+    canProceed: boolean;
+    canSkip: boolean;
+    canGoBack: boolean;
+}
+export declare class NiceTutorial {
+    private config;
+    private tutorials;
+    private tooltips;
+    private hints;
+    private state;
+    private isPaused;
+    private actionCallbacks;
+    private eventListeners;
+    constructor(config?: Partial<TutorialConfig>);
+    on(event: TutorialEventType, callback: TutorialEventCallback): () => void;
+    private emit;
+    registerTutorial(tutorial: TutorialDefinition): void;
+    unregisterTutorial(tutorialId: TutorialId): void;
+    registerTooltip(tooltip: TooltipDefinition): void;
+    registerHint(hint: HintDefinition): void;
+    registerActionHandler(actionType: string, handler: (data: unknown) => boolean): void;
+    handleAction(actionType: string, data?: unknown): void;
+    startTutorial(tutorialId: TutorialId, force?: boolean): boolean;
+    private enterStep;
+    nextStep(): void;
+    previousStep(): void;
+    goToStep(stepId: StepId): void;
+    makeChoice(choiceId: string): void;
+    skipStep(): void;
+    skipTutorial(): void;
+    private completeTutorial;
+    private endTutorial;
+    pauseTutorial(): void;
+    resumeTutorial(): void;
+    showTooltip(tooltipId: TooltipId): void;
+    hideTooltip(tooltipId: TooltipId): void;
+    hideAllTooltips(): void;
+    getAvailableHints(): HintDefinition[];
+    showHint(hintId: HintId): void;
+    dismissHint(hintId: HintId): void;
+    isActive(): boolean;
+    getActiveTutorial(): TutorialDefinition | undefined;
+    getCurrentStep(): TutorialStep | undefined;
+    getCurrentStepIndex(): number;
+    getTotalSteps(): number;
+    getProgress(tutorialId?: TutorialId): TutorialProgress | undefined;
+    isCompleted(tutorialId: TutorialId): boolean;
+    isSkipped(tutorialId: TutorialId): boolean;
+    getCompletedTutorials(): TutorialId[];
+    getAvailableTutorials(): TutorialDefinition[];
+    checkAutoStart(): void;
+    lock(): void;
+    unlock(): void;
+    getRenderData(): TutorialRenderData;
+    private loadProgress;
+    private saveProgress;
+    resetProgress(tutorialId?: TutorialId): void;
+    destroy(): void;
+}
+export declare function createTutorialSystem(config?: Partial<TutorialConfig>): NiceTutorial;