@nice2dev/game-engine 1.0.28 → 1.1.6

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

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

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

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

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