@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,215 @@
+export type RaidId = string;
+export type BossId = string;
+export type PhaseId = string;
+export type MechanicId = string;
+export type AchievementId = string;
+export type RaidDifficulty = 'lfr' | 'normal' | 'heroic' | 'mythic';
+export type RaidRole = 'tank' | 'healer' | 'dps';
+export type RaidStatus = 'forming' | 'ready' | 'in_progress' | 'completed' | 'failed' | 'disbanded';
+export type PhaseStatus = 'pending' | 'active' | 'completed';
+export interface MechanicDefinition {
+    id: MechanicId;
+    name: string;
+    description: string;
+    type: 'avoidable' | 'stack' | 'spread' | 'soak' | 'interrupt' | 'tank_swap' | 'heal_check';
+    damage?: number;
+    duration?: number;
+    cooldown?: number;
+    warningTime?: number;
+    icon?: string;
+}
+export interface PhaseDefinition {
+    id: PhaseId;
+    name: string;
+    description?: string;
+    healthThreshold?: number;
+    timeLimit?: number;
+    mechanics: MechanicDefinition[];
+    enrageTimer?: number;
+}
+export interface BossDefinition {
+    id: BossId;
+    name: string;
+    title?: string;
+    description: string;
+    baseHealth: number;
+    baseDamage: number;
+    phases: PhaseDefinition[];
+    lootTable: Array<{
+        itemId: string;
+        dropChance: number;
+        minQuantity: number;
+        maxQuantity: number;
+    }>;
+    minPlayers: number;
+    recommendedRoles: {
+        tanks: number;
+        healers: number;
+        dps: number;
+    };
+    model?: string;
+    portrait?: string;
+    achievements?: BossAchievement[];
+}
+export interface BossAchievement {
+    id: AchievementId;
+    name: string;
+    description: string;
+    condition: string;
+}
+export interface RaidDefinition {
+    id: RaidId;
+    name: string;
+    description: string;
+    tier: number;
+    minLevel: number;
+    minItemLevel?: number;
+    minPlayers: number;
+    maxPlayers: number;
+    bosses: BossDefinition[];
+    bossOrder: BossId[];
+    difficulties: RaidDifficulty[];
+    difficultyScaling: Record<RaidDifficulty, {
+        healthMultiplier: number;
+        damageMultiplier: number;
+        lootMultiplier: number;
+        extraMechanics?: string[];
+    }>;
+    lockoutType: 'boss' | 'raid';
+    lockoutDuration: number;
+    icon?: string;
+    background?: string;
+    completionRewards?: Array<{
+        type: string;
+        itemId: string;
+        quantity: number;
+    }>;
+}
+export interface RaidMember {
+    playerId: string;
+    name: string;
+    role: RaidRole;
+    class?: string;
+    itemLevel?: number;
+    ready: boolean;
+    connected: boolean;
+    alive: boolean;
+    damageDealt: number;
+    damageTaken: number;
+    healingDone: number;
+    deaths: number;
+    mechanicsHit: number;
+}
+export interface BossInstance {
+    bossId: BossId;
+    status: 'pending' | 'active' | 'defeated' | 'failed';
+    currentPhase: number;
+    currentHealth: number;
+    maxHealth: number;
+    startTime?: number;
+    endTime?: number;
+    pullCount: number;
+    bestAttempt?: number;
+    lootDropped?: Array<{
+        itemId: string;
+        quantity: number;
+        awardedTo?: string;
+    }>;
+}
+export interface RaidInstance {
+    instanceId: string;
+    raidId: RaidId;
+    definition: RaidDefinition;
+    difficulty: RaidDifficulty;
+    status: RaidStatus;
+    leader: string;
+    members: Map<string, RaidMember>;
+    currentBossIndex: number;
+    bosses: Map<BossId, BossInstance>;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    totalWipes: number;
+    totalDeaths: number;
+    totalDamageDealt: number;
+    unlockedAchievements: Set<AchievementId>;
+}
+export interface RaidLockout {
+    raidId: RaidId;
+    difficulty: RaidDifficulty;
+    defeatedBosses: Set<BossId>;
+    expiresAt: number;
+}
+export type RaidEventType = 'raid-formed' | 'raid-started' | 'raid-completed' | 'raid-disbanded' | 'member-joined' | 'member-left' | 'boss-pulled' | 'boss-defeated' | 'boss-wipe' | 'phase-changed' | 'mechanic-triggered' | 'loot-dropped' | 'achievement-unlocked';
+export interface RaidEvent {
+    type: RaidEventType;
+    timestamp: number;
+    instanceId: string;
+    data?: unknown;
+}
+export type RaidEventCallback = (event: RaidEvent) => void;
+export interface RaidConfig {
+    readyCheckTimeout: number;
+    pullCountdown: number;
+    combatLogRetention: number;
+    autoDistributeLoot: boolean;
+    personalLootEnabled: boolean;
+    storageKey: string;
+}
+export declare const DEFAULT_RAID_CONFIG: RaidConfig;
+export declare class NiceRaid {
+    private config;
+    private definitions;
+    private instances;
+    private playerInstances;
+    private lockouts;
+    private eventListeners;
+    private instanceCounter;
+    constructor(config?: Partial<RaidConfig>);
+    on(event: RaidEventType, callback: RaidEventCallback): () => void;
+    private emit;
+    registerRaid(definition: RaidDefinition): void;
+    getRaidDefinition(raidId: RaidId): RaidDefinition | undefined;
+    formRaid(raidId: RaidId, leaderId: string, leaderData: {
+        name: string;
+        role: RaidRole;
+        class?: string;
+        itemLevel?: number;
+    }, difficulty?: RaidDifficulty): RaidInstance | null;
+    joinRaid(instanceId: string, playerId: string, data: {
+        name: string;
+        role: RaidRole;
+        class?: string;
+        itemLevel?: number;
+    }): boolean;
+    leaveRaid(instanceId: string, playerId: string): boolean;
+    setReady(instanceId: string, playerId: string, ready: boolean): void;
+    getRoleCount(instanceId: string): {
+        tanks: number;
+        healers: number;
+        dps: number;
+    };
+    startRaid(instanceId: string): boolean;
+    disbandRaid(instanceId: string): void;
+    pullBoss(instanceId: string, bossId: BossId): boolean;
+    damageBoss(instanceId: string, bossId: BossId, damage: number, dealerId?: string): void;
+    private checkPhaseTransition;
+    defeatBoss(instanceId: string, bossId: BossId): void;
+    wipeBoss(instanceId: string, bossId: BossId): void;
+    triggerMechanic(instanceId: string, bossId: BossId, mechanicId: MechanicId, affectedPlayers: string[]): void;
+    private generateLoot;
+    awardLoot(instanceId: string, bossId: BossId, itemId: string, playerId: string): boolean;
+    private completeRaid;
+    private updateLockout;
+    getPlayerLockouts(playerId: string): RaidLockout[];
+    hasLockout(playerId: string, raidId: RaidId, difficulty: RaidDifficulty, bossId: BossId): boolean;
+    private checkBossAchievements;
+    getInstance(instanceId: string): RaidInstance | undefined;
+    getPlayerRaid(playerId: string): RaidInstance | undefined;
+    getActiveRaids(): RaidInstance[];
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createRaidSystem(config?: Partial<RaidConfig>): NiceRaid;

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

@@ -0,0 +1,399 @@
+/**
+ * NiceRanking - Ranking & Tier System
+ *
+ * Comprehensive competitive ranking system with tiers,
+ * divisions, ELO/MMR calculations, and seasonal resets.
+ *
+ * Features:
+ * - Multiple ranking algorithms
+ * - Tier & division system
+ * - Placement matches
+ * - Decay system
+ * - Seasonal rankings
+ * - Leaderboards
+ * - Match history
+ * - Skill brackets
+ * - Group rankings
+ * - Regional rankings
+ * - Rank protection
+ * - Streaks & bonuses
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique player ID */
+export type PlayerId = string;
+/** Unique season ID */
+export type SeasonId = string;
+/** Unique match ID */
+export type MatchId = string;
+/** Ranking algorithm type */
+export type RankingAlgorithm = 'elo' | 'glicko2' | 'trueskill' | 'mmr' | 'custom';
+/** Match result */
+export type MatchResult = 'win' | 'loss' | 'draw' | 'abandoned';
+/** Rank tier */
+export type RankTier = 'unranked' | 'bronze' | 'silver' | 'gold' | 'platinum' | 'diamond' | 'master' | 'grandmaster' | 'legend';
+/** Division within tier */
+export type RankDivision = 1 | 2 | 3 | 4 | 5;
+/** Player ranking data */
+export interface PlayerRanking {
+    playerId: PlayerId;
+    rating: number;
+    peakRating: number;
+    tier: RankTier;
+    division: RankDivision;
+    ratingDeviation: number;
+    volatility: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    winStreak: number;
+    lossStreak: number;
+    maxWinStreak: number;
+    maxLossStreak: number;
+    gamesPlayed: number;
+    lastMatchTime?: number;
+    placementGames: number;
+    placementRequired: number;
+    isPlaced: boolean;
+    rankProtection: number;
+    decayWarning: boolean;
+    seasonId: SeasonId;
+    region?: string;
+    percentile?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Tier configuration */
+export interface TierConfig {
+    tier: RankTier;
+    name: string;
+    minRating: number;
+    maxRating: number;
+    divisions: number;
+    color: string;
+    icon?: string;
+    rewards?: TierReward[];
+}
+/** Tier reward */
+export interface TierReward {
+    type: string;
+    id: string;
+    name: string;
+    tier: RankTier;
+    division?: RankDivision;
+}
+/** Match record */
+export interface MatchRecord {
+    matchId: MatchId;
+    playerId: PlayerId;
+    opponentId?: PlayerId;
+    teamId?: string;
+    result: MatchResult;
+    ratingBefore: number;
+    ratingAfter: number;
+    ratingChange: number;
+    tierBefore?: RankTier;
+    tierAfter?: RankTier;
+    divisionBefore?: RankDivision;
+    divisionAfter?: RankDivision;
+    timestamp: number;
+    seasonId: SeasonId;
+    metadata?: Record<string, unknown>;
+}
+/** Season info */
+export interface Season {
+    id: SeasonId;
+    name: string;
+    startDate: number;
+    endDate: number;
+    isActive: boolean;
+    softResetPercentage: number;
+    placementGames: number;
+    rewards: SeasonReward[];
+    config: SeasonConfig;
+}
+/** Season config */
+export interface SeasonConfig {
+    decayEnabled: boolean;
+    decayStartDays: number;
+    decayRatePerDay: number;
+    decayMinRating: number;
+    decayFloorTier: RankTier;
+    rankProtectionGames: number;
+    promoGames: number;
+    demotionProtection: number;
+}
+/** Season reward */
+export interface SeasonReward {
+    tier: RankTier;
+    minDivision?: RankDivision;
+    rewards: {
+        type: string;
+        id: string;
+        name: string;
+        quantity?: number;
+    }[];
+}
+/** Rating calculation result */
+export interface RatingCalculation {
+    newRating: number;
+    ratingChange: number;
+    newDeviation?: number;
+    newVolatility?: number;
+    newTier: RankTier;
+    newDivision: RankDivision;
+    promotion: boolean;
+    demotion: boolean;
+    streakBonus: number;
+    placementMultiplier: number;
+}
+/** Leaderboard entry */
+export interface LeaderboardEntry {
+    rank: number;
+    playerId: PlayerId;
+    playerName?: string;
+    rating: number;
+    tier: RankTier;
+    division: RankDivision;
+    wins: number;
+    losses: number;
+    winRate: number;
+    region?: string;
+}
+/** Matchmaking bracket */
+export interface SkillBracket {
+    id: string;
+    name: string;
+    minRating: number;
+    maxRating: number;
+    averageQueueTime?: number;
+    playerCount?: number;
+}
+/** Team/Group ranking */
+export interface TeamRanking {
+    teamId: string;
+    name: string;
+    rating: number;
+    tier: RankTier;
+    division: RankDivision;
+    members: PlayerId[];
+    wins: number;
+    losses: number;
+    seasonId: SeasonId;
+}
+/** Ranking statistics */
+export interface RankingStatistics {
+    totalPlayers: number;
+    rankedPlayers: number;
+    averageRating: number;
+    medianRating: number;
+    tierDistribution: Record<RankTier, number>;
+    matchesPlayed: number;
+    activePlayers: number;
+}
+/** Ranking event types */
+export type RankingEventType = 'rating_changed' | 'tier_changed' | 'division_changed' | 'promoted' | 'demoted' | 'placement_completed' | 'placement_match' | 'win_streak' | 'loss_streak' | 'peak_rating' | 'decay_warning' | 'decay_applied' | 'season_started' | 'season_ended' | 'season_reset' | 'rewards_granted' | 'leaderboard_updated';
+/** Ranking event data */
+export interface RankingEvent {
+    type: RankingEventType;
+    timestamp: number;
+    playerId?: PlayerId;
+    data?: unknown;
+}
+/** Ranking event callback */
+export type RankingEventCallback = (event: RankingEvent) => void;
+/** Ranking system configuration */
+export interface RankingConfig {
+    algorithm: RankingAlgorithm;
+    initialRating: number;
+    initialDeviation: number;
+    initialVolatility: number;
+    kFactor: number;
+    minRating: number;
+    maxRating: number;
+    streakBonusThreshold: number;
+    streakBonusMultiplier: number;
+    maxStreakBonus: number;
+    placementMultiplier: number;
+    drawRatingChange: number;
+    regionEnabled: boolean;
+    teamRankingEnabled: boolean;
+}
+/** Default configuration */
+export declare const DEFAULT_RANKING_CONFIG: RankingConfig;
+/** Default tier configuration */
+export declare const DEFAULT_TIER_CONFIG: TierConfig[];
+/**
+ * Ranking and tier system
+ */
+export declare class NiceRanking extends EventEmitter {
+    private config;
+    private tierConfigs;
+    private rankings;
+    private matches;
+    private seasons;
+    private currentSeason?;
+    private teamRankings;
+    private brackets;
+    private decayInterval?;
+    constructor(config?: Partial<RankingConfig>, tierConfigs?: TierConfig[]);
+    /**
+     * Emit ranking event
+     */
+    private emitEvent;
+    /**
+     * Initialize skill brackets
+     */
+    private initializeBrackets;
+    /**
+     * Load state
+     */
+    private loadState;
+    /**
+     * Save state
+     */
+    private saveState;
+    /**
+     * Create season
+     */
+    createSeason(name: string, startDate: number, endDate: number, config?: Partial<SeasonConfig>): Season;
+    /**
+     * Start season
+     */
+    startSeason(seasonId: SeasonId): boolean;
+    /**
+     * End season
+     */
+    endSeason(seasonId: SeasonId): boolean;
+    /**
+     * Generate default season rewards
+     */
+    private generateDefaultSeasonRewards;
+    /**
+     * Grant season rewards
+     */
+    private grantSeasonRewards;
+    /**
+     * Get tier index
+     */
+    private getTierIndex;
+    /**
+     * Get current season
+     */
+    getCurrentSeason(): Season | undefined;
+    /**
+     * Get season
+     */
+    getSeason(seasonId: SeasonId): Season | undefined;
+    /**
+     * Start decay check
+     */
+    private startDecayCheck;
+    /**
+     * Process decay
+     */
+    private processDecay;
+    /**
+     * Register player
+     */
+    registerPlayer(playerId: PlayerId, region?: string): PlayerRanking;
+    /**
+     * Get player ranking
+     */
+    getPlayerRanking(playerId: PlayerId): PlayerRanking | undefined;
+    /**
+     * Record match
+     */
+    recordMatch(playerId: PlayerId, opponentId: PlayerId | undefined, result: MatchResult, metadata?: Record<string, unknown>): RatingCalculation | undefined;
+    /**
+     * Calculate rating change
+     */
+    private calculateRating;
+    /**
+     * Calculate ELO
+     */
+    private calculateElo;
+    /**
+     * Calculate Glicko-2
+     */
+    private calculateGlicko2;
+    /**
+     * Calculate MMR (simpler rating)
+     */
+    private calculateMMR;
+    /**
+     * Get tier from rating
+     */
+    getTierFromRating(rating: number): {
+        tier: RankTier;
+        division: RankDivision;
+    };
+    /**
+     * Get tier config
+     */
+    getTierConfig(tier: RankTier): TierConfig | undefined;
+    /**
+     * Get all tier configs
+     */
+    getAllTierConfigs(): TierConfig[];
+    /**
+     * Check if promotion
+     */
+    private isPromotion;
+    /**
+     * Check if demotion
+     */
+    private isDemotion;
+    /**
+     * Get leaderboard
+     */
+    getLeaderboard(options?: {
+        limit?: number;
+        offset?: number;
+        region?: string;
+        tier?: RankTier;
+        seasonId?: SeasonId;
+    }): LeaderboardEntry[];
+    /**
+     * Get player rank position
+     */
+    getPlayerRankPosition(playerId: PlayerId): number;
+    /**
+     * Update percentiles
+     */
+    private updatePercentiles;
+    /**
+     * Get match history
+     */
+    getMatchHistory(playerId: PlayerId, limit?: number): MatchRecord[];
+    /**
+     * Get skill bracket for rating
+     */
+    getSkillBracket(rating: number): SkillBracket | undefined;
+    /**
+     * Get all brackets
+     */
+    getAllBrackets(): SkillBracket[];
+    /**
+     * Get ranking statistics
+     */
+    getStatistics(): RankingStatistics;
+    /**
+     * Load from storage
+     */
+    private loadFromStorage;
+    /**
+     * Save to storage
+     */
+    private saveToStorage;
+    /**
+     * Destroy ranking system
+     */
+    destroy(): void;
+}
+/**
+ * Create ranking system instance
+ */
+export declare function createRankingSystem(config?: Partial<RankingConfig>, tierConfigs?: TierConfig[]): NiceRanking;
+export default NiceRanking;