@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,140 +0,0 @@
-export type FormationId = string;
-export type UnitId = string;
-export type FormationPatternType = 'line' | 'column' | 'wedge' | 'square' | 'circle' | 'arc' | 'scattered' | 'custom';
-export interface Vector2D {
-    x: number;
-    y: number;
-}
-export interface FormationSlot {
-    index: number;
-    offset: Vector2D;
-    unitId?: UnitId;
-    priority: number;
-    role?: string;
-    facing?: number;
-}
-export interface FormationPattern {
-    type: FormationPatternType;
-    name: string;
-    slots: FormationSlot[];
-    spacing: number;
-    depth: number;
-    width: number;
-    rotatable: boolean;
-    scalable: boolean;
-}
-export interface Formation {
-    id: FormationId;
-    pattern: FormationPattern;
-    position: Vector2D;
-    rotation: number;
-    scale: number;
-    units: UnitId[];
-    leader?: UnitId;
-    state: FormationState;
-    targetPosition?: Vector2D;
-    targetRotation?: number;
-    speed: number;
-    modifiers: FormationModifier[];
-}
-export type FormationState = 'idle' | 'moving' | 'reforming' | 'engaging' | 'disbanding';
-export interface FormationModifier {
-    id: string;
-    type: 'spacing' | 'speed' | 'cohesion' | 'facing';
-    value: number;
-    source?: string;
-}
-export interface UnitFormationState {
-    unitId: UnitId;
-    formationId: FormationId;
-    slotIndex: number;
-    targetPosition: Vector2D;
-    currentPosition: Vector2D;
-    targetFacing: number;
-    inPosition: boolean;
-    distanceToSlot: number;
-}
-export type FormationEventType = 'formation-created' | 'formation-disbanded' | 'formation-pattern-changed' | 'unit-joined' | 'unit-left' | 'unit-assigned-slot' | 'formation-moving' | 'formation-arrived' | 'formation-reformed' | 'formation-broken' | 'leader-changed';
-export interface FormationEvent {
-    type: FormationEventType;
-    timestamp: number;
-    formationId: FormationId;
-    data?: unknown;
-}
-export type FormationEventCallback = (event: FormationEvent) => void;
-export interface FormationConfig {
-    /** Default spacing between units */
-    defaultSpacing: number;
-    /** Position tolerance for "in position" */
-    positionTolerance: number;
-    /** Reform speed multiplier */
-    reformSpeed: number;
-    /** Max units per formation */
-    maxUnitsPerFormation: number;
-    /** Enable automatic slot optimization */
-    autoOptimizeSlots: boolean;
-    /** Cohesion break distance */
-    cohesionBreakDistance: number;
-}
-export declare const DEFAULT_FORMATION_CONFIG: FormationConfig;
-export interface UnitPositionProvider {
-    getPosition(unitId: UnitId): Vector2D | null;
-    setTargetPosition(unitId: UnitId, position: Vector2D, facing?: number): void;
-    getSpeed(unitId: UnitId): number;
-}
-export declare class NiceFormation {
-    private config;
-    private formations;
-    private unitToFormation;
-    private unitStates;
-    private patterns;
-    private positionProvider?;
-    private idCounter;
-    private eventListeners;
-    constructor(config?: Partial<FormationConfig>);
-    on(event: FormationEventType, callback: FormationEventCallback): () => void;
-    private emit;
-    setPositionProvider(provider: UnitPositionProvider): void;
-    private registerDefaultPatterns;
-    private generateLineSlots;
-    private generateColumnSlots;
-    private generateWedgeSlots;
-    private generateSquareSlots;
-    private generateCircleSlots;
-    private generateArcSlots;
-    private generateScatteredSlots;
-    registerPattern(id: string, pattern: FormationPattern): void;
-    getPattern(id: string): FormationPattern | undefined;
-    getPatternNames(): string[];
-    createFormation(patternId: string, position: Vector2D, options?: {
-        rotation?: number;
-        scale?: number;
-        units?: UnitId[];
-        leader?: UnitId;
-        speed?: number;
-    }): FormationId | null;
-    disbandFormation(formationId: FormationId): void;
-    getFormation(formationId: FormationId): Formation | undefined;
-    getAllFormations(): Formation[];
-    addUnit(formationId: FormationId, unitId: UnitId): boolean;
-    removeUnit(formationId: FormationId, unitId: UnitId): void;
-    private assignSlot;
-    private selectNewLeader;
-    private reorganizeSlots;
-    moveFormation(formationId: FormationId, targetPosition: Vector2D): void;
-    rotateFormation(formationId: FormationId, targetRotation: number): void;
-    setFormationScale(formationId: FormationId, scale: number): void;
-    changePattern(formationId: FormationId, patternId: string): void;
-    private updateFormation;
-    update(deltaTime: number): void;
-    private updateFormationState;
-    getUnitFormation(unitId: UnitId): FormationId | undefined;
-    getUnitState(unitId: UnitId): UnitFormationState | undefined;
-    getSlotPosition(formationId: FormationId, slotIndex: number): Vector2D | null;
-    isFormationComplete(formationId: FormationId): boolean;
-    addModifier(formationId: FormationId, modifier: FormationModifier): void;
-    removeModifier(formationId: FormationId, modifierId: string): void;
-    private applyModifiers;
-    destroy(): void;
-}
-export declare function createFormationSystem(config?: Partial<FormationConfig>): NiceFormation;

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

