@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,157 @@
+export type AuctionId = string;
+export type ListingId = string;
+export type BidId = string;
+export type UserId = string;
+export type ItemId = string;
+export type CategoryId = string;
+export type AuctionStatus = 'active' | 'sold' | 'expired' | 'cancelled';
+export type BidStatus = 'pending' | 'outbid' | 'winning' | 'won' | 'lost';
+export interface AuctionItem {
+    itemId: ItemId;
+    name: string;
+    description?: string;
+    icon?: string;
+    quantity: number;
+    rarity?: string;
+    level?: number;
+    stats?: Record<string, number>;
+    category: CategoryId;
+    tags?: string[];
+}
+export interface Bid {
+    id: BidId;
+    auctionId: AuctionId;
+    bidderId: UserId;
+    amount: number;
+    timestamp: number;
+    status: BidStatus;
+}
+export interface AuctionListing {
+    id: AuctionId;
+    sellerId: UserId;
+    sellerName?: string;
+    item: AuctionItem;
+    startingPrice: number;
+    currentPrice: number;
+    buyNowPrice?: number;
+    minBidIncrement: number;
+    currency: string;
+    bids: Bid[];
+    highestBidderId?: UserId;
+    totalBids: number;
+    createdAt: number;
+    expiresAt: number;
+    status: AuctionStatus;
+    soldAt?: number;
+    soldTo?: UserId;
+    finalPrice?: number;
+    listingFee: number;
+    sellerFeePercent: number;
+}
+export interface AuctionCategory {
+    id: CategoryId;
+    name: string;
+    parent?: CategoryId;
+    icon?: string;
+    sortOrder: number;
+}
+export interface PriceRecord {
+    itemId: ItemId;
+    price: number;
+    quantity: number;
+    timestamp: number;
+}
+export type AuctionEventType = 'listing-created' | 'listing-cancelled' | 'bid-placed' | 'outbid' | 'auction-won' | 'auction-sold' | 'auction-expired' | 'buy-now' | 'item-collected' | 'currency-collected';
+export interface AuctionEvent {
+    type: AuctionEventType;
+    timestamp: number;
+    auctionId: AuctionId;
+    data?: unknown;
+}
+export type AuctionEventCallback = (event: AuctionEvent) => void;
+export interface AuctionSearchParams {
+    query?: string;
+    category?: CategoryId;
+    rarity?: string;
+    minLevel?: number;
+    maxLevel?: number;
+    minPrice?: number;
+    maxPrice?: number;
+    sellerId?: UserId;
+    status?: AuctionStatus;
+    sortBy?: 'price' | 'time' | 'bids' | 'name';
+    sortOrder?: 'asc' | 'desc';
+    page?: number;
+    pageSize?: number;
+}
+export interface SearchResult {
+    listings: AuctionListing[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+}
+export interface AuctionConfig {
+    defaultDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    listingFee: number;
+    sellerFeePercent: number;
+    minBidIncrement: number;
+    minBidIncrementPercent: number;
+    maxListingsPerUser: number;
+    priceHistoryLimit: number;
+    antiSnipeExtension: number;
+    antiSnipeThreshold: number;
+    storageKey: string;
+}
+export declare const DEFAULT_AUCTION_CONFIG: AuctionConfig;
+export declare class NiceAuction {
+    private config;
+    private categories;
+    private listings;
+    private userListings;
+    private userBids;
+    private priceHistory;
+    private eventListeners;
+    private idCounter;
+    constructor(config?: Partial<AuctionConfig>);
+    on(event: AuctionEventType, callback: AuctionEventCallback): () => void;
+    private emit;
+    registerCategory(category: AuctionCategory): void;
+    getCategories(): AuctionCategory[];
+    getCategoryTree(): Array<AuctionCategory & {
+        children: AuctionCategory[];
+    }>;
+    createListing(sellerId: UserId, item: AuctionItem, startingPrice: number, options?: {
+        buyNowPrice?: number;
+        duration?: number;
+        currency?: string;
+        sellerName?: string;
+    }): AuctionListing | null;
+    cancelListing(auctionId: AuctionId, userId: UserId): boolean;
+    placeBid(auctionId: AuctionId, bidderId: UserId, amount: number): Bid | null;
+    buyNow(auctionId: AuctionId, buyerId: UserId): boolean;
+    private completeSale;
+    processExpiredListings(): AuctionListing[];
+    private recordPrice;
+    getPriceHistory(itemId: ItemId, limit?: number): PriceRecord[];
+    getAveragePrice(itemId: ItemId, days?: number): number | null;
+    search(params?: AuctionSearchParams): SearchResult;
+    getUserListings(userId: UserId): AuctionListing[];
+    getUserBids(userId: UserId): Array<{
+        listing: AuctionListing;
+        bid: Bid;
+    }>;
+    getWonAuctions(userId: UserId): AuctionListing[];
+    getSoldAuctions(userId: UserId): AuctionListing[];
+    getListing(auctionId: AuctionId): AuctionListing | undefined;
+    getActiveListingsCount(): number;
+    calculateSellerProceeds(listing: AuctionListing): number;
+    private generateId;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createAuctionSystem(config?: Partial<AuctionConfig>): NiceAuction;

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

@@ -0,0 +1,224 @@
+export type SoundId = string;
+export type MusicTrackId = string;
+export type SoundBankId = string;
+export type AudioCategory = 'master' | 'sfx' | 'music' | 'ambient' | 'voice' | 'ui';
+export interface SoundDefinition {
+    id: SoundId;
+    name: string;
+    /** URL or base64 data */
+    src: string | string[];
+    /** Audio category */
+    category: AudioCategory;
+    /** Default volume (0-1) */
+    volume: number;
+    /** Pitch variation range */
+    pitchVariation?: {
+        min: number;
+        max: number;
+    };
+    /** Max simultaneous instances */
+    maxInstances?: number;
+    /** Cooldown between plays (ms) */
+    cooldown?: number;
+    /** Loop sound */
+    loop?: boolean;
+    /** 3D positioning */
+    spatial?: boolean;
+    /** Falloff settings */
+    rolloff?: {
+        type: 'linear' | 'inverse' | 'exponential';
+        minDistance: number;
+        maxDistance: number;
+    };
+    /** Tags for grouping */
+    tags?: string[];
+}
+export interface SoundInstance {
+    id: string;
+    soundId: SoundId;
+    source: AudioBufferSourceNode | null;
+    gainNode: GainNode | null;
+    pannerNode: PannerNode | null;
+    playing: boolean;
+    paused: boolean;
+    startTime: number;
+    pauseTime: number;
+    volume: number;
+    pitch: number;
+    loop: boolean;
+    position?: Vec3;
+    onEnd?: () => void;
+}
+export interface MusicTrack {
+    id: MusicTrackId;
+    name: string;
+    src: string;
+    /** BPM for beat-synced transitions */
+    bpm?: number;
+    /** Loop points */
+    loopStart?: number;
+    loopEnd?: number;
+    /** Intro section (plays once) */
+    introEnd?: number;
+    /** Layers for dynamic music */
+    layers?: MusicLayer[];
+    /** Tags */
+    tags?: string[];
+}
+export interface MusicLayer {
+    id: string;
+    src: string;
+    /** Condition to enable layer */
+    condition?: string;
+    /** Volume of this layer */
+    volume: number;
+}
+export interface MusicState {
+    currentTrack: MusicTrackId | null;
+    nextTrack: MusicTrackId | null;
+    playing: boolean;
+    volume: number;
+    crossfading: boolean;
+    crossfadeProgress: number;
+    position: number;
+    activeLayers: string[];
+}
+export interface AmbientSound {
+    id: string;
+    soundId: SoundId;
+    volume: number;
+    /** Random interval range (ms) */
+    interval?: {
+        min: number;
+        max: number;
+    };
+    /** Continuous loop */
+    continuous?: boolean;
+    /** 3D position */
+    position?: Vec3;
+    /** Fade in/out time */
+    fadeTime?: number;
+}
+export interface AmbientLayer {
+    id: string;
+    name: string;
+    sounds: AmbientSound[];
+    volume: number;
+    active: boolean;
+}
+export interface SoundBank {
+    id: SoundBankId;
+    name: string;
+    sounds: SoundDefinition[];
+    /** Preload on registration */
+    preload?: boolean;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface ListenerState {
+    position: Vec3;
+    forward: Vec3;
+    up: Vec3;
+}
+export type AudioEventType = 'sound-start' | 'sound-end' | 'music-start' | 'music-end' | 'music-crossfade' | 'volume-changed' | 'mute-changed' | 'loaded';
+export interface AudioEvent {
+    type: AudioEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type AudioEventCallback = (event: AudioEvent) => void;
+export interface AudioConfig {
+    /** Master volume */
+    masterVolume: number;
+    /** Category volumes */
+    categoryVolumes: Record<AudioCategory, number>;
+    /** Default crossfade duration (ms) */
+    crossfadeDuration: number;
+    /** Max total sound instances */
+    maxInstances: number;
+    /** Audio context options */
+    contextOptions?: AudioContextOptions;
+    /** Auto-resume on interaction */
+    autoResume: boolean;
+    /** Enable 3D audio */
+    enable3D: boolean;
+    /** Storage key for settings */
+    storageKey: string;
+}
+export declare const DEFAULT_AUDIO_CONFIG: AudioConfig;
+export declare class NiceAudio {
+    private config;
+    private context;
+    private masterGain;
+    private categoryGains;
+    private sounds;
+    private buffers;
+    private instances;
+    private soundCooldowns;
+    private musicTracks;
+    private musicBuffers;
+    private musicState;
+    private musicSource;
+    private nextMusicSource;
+    private musicGain;
+    private nextMusicGain;
+    private ambientLayers;
+    private ambientTimers;
+    private listener;
+    private muted;
+    private eventListeners;
+    private loadingPromises;
+    constructor(config?: Partial<AudioConfig>);
+    init(): Promise<void>;
+    resume(): Promise<void>;
+    on(event: AudioEventType, callback: AudioEventCallback): () => void;
+    private emit;
+    registerSound(sound: SoundDefinition): void;
+    registerSounds(sounds: SoundDefinition[]): void;
+    registerSoundBank(bank: SoundBank): void;
+    loadSound(soundId: SoundId): Promise<AudioBuffer | null>;
+    private loadAudioBuffer;
+    play(soundId: SoundId, options?: Partial<{
+        volume: number;
+        pitch: number;
+        loop: boolean;
+        position: Vec3;
+        onEnd: () => void;
+    }>): Promise<string | null>;
+    stop(instanceId: string, fadeOut?: number): void;
+    stopAll(category?: AudioCategory): void;
+    setInstanceVolume(instanceId: string, volume: number): void;
+    setInstancePosition(instanceId: string, position: Vec3): void;
+    registerMusic(track: MusicTrack): void;
+    registerMusicTracks(tracks: MusicTrack[]): void;
+    loadMusic(trackId: MusicTrackId): Promise<AudioBuffer | null>;
+    playMusic(trackId: MusicTrackId, options?: Partial<{
+        crossfade: boolean;
+        fadeDuration: number;
+        startTime: number;
+    }>): Promise<void>;
+    stopMusic(fadeOut?: number): void;
+    setMusicVolume(volume: number): void;
+    getMusicState(): MusicState;
+    registerAmbientLayer(layer: AmbientLayer): void;
+    startAmbientLayer(layerId: string): void;
+    stopAmbientLayer(layerId: string): void;
+    private scheduleAmbientSound;
+    setMasterVolume(volume: number): void;
+    setCategoryVolume(category: AudioCategory, volume: number): void;
+    getMasterVolume(): number;
+    getCategoryVolume(category: AudioCategory): number;
+    mute(): void;
+    unmute(): void;
+    toggleMute(): void;
+    isMuted(): boolean;
+    setListenerPosition(position: Vec3): void;
+    setListenerOrientation(forward: Vec3, up: Vec3): void;
+    private saveSettings;
+    private loadSettings;
+    destroy(): void;
+}
+export declare function createAudioSystem(config?: Partial<AudioConfig>): NiceAudio;

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

@@ -0,0 +1,187 @@
+export type AugmentId = string;
+export type AugmentSlotId = string;
+export type AugmentSetId = string;
+export type EquipmentId = string;
+export type AugmentRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic';
+export type AugmentCategory = 'offensive' | 'defensive' | 'utility' | 'special';
+export type ModifierType = 'flat' | 'percent' | 'multiplier';
+export interface StatModifier {
+    stat: string;
+    type: ModifierType;
+    value: number;
+    condition?: {
+        type: string;
+        value: unknown;
+    };
+}
+export interface AugmentDefinition {
+    id: AugmentId;
+    name: string;
+    description: string;
+    icon?: string;
+    rarity: AugmentRarity;
+    category: AugmentCategory;
+    level: number;
+    maxLevel: number;
+    slotTypes: string[];
+    size: number;
+    modifiers: StatModifier[];
+    modifiersPerLevel?: StatModifier[];
+    setId?: AugmentSetId;
+    requirements?: {
+        level?: number;
+        stats?: Record<string, number>;
+        skills?: string[];
+    };
+    upgradeCost?: {
+        currency: string;
+        amount: number;
+        materials?: Array<{
+            itemId: string;
+            amount: number;
+        }>;
+    };
+    tags?: string[];
+}
+export interface AugmentSlot {
+    id: AugmentSlotId;
+    type: string;
+    size: number;
+    locked: boolean;
+    unlockCost?: {
+        currency: string;
+        amount: number;
+    };
+    augmentId?: AugmentId;
+}
+export interface AugmentableEquipment {
+    equipmentId: EquipmentId;
+    slots: AugmentSlot[];
+    maxSlots: number;
+}
+export interface SetBonus {
+    requiredPieces: number;
+    modifiers: StatModifier[];
+    specialEffect?: {
+        name: string;
+        description: string;
+        trigger?: string;
+        effect: unknown;
+    };
+}
+export interface AugmentSet {
+    id: AugmentSetId;
+    name: string;
+    description: string;
+    augmentIds: AugmentId[];
+    bonuses: SetBonus[];
+}
+export interface FusionRecipe {
+    id: string;
+    inputs: Array<{
+        augmentId?: AugmentId;
+        rarity?: AugmentRarity;
+        category?: AugmentCategory;
+        count: number;
+    }>;
+    output: {
+        augmentId?: AugmentId;
+        rarityUpgrade?: boolean;
+        levelBonus?: number;
+        randomPool?: AugmentId[];
+    };
+    cost?: {
+        currency: string;
+        amount: number;
+    };
+    successRate: number;
+}
+export interface SalvageResult {
+    materials: Array<{
+        itemId: string;
+        amount: number;
+    }>;
+    currency?: {
+        type: string;
+        amount: number;
+    };
+    preservedAugment?: AugmentId;
+}
+export interface AugmentInstance {
+    instanceId: string;
+    augmentId: AugmentId;
+    level: number;
+    experience: number;
+    locked: boolean;
+    enhanced: boolean;
+    bonusStats?: StatModifier[];
+}
+export interface AugmentState {
+    inventory: Map<string, AugmentInstance>;
+    equipment: Map<EquipmentId, AugmentableEquipment>;
+    activeSets: Map<AugmentSetId, number>;
+    totalStats: Map<string, number>;
+}
+export type AugmentEventType = 'augment-added' | 'augment-removed' | 'augment-equipped' | 'augment-unequipped' | 'augment-upgraded' | 'augment-fused' | 'augment-salvaged' | 'slot-unlocked' | 'set-bonus-activated' | 'set-bonus-deactivated';
+export interface AugmentEvent {
+    type: AugmentEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type AugmentEventCallback = (event: AugmentEvent) => void;
+export interface AugmentConfig {
+    maxInventorySize: number;
+    maxLevel: number;
+    experiencePerLevel: number[];
+    fusionEnabled: boolean;
+    salvageEnabled: boolean;
+    storageKey: string;
+}
+export declare const DEFAULT_AUGMENT_CONFIG: AugmentConfig;
+export declare const RARITY_CONFIG: Record<AugmentRarity, {
+    color: string;
+    multiplier: number;
+    salvageRate: number;
+    fusionCount: number;
+}>;
+export declare class NiceAugment {
+    private config;
+    private definitions;
+    private sets;
+    private recipes;
+    private state;
+    private eventListeners;
+    private instanceCounter;
+    constructor(config?: Partial<AugmentConfig>);
+    on(event: AugmentEventType, callback: AugmentEventCallback): () => void;
+    private emit;
+    registerAugment(def: AugmentDefinition): void;
+    registerSet(set: AugmentSet): void;
+    registerRecipe(recipe: FusionRecipe): void;
+    registerEquipment(equipment: AugmentableEquipment): void;
+    addSlot(equipmentId: EquipmentId, slotType: string, size?: number): AugmentSlotId | null;
+    unlockSlot(equipmentId: EquipmentId, slotId: AugmentSlotId): boolean;
+    addAugment(augmentId: AugmentId, level?: number): string | null;
+    removeAugment(instanceId: string): boolean;
+    equip(instanceId: string, equipmentId: EquipmentId, slotId: AugmentSlotId): boolean;
+    unequip(equipmentId: EquipmentId, slotId: AugmentSlotId): string | null;
+    upgradeAugment(instanceId: string, experienceGain: number): boolean;
+    fuse(recipeId: string, inputInstanceIds: string[]): string | null;
+    salvage(instanceId: string): SalvageResult | null;
+    private recalculateStats;
+    private applyModifier;
+    private recalculateSetBonuses;
+    getAugment(instanceId: string): AugmentInstance | undefined;
+    getDefinition(augmentId: AugmentId): AugmentDefinition | undefined;
+    getEquipment(equipmentId: EquipmentId): AugmentableEquipment | undefined;
+    getInventory(): AugmentInstance[];
+    getEquippedAugments(equipmentId: EquipmentId): AugmentId[];
+    getTotalStats(): Map<string, number>;
+    getStat(stat: string): number;
+    getActiveSets(): Map<AugmentSetId, number>;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createAugmentSystem(config?: Partial<AugmentConfig>): NiceAugment;