@@ -1,134 +0,0 @@
-export type BannerId = string;
-export type ItemId = string;
-export type CurrencyId = string;
-export type GachaRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic';
-export interface GachaItem {
-    id: ItemId;
-    name: string;
-    description: string;
-    rarity: GachaRarity;
-    icon?: string;
-    model?: string;
-    type: string;
-    tags?: string[];
-}
-export interface GachaPullResult {
-    item: GachaItem;
-    isRateUp: boolean;
-    isPity: boolean;
-    isSpark: boolean;
-    banner: BannerId;
-    timestamp: number;
-}
-export interface BannerPool {
-    rarity: GachaRarity;
-    baseRate: number;
-    items: ItemId[];
-    rateUpItems?: ItemId[];
-    rateUpBonus?: number;
-}
-export interface BannerDefinition {
-    id: BannerId;
-    name: string;
-    description: string;
-    startDate?: Date | number;
-    endDate?: Date | number;
-    pools: BannerPool[];
-    currency: CurrencyId;
-    singlePullCost: number;
-    multiPullCost?: number;
-    multiPullCount?: number;
-    softPityStart?: number;
-    softPityRateIncrease?: number;
-    hardPity?: number;
-    hardPityRarity?: GachaRarity;
-    sparkCost?: number;
-    sparkItems?: ItemId[];
-    banner?: string;
-    featured?: ItemId[];
-    dailyLimit?: number;
-    totalLimit?: number;
-}
-export interface BannerState {
-    bannerId: BannerId;
-    pullCount: number;
-    pityCounter: number;
-    sparkPoints: number;
-    dailyPulls: number;
-    lastPullDate: string;
-    history: GachaPullResult[];
-}
-export type GachaEventType = 'banner-added' | 'banner-removed' | 'pull-single' | 'pull-multi' | 'pity-triggered' | 'spark-redeemed' | 'currency-spent' | 'item-obtained';
-export interface GachaEvent {
-    type: GachaEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type GachaEventCallback = (event: GachaEvent) => void;
-export interface GachaConfig {
-    defaultRates: Record<GachaRarity, number>;
-    sparkPointsPerPull: number;
-    enableAnimation: boolean;
-    maxHistoryPerBanner: number;
-    storageKey: string;
-}
-export declare const DEFAULT_GACHA_CONFIG: GachaConfig;
-export declare const RARITY_ORDER: GachaRarity[];
-export declare class NiceGacha {
-    private config;
-    private items;
-    private banners;
-    private bannerStates;
-    private currencies;
-    private eventListeners;
-    constructor(config?: Partial<GachaConfig>);
-    on(event: GachaEventType, callback: GachaEventCallback): () => void;
-    private emit;
-    registerItem(item: GachaItem): void;
-    registerItems(items: GachaItem[]): void;
-    addBanner(banner: BannerDefinition): void;
-    removeBanner(bannerId: BannerId): void;
-    setCurrency(currencyId: CurrencyId, amount: number): void;
-    addCurrency(currencyId: CurrencyId, amount: number): void;
-    getCurrency(currencyId: CurrencyId): number;
-    private spendCurrency;
-    canPull(bannerId: BannerId, count?: number): {
-        canPull: boolean;
-        reason?: string;
-    };
-    pull(bannerId: BannerId): GachaPullResult | null;
-    multiPull(bannerId: BannerId): GachaPullResult[] | null;
-    private performPull;
-    private calculateRates;
-    private updateBannerState;
-    canSpark(bannerId: BannerId, itemId: ItemId): boolean;
-    spark(bannerId: BannerId, itemId: ItemId): GachaItem | null;
-    getBanner(bannerId: BannerId): BannerDefinition | undefined;
-    getBannerState(bannerId: BannerId): BannerState | undefined;
-    getActiveBanners(): BannerDefinition[];
-    getHistory(bannerId: BannerId, limit?: number): GachaPullResult[];
-    getPityInfo(bannerId: BannerId): {
-        current: number;
-        softPityStart: number | null;
-        hardPity: number | null;
-        untilSoftPity: number | null;
-        untilHardPity: number | null;
-    } | null;
-    getSparkInfo(bannerId: BannerId): {
-        current: number;
-        cost: number | null;
-        available: ItemId[];
-        progress: number;
-    } | null;
-    getStats(bannerId?: BannerId): {
-        totalPulls: number;
-        rarityDistribution: Record<GachaRarity, number>;
-        rateUpHits: number;
-        pityHits: number;
-    };
-    private save;
-    private load;
-    reset(bannerId?: BannerId): void;
-    destroy(): void;
-}
-export declare function createGachaSystem(config?: Partial<GachaConfig>): NiceGacha;

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

@@ -1,175 +0,0 @@
-export type GameId = string;
-export type JackpotId = string;
-export type GamblingGameType = 'slots' | 'dice' | 'blackjack' | 'poker' | 'roulette' | 'wheel' | 'scratch' | 'custom';
-export type BetResult = 'win' | 'loss' | 'push' | 'jackpot';
-export interface GamblingPayout {
-    condition: string;
-    multiplier: number;
-    chance?: number;
-}
-export interface GamblingGame {
-    id: GameId;
-    name: string;
-    description: string;
-    type: GamblingGameType;
-    minBet: number;
-    maxBet: number;
-    currency: string;
-    houseEdge: number;
-    payouts: GamblingPayout[];
-    jackpotContribution?: number;
-    cooldown?: number;
-    dailyLimit?: number;
-    sessionLimit?: number;
-    icon?: string;
-    theme?: string;
-}
-export interface SlotSymbol {
-    id: string;
-    name: string;
-    icon: string;
-    weight: number;
-    payoutMultiplier: number;
-    isWild?: boolean;
-    isScatter?: boolean;
-}
-export interface SlotConfig extends GamblingGame {
-    type: 'slots';
-    reels: number;
-    rows: number;
-    symbols: SlotSymbol[];
-    paylines: number[][];
-    freeSpinsSymbol?: string;
-    freeSpinsCount?: number;
-}
-export interface DiceConfig extends GamblingGame {
-    type: 'dice';
-    numDice: number;
-    sides: number;
-    targetModes: Array<'over' | 'under' | 'exact'>;
-}
-export type RouletteBetType = 'straight' | 'split' | 'street' | 'corner' | 'line' | 'dozen' | 'column' | 'red' | 'black' | 'odd' | 'even' | 'low' | 'high';
-export interface RouletteConfig extends GamblingGame {
-    type: 'roulette';
-    numbers: number[];
-    hasDoubleZero: boolean;
-    betTypes: RouletteBetType[];
-}
-export interface Jackpot {
-    id: JackpotId;
-    name: string;
-    currentAmount: number;
-    seedAmount: number;
-    contributionRate: number;
-    lastWonAt?: number;
-    lastWonBy?: string;
-    lastWonAmount?: number;
-    linkedGames: GameId[];
-}
-export interface Bet {
-    id: string;
-    gameId: GameId;
-    playerId: string;
-    amount: number;
-    betType?: string;
-    betValue?: unknown;
-    timestamp: number;
-}
-export interface BetOutcome {
-    bet: Bet;
-    result: BetResult;
-    outcome: unknown;
-    winAmount: number;
-    multiplier: number;
-    jackpotWon?: number;
-    animationData?: unknown;
-}
-export interface GamblingPlayerStats {
-    playerId: string;
-    totalBets: number;
-    totalWagered: number;
-    totalWon: number;
-    totalLost: number;
-    netProfit: number;
-    biggestWin: number;
-    biggestLoss: number;
-    currentStreak: number;
-    bestWinStreak: number;
-    jackpotsWon: number;
-    sessionBets: number;
-    sessionWagered: number;
-    sessionNet: number;
-    sessionStart: number;
-    dailyBets: number;
-    dailyWagered: number;
-    lastBetDate: string;
-    dailyLimitReached: boolean;
-    sessionLimitReached: boolean;
-    cooldownUntil?: number;
-}
-export type GamblingEventType = 'bet-placed' | 'bet-result' | 'jackpot-won' | 'jackpot-contribution' | 'streak-bonus' | 'daily-limit-reached' | 'session-limit-reached' | 'game-cooldown';
-export interface GamblingEvent {
-    type: GamblingEventType;
-    timestamp: number;
-    playerId?: string;
-    gameId?: GameId;
-    data?: unknown;
-}
-export type GamblingEventCallback = (event: GamblingEvent) => void;
-export interface GamblingConfig {
-    defaultCurrency: string;
-    enableResponsibleGaming: boolean;
-    defaultDailyLimit: number;
-    defaultSessionLimit: number;
-    sessionTimeout: number;
-    streakBonusThreshold: number;
-    streakBonusMultiplier: number;
-    maxStreakBonus: number;
-    storageKey: string;
-}
-export declare const DEFAULT_GAMBLING_CONFIG: GamblingConfig;
-export declare class NiceGambling {
-    private config;
-    private games;
-    private jackpots;
-    private playerStats;
-    private betHistory;
-    private eventListeners;
-    private betCounter;
-    constructor(config?: Partial<GamblingConfig>);
-    on(event: GamblingEventType, callback: GamblingEventCallback): () => void;
-    private emit;
-    registerGame(game: GamblingGame): void;
-    registerJackpot(jackpot: Jackpot): void;
-    private getOrCreateStats;
-    getPlayerStats(playerId: string): GamblingPlayerStats;
-    canBet(playerId: string, gameId: GameId, amount: number): {
-        can: boolean;
-        reason?: string;
-    };
-    placeBet(playerId: string, gameId: GameId, amount: number, betType?: string, betValue?: unknown): BetOutcome | null;
-    private processGameBet;
-    private processSlotsBet;
-    private weightedRandomSymbol;
-    private evaluateSlotLine;
-    private processDiceBet;
-    private processRouletteBet;
-    private getRouletteNumbers;
-    private getRoulettePayout;
-    private processGenericBet;
-    private updatePlayerStats;
-    private updateStreak;
-    private checkLimits;
-    private contributeToJackpot;
-    private awardJackpot;
-    getGame(gameId: GameId): GamblingGame | undefined;
-    getAllGames(): GamblingGame[];
-    getJackpot(jackpotId: JackpotId): Jackpot | undefined;
-    getAllJackpots(): Jackpot[];
-    getBetHistory(playerId?: string, limit?: number): BetOutcome[];
-    private save;
-    private load;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createGamblingSystem(config?: Partial<GamblingConfig>): NiceGambling;

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

@@ -1,165 +0,0 @@
-export type GemId = string;
-export type GemSetId = string;
-export type GemType = 'ruby' | 'sapphire' | 'emerald' | 'topaz' | 'diamond' | 'amethyst' | 'onyx' | 'opal' | 'prismatic';
-export type GemQuality = 'chipped' | 'flawed' | 'normal' | 'flawless' | 'perfect' | 'radiant';
-export type SocketColor = 'red' | 'blue' | 'green' | 'yellow' | 'white' | 'prismatic';
-export interface GemDefinition {
-    id: GemId;
-    name: string;
-    description: string;
-    type: GemType;
-    quality: GemQuality;
-    tier: number;
-    weaponStats: GemStat[];
-    armorStats: GemStat[];
-    helmStats: GemStat[];
-    socketColor: SocketColor;
-    combineInto?: GemId;
-    combineCount: number;
-    setId?: GemSetId;
-    icon: string;
-    color: string;
-    sparkle?: string;
-    sellValue: number;
-    tags?: string[];
-}
-export interface GemStat {
-    stat: string;
-    value: number;
-    isPercentage: boolean;
-}
-export interface GemSetDefinition {
-    id: GemSetId;
-    name: string;
-    description?: string;
-    gems: GemId[];
-    bonuses: GemSetBonus[];
-}
-export interface GemSetBonus {
-    count: number;
-    stats: GemStat[];
-    effect?: string;
-    effectDescription?: string;
-}
-export interface GemSocketedItem {
-    itemId: string;
-    itemType: 'weapon' | 'armor' | 'helm' | 'shield' | 'accessory';
-    sockets: GemSocket[];
-    maxSockets: number;
-    computedStats: Map<string, number>;
-    activeSetBonuses: ActiveSetBonus[];
-}
-export interface GemSocket {
-    index: number;
-    color: SocketColor;
-    gem?: GemId;
-    locked: boolean;
-}
-export interface ActiveSetBonus {
-    setId: GemSetId;
-    count: number;
-    bonuses: GemSetBonus[];
-}
-export interface PlayerGemData {
-    playerId: string;
-    gemStash: Map<GemId, number>;
-    maxGemSlots: number;
-    jewelerLevel: number;
-    jewelerXP: number;
-    totalGemsFound: number;
-    totalGemsCombined: number;
-    totalGemsSocketed: number;
-    perfectGemsCreated: number;
-}
-export interface CombineResult {
-    success: boolean;
-    resultGem?: GemId;
-    gemsConsumed: number;
-}
-export type GemEventType = 'gem-obtained' | 'gem-socketed' | 'gem-removed' | 'gem-combined' | 'gem-extracted' | 'socket-added' | 'socket-unlocked' | 'set-bonus-activated' | 'jeweler-level-up';
-export interface GemEvent {
-    type: GemEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type GemEventCallback = (event: GemEvent) => void;
-export interface GemConfig {
-    maxGemSlots: number;
-    defaultCombineCount: number;
-    extractionSuccessRate: number;
-    socketUnlockCost: number;
-    jewelerXPPerLevel: number;
-    jewelerMaxLevel: number;
-    storageKey: string;
-}
-export declare const DEFAULT_GEM_CONFIG: GemConfig;
-export declare class NiceGem {
-    private config;
-    private gems;
-    private sets;
-    private items;
-    private players;
-    private eventListeners;
-    constructor(config?: Partial<GemConfig>);
-    on(event: GemEventType, callback: GemEventCallback): () => void;
-    private emit;
-    registerGem(gem: GemDefinition): void;
-    registerGems(gems: GemDefinition[]): void;
-    registerSet(set: GemSetDefinition): void;
-    getPlayer(playerId: string): PlayerGemData;
-    private createPlayerData;
-    addGem(playerId: string, gemId: GemId, count?: number): boolean;
-    removeGem(playerId: string, gemId: GemId, count?: number): boolean;
-    getGemCount(playerId: string, gemId: GemId): number;
-    getGemInventory(playerId: string): Map<GemId, number>;
-    getGemsByType(playerId: string, type: GemType): {
-        gem: GemDefinition;
-        count: number;
-    }[];
-    registerItem(itemId: string, itemType: GemSocketedItem['itemType'], socketCount: number, socketColors?: SocketColor[]): GemSocketedItem;
-    getItem(itemId: string): GemSocketedItem | undefined;
-    addSocket(itemId: string, color?: SocketColor, maxSockets?: number): boolean;
-    socketGem(playerId: string, itemId: string, socketIndex: number, gemId: GemId): boolean;
-    unsocketGem(playerId: string, itemId: string, socketIndex: number): GemId | null;
-    unsocketAllGems(playerId: string, itemId: string): GemId[];
-    extractGem(playerId: string, itemId: string, socketIndex: number): {
-        success: boolean;
-        gemId?: GemId;
-        destroyed: boolean;
-    };
-    private gemTypeToSocketColor;
-    canCombine(playerId: string, gemId: GemId): boolean;
-    combineGems(playerId: string, gemId: GemId): CombineResult;
-    combineAllGems(playerId: string, gemId: GemId): CombineResult[];
-    private recalculateItem;
-    private getGemStatsForItem;
-    private calculateSetBonuses;
-    addJewelerXP(playerId: string, xp: number): void;
-    getJewelerXPForLevel(level: number): number;
-    getJewelerProgress(playerId: string): {
-        level: number;
-        xp: number;
-        xpNeeded: number;
-    };
-    getGem(id: GemId): GemDefinition | undefined;
-    getAllGems(): GemDefinition[];
-    getGemsByQuality(quality: GemQuality): GemDefinition[];
-    getSet(id: GemSetId): GemSetDefinition | undefined;
-    getAllSets(): GemSetDefinition[];
-    getItemStats(itemId: string): Map<string, number>;
-    getItemSetBonuses(itemId: string): ActiveSetBonus[];
-    getUpgradeChain(gemId: GemId): GemDefinition[];
-    getStats(playerId: string): {
-        totalGems: number;
-        uniqueGems: number;
-        perfectGems: number;
-        gemsCombined: number;
-        gemsSocketed: number;
-        jewelerLevel: number;
-    };
-    save(): void;
-    load(): void;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createGemSystem(config?: Partial<GemConfig>): NiceGem;