@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,150 +0,0 @@
-export type MarriageId = string;
-export type PartnerId = string;
-export type CeremonyId = string;
-export type MarriageStatus = 'pending' | 'engaged' | 'married' | 'separated' | 'divorced';
-export type ProposalStatus = 'pending' | 'accepted' | 'declined' | 'expired';
-export interface Proposal {
-    id: string;
-    proposerId: PartnerId;
-    targetId: PartnerId;
-    status: ProposalStatus;
-    message?: string;
-    ringId?: string;
-    createdAt: number;
-    respondedAt?: number;
-    expiresAt: number;
-}
-export interface Marriage {
-    id: MarriageId;
-    partner1Id: PartnerId;
-    partner2Id: PartnerId;
-    status: MarriageStatus;
-    engagedAt?: number;
-    marriedAt?: number;
-    separatedAt?: number;
-    divorcedAt?: number;
-    sharedInventoryEnabled: boolean;
-    sharedCurrencyEnabled: boolean;
-    sharedCurrency: Record<string, number>;
-    experienceShared: number;
-    questsCompletedTogether: number;
-    anniversariesCelebrated: number;
-    teleportsUsed: number;
-    activeBenefits: string[];
-    benefitLevel: number;
-    title?: string;
-    ringStyles?: [string, string];
-    homeId?: string;
-}
-export interface CeremonyVenue {
-    id: string;
-    name: string;
-    description: string;
-    capacity: number;
-    cost: number;
-    currency: string;
-    imageUrl?: string;
-    features: string[];
-}
-export interface Ceremony {
-    id: CeremonyId;
-    marriageId: MarriageId;
-    venueId: string;
-    scheduledAt: number;
-    duration: number;
-    status: 'scheduled' | 'in-progress' | 'completed' | 'cancelled';
-    invitedGuests: PartnerId[];
-    attendedGuests: PartnerId[];
-    gifts: Array<{
-        fromId: PartnerId;
-        itemId: string;
-        quantity: number;
-    }>;
-    startedAt?: number;
-    completedAt?: number;
-}
-export interface MarriageBenefit {
-    id: string;
-    name: string;
-    description: string;
-    requiredLevel: number;
-    effects: Array<{
-        type: 'stat_bonus' | 'xp_share' | 'teleport' | 'buff' | 'discount' | 'custom';
-        statId?: string;
-        value: number;
-        percentage?: boolean;
-    }>;
-}
-export type MarriageEventType = 'proposal-sent' | 'proposal-accepted' | 'proposal-declined' | 'proposal-expired' | 'engaged' | 'ceremony-scheduled' | 'ceremony-started' | 'ceremony-completed' | 'married' | 'anniversary' | 'benefit-unlocked' | 'teleport-used' | 'currency-deposited' | 'currency-withdrawn' | 'separation-requested' | 'separated' | 'divorce-finalized';
-export interface MarriageEvent {
-    type: MarriageEventType;
-    timestamp: number;
-    marriageId?: MarriageId;
-    partnerId?: PartnerId;
-    data?: unknown;
-}
-export type MarriageEventCallback = (event: MarriageEvent) => void;
-export interface MarriageConfig {
-    proposalDuration: number;
-    engagementDuration: number;
-    separationCooldown: number;
-    divorceWaitPeriod: number;
-    maxTeleportsPerDay: number;
-    xpSharePercentage: number;
-    anniversaryInterval: number;
-    benefitLevelXpRequired: number[];
-    storageKey: string;
-}
-export declare const DEFAULT_MARRIAGE_CONFIG: MarriageConfig;
-export declare class NiceMarriage {
-    private config;
-    private marriages;
-    private proposals;
-    private ceremonies;
-    private venues;
-    private benefits;
-    private playerMarriage;
-    private playerProposals;
-    private dailyTeleports;
-    private eventListeners;
-    private idCounter;
-    constructor(config?: Partial<MarriageConfig>);
-    on(event: MarriageEventType, callback: MarriageEventCallback): () => void;
-    private emit;
-    registerVenue(venue: CeremonyVenue): void;
-    registerBenefit(benefit: MarriageBenefit): void;
-    propose(proposerId: PartnerId, targetId: PartnerId, message?: string, ringId?: string): Proposal | null;
-    acceptProposal(proposalId: string): Marriage | null;
-    declineProposal(proposalId: string): boolean;
-    getProposalsFor(playerId: PartnerId): Proposal[];
-    private createMarriage;
-    scheduleCeremony(marriageId: MarriageId, venueId: string, scheduledAt: number, invitedGuests?: PartnerId[]): Ceremony | null;
-    startCeremony(ceremonyId: CeremonyId): boolean;
-    attendCeremony(ceremonyId: CeremonyId, guestId: PartnerId): boolean;
-    giveWeddingGift(ceremonyId: CeremonyId, fromId: PartnerId, itemId: string, quantity: number): boolean;
-    completeCeremony(ceremonyId: CeremonyId): boolean;
-    private updateBenefits;
-    addMarriageXp(marriageId: MarriageId, xp: number): void;
-    getActiveBenefits(marriageId: MarriageId): MarriageBenefit[];
-    teleportToPartner(playerId: PartnerId): boolean;
-    enableSharedCurrency(marriageId: MarriageId): boolean;
-    depositCurrency(marriageId: MarriageId, currency: string, amount: number): boolean;
-    withdrawCurrency(marriageId: MarriageId, currency: string, amount: number): boolean;
-    getSharedCurrency(marriageId: MarriageId): Record<string, number>;
-    checkAnniversary(marriageId: MarriageId): boolean;
-    requestSeparation(marriageId: MarriageId, requesterId: PartnerId): boolean;
-    separate(marriageId: MarriageId): boolean;
-    divorce(marriageId: MarriageId): boolean;
-    getMarriage(marriageId: MarriageId): Marriage | undefined;
-    getMarriageForPlayer(playerId: PartnerId): Marriage | undefined;
-    getPartner(playerId: PartnerId): PartnerId | undefined;
-    isMarried(playerId: PartnerId): boolean;
-    getVenue(venueId: string): CeremonyVenue | undefined;
-    getAllVenues(): CeremonyVenue[];
-    getCeremony(ceremonyId: CeremonyId): Ceremony | undefined;
-    private save;
-    private load;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createMarriageSystem(config?: Partial<MarriageConfig>): NiceMarriage;

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

@@ -1,171 +0,0 @@
-export type MasteryId = string;
-export type SpecializationId = string;
-export type MasteryTierId = string;
-export type MasteryCategory = 'weapon' | 'skill' | 'magic' | 'crafting' | 'combat' | 'survival' | 'class';
-export interface MasteryDefinition {
-    id: MasteryId;
-    name: string;
-    description: string;
-    category: MasteryCategory;
-    maxLevel: number;
-    xpPerLevel: number[];
-    xpScaling: number;
-    tiers: MasteryTier[];
-    requiredLevel?: number;
-    requiredMasteries?: Record<MasteryId, number>;
-    icon: string;
-    color?: string;
-    tags?: string[];
-}
-export interface MasteryTier {
-    id: MasteryTierId;
-    name: string;
-    level: number;
-    bonuses: MasteryBonus[];
-    unlocksAbility?: string;
-    unlocksPassive?: string;
-    badge?: string;
-    title?: string;
-}
-export interface MasteryBonus {
-    type: 'stat' | 'damage' | 'crit' | 'speed' | 'resource' | 'cooldown' | 'proc' | 'custom';
-    value: number;
-    isPercentage: boolean;
-    perLevel?: boolean;
-    stat?: string;
-    damageType?: string;
-    abilityId?: string;
-    description: string;
-}
-export interface SpecializationDefinition {
-    id: SpecializationId;
-    name: string;
-    description: string;
-    lore?: string;
-    requiredMastery: MasteryId;
-    requiredMasteryLevel: number;
-    bonuses: MasteryBonus[];
-    passiveEffects: PassiveEffect[];
-    grantedAbilities: string[];
-    modifiedAbilities: AbilityModification[];
-    exclusiveWith?: SpecializationId[];
-    icon: string;
-    color?: string;
-    particleEffect?: string;
-}
-export interface PassiveEffect {
-    id: string;
-    name: string;
-    description: string;
-    trigger: 'always' | 'on_hit' | 'on_crit' | 'on_kill' | 'on_damage_taken' | 'low_health' | 'full_health';
-    chance?: number;
-    cooldown?: number;
-    effect: MasteryBonus;
-}
-export interface AbilityModification {
-    abilityId: string;
-    modifications: {
-        type: 'damage' | 'cost' | 'cooldown' | 'range' | 'effect';
-        value: number;
-        isPercentage: boolean;
-    }[];
-}
-export interface PlayerMasteryData {
-    playerId: string;
-    masteries: Map<MasteryId, MasteryProgress>;
-    activeSpecializations: Set<SpecializationId>;
-    maxSpecializations: number;
-    totalBonuses: Map<string, number>;
-    totalMasteryLevels: number;
-    maxMasteryReached: Map<MasteryId, number>;
-    timeInMasteries: Map<MasteryId, number>;
-}
-export interface MasteryProgress {
-    masteryId: MasteryId;
-    level: number;
-    currentXP: number;
-    totalXP: number;
-    highestTierReached: MasteryTierId;
-    timesUsed: number;
-    lastUsed: number;
-}
-export interface MasteryEffect {
-    stat: string;
-    flatBonus: number;
-    percentBonus: number;
-}
-export type MasteryEventType = 'mastery-xp-gained' | 'mastery-level-up' | 'mastery-tier-unlocked' | 'mastery-maxed' | 'specialization-chosen' | 'specialization-removed' | 'ability-unlocked' | 'passive-triggered';
-export interface MasteryEvent {
-    type: MasteryEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type MasteryEventCallback = (event: MasteryEvent) => void;
-export interface MasteryConfig {
-    maxSpecializations: number;
-    baseXPPerLevel: number;
-    xpScalingDefault: number;
-    xpBonusPerPlayerLevel: number;
-    storageKey: string;
-}
-export declare const DEFAULT_MASTERY_CONFIG: MasteryConfig;
-export declare class NiceMastery {
-    private config;
-    private masteries;
-    private specializations;
-    private players;
-    private eventListeners;
-    constructor(config?: Partial<MasteryConfig>);
-    on(event: MasteryEventType, callback: MasteryEventCallback): () => void;
-    private emit;
-    registerMastery(mastery: MasteryDefinition): void;
-    registerSpecialization(spec: SpecializationDefinition): void;
-    getPlayer(playerId: string): PlayerMasteryData;
-    private createPlayerData;
-    addMasteryXP(playerId: string, masteryId: MasteryId, xp: number, playerLevel?: number): {
-        levelsGained: number;
-        tiersUnlocked: MasteryTier[];
-    };
-    private getXPForLevel;
-    canChooseSpecialization(playerId: string, specId: SpecializationId): boolean;
-    chooseSpecialization(playerId: string, specId: SpecializationId): boolean;
-    removeSpecialization(playerId: string, specId: SpecializationId): boolean;
-    private recalculateBonuses;
-    private applyBonus;
-    getMastery(id: MasteryId): MasteryDefinition | undefined;
-    getAllMasteries(): MasteryDefinition[];
-    getMasteriesByCategory(category: MasteryCategory): MasteryDefinition[];
-    getSpecialization(id: SpecializationId): SpecializationDefinition | undefined;
-    getAllSpecializations(): SpecializationDefinition[];
-    getAvailableSpecializations(playerId: string): SpecializationDefinition[];
-    getMasteryProgress(playerId: string, masteryId: MasteryId): MasteryProgress | undefined;
-    getMasteryLevel(playerId: string, masteryId: MasteryId): number;
-    getMasteryXPProgress(playerId: string, masteryId: MasteryId): {
-        level: number;
-        currentXP: number;
-        xpNeeded: number;
-        percentage: number;
-    };
-    getActiveSpecializations(playerId: string): SpecializationDefinition[];
-    getUnlockedAbilities(playerId: string): string[];
-    getUnlockedPassives(playerId: string): string[];
-    getEffectiveBonuses(playerId: string): Map<string, number>;
-    getStatBonus(playerId: string, stat: string): number;
-    getDamageBonus(playerId: string, damageType?: string): number;
-    getCooldownReduction(playerId: string, abilityId?: string): number;
-    getStats(playerId: string): {
-        totalMasteryLevels: number;
-        highestMastery: {
-            id: MasteryId;
-            level: number;
-        } | null;
-        activeSpecCount: number;
-        unlockedAbilitiesCount: number;
-        maxedMasteries: number;
-    };
-    save(): void;
-    load(): void;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createMasterySystem(config?: Partial<MasteryConfig>): NiceMastery;

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

@@ -1,196 +0,0 @@
-export type PlayerId = string;
-export type LobbyId = string;
-export type MatchId = string;
-export type PartyId = string;
-export interface MatchPlayer {
-    id: PlayerId;
-    displayName: string;
-    skillRating: number;
-    level?: number;
-    connectionQuality?: number;
-    region?: string;
-    partyId?: PartyId;
-    isReady: boolean;
-    team?: number;
-    slot?: number;
-    joinedAt: number;
-    customData?: Record<string, unknown>;
-}
-export interface QueueEntry {
-    playerId: PlayerId;
-    partyId?: PartyId;
-    partyMembers?: PlayerId[];
-    skillRating: number;
-    joinedAt: number;
-    searchParams: SearchParams;
-    expandedSkillRange: number;
-    priority: number;
-}
-export interface SearchParams {
-    gameMode: string;
-    region?: string;
-    mapPreferences?: string[];
-    teamSize?: number;
-    allowBackfill?: boolean;
-    customFilters?: Record<string, unknown>;
-}
-export interface Party {
-    id: PartyId;
-    leaderId: PlayerId;
-    members: PlayerId[];
-    maxSize: number;
-    createdAt: number;
-    isPublic: boolean;
-    invitedPlayers: Set<PlayerId>;
-    averageSkill: number;
-}
-export interface Lobby {
-    id: LobbyId;
-    hostId: PlayerId;
-    players: Map<PlayerId, MatchPlayer>;
-    maxPlayers: number;
-    minPlayers: number;
-    gameMode: string;
-    mapId?: string;
-    settings: LobbySettings;
-    state: LobbyState;
-    teams: LobbyTeam[];
-    createdAt: number;
-    readyCheckStartedAt?: number;
-    readyCheckTimeout: number;
-    isPublic: boolean;
-    password?: string;
-    region: string;
-    averageSkill: number;
-}
-export type LobbyState = 'waiting' | 'ready-check' | 'starting' | 'in-game' | 'post-game' | 'closed';
-export interface LobbySettings {
-    allowSpectators: boolean;
-    autoTeamBalance: boolean;
-    friendlyFire: boolean;
-    maxRounds?: number;
-    timeLimit?: number;
-    scoreLimit?: number;
-    customSettings: Record<string, unknown>;
-}
-export interface LobbyTeam {
-    id: number;
-    name: string;
-    maxPlayers: number;
-    players: PlayerId[];
-    color?: string;
-}
-export interface Match {
-    id: MatchId;
-    lobbyId: LobbyId;
-    players: MatchPlayer[];
-    gameMode: string;
-    mapId: string;
-    region: string;
-    teams: LobbyTeam[];
-    startedAt: number;
-    endedAt?: number;
-    state: MatchState;
-    serverInfo?: ServerInfo;
-}
-export type MatchState = 'initializing' | 'loading' | 'running' | 'paused' | 'ending' | 'completed' | 'cancelled';
-export interface ServerInfo {
-    address: string;
-    port: number;
-    token?: string;
-    region: string;
-}
-export type MatchEventType = 'queue-joined' | 'queue-left' | 'queue-updated' | 'match-found' | 'lobby-created' | 'lobby-joined' | 'lobby-left' | 'lobby-closed' | 'player-joined' | 'player-left' | 'player-ready' | 'player-unready' | 'team-changed' | 'host-changed' | 'settings-changed' | 'ready-check-started' | 'ready-check-passed' | 'ready-check-failed' | 'match-starting' | 'match-started' | 'match-ended' | 'party-created' | 'party-joined' | 'party-left' | 'party-disbanded';
-export interface MatchEvent {
-    type: MatchEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type MatchEventCallback = (event: MatchEvent) => void;
-export interface MatchConfig {
-    /** Default skill range for matching */
-    initialSkillRange: number;
-    /** Skill range expansion per second */
-    skillRangeExpansion: number;
-    /** Max skill range */
-    maxSkillRange: number;
-    /** Ready check timeout (seconds) */
-    readyCheckTimeout: number;
-    /** Max queue time before priority boost (seconds) */
-    maxQueueTime: number;
-    /** Min players to start */
-    minPlayersToStart: number;
-    /** Enable backfill */
-    enableBackfill: boolean;
-    /** Max party size */
-    maxPartySize: number;
-    /** Auto-balance teams */
-    autoBalanceTeams: boolean;
-    /** Match tick interval (ms) */
-    tickInterval: number;
-}
-export declare const DEFAULT_MATCH_CONFIG: MatchConfig;
-export declare class NiceMatch {
-    private config;
-    private players;
-    private queue;
-    private parties;
-    private playerToParty;
-    private lobbies;
-    private matches;
-    private playerToLobby;
-    private idCounter;
-    private tickTimer?;
-    private eventListeners;
-    constructor(config?: Partial<MatchConfig>);
-    on(event: MatchEventType, callback: MatchEventCallback): () => void;
-    private emit;
-    registerPlayer(player: MatchPlayer): void;
-    unregisterPlayer(playerId: PlayerId): void;
-    getPlayer(playerId: PlayerId): MatchPlayer | undefined;
-    joinQueue(playerId: PlayerId, searchParams: SearchParams): boolean;
-    leaveQueue(playerId: PlayerId): void;
-    isInQueue(playerId: PlayerId): boolean;
-    getQueuePosition(playerId: PlayerId): number;
-    getQueueStats(): {
-        total: number;
-        byMode: Record<string, number>;
-    };
-    startMatchmaking(): void;
-    stopMatchmaking(): void;
-    private processQueue;
-    private attemptMatch;
-    private createMatchFromQueue;
-    createParty(leaderId: PlayerId): PartyId | null;
-    inviteToParty(partyId: PartyId, inviterId: PlayerId, inviteeId: PlayerId): boolean;
-    joinParty(playerId: PlayerId, partyId: PartyId): boolean;
-    leaveParty(playerId: PlayerId): void;
-    private recalculatePartySkill;
-    getParty(partyId: PartyId): Party | undefined;
-    getPlayerParty(playerId: PlayerId): Party | undefined;
-    createLobby(hostId: PlayerId, options: {
-        gameMode: string;
-        maxPlayers?: number;
-        minPlayers?: number;
-        isPublic?: boolean;
-        password?: string;
-        settings?: Partial<LobbySettings>;
-        teamCount?: number;
-    }): LobbyId | null;
-    joinLobby(playerId: PlayerId, lobbyId: LobbyId, password?: string): boolean;
-    leaveLobby(playerId: PlayerId): void;
-    closeLobby(lobbyId: LobbyId): void;
-    private recalculateLobbySkill;
-    setReady(playerId: PlayerId, ready: boolean): void;
-    startReadyCheck(lobbyId: LobbyId): boolean;
-    private checkReadyStatus;
-    changeTeam(playerId: PlayerId, newTeam: number): boolean;
-    startMatch(lobbyId: LobbyId): MatchId | null;
-    endMatch(matchId: MatchId): void;
-    getMatch(matchId: MatchId): Match | undefined;
-    getLobby(lobbyId: LobbyId): Lobby | undefined;
-    getPlayerLobby(playerId: PlayerId): Lobby | undefined;
-    getPublicLobbies(): Lobby[];
-    destroy(): void;
-}
-export declare function createMatchSystem(config?: Partial<MatchConfig>): NiceMatch;

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

@@ -1,118 +0,0 @@
-export type GemType = 'red' | 'blue' | 'green' | 'yellow' | 'purple' | 'orange' | 'wild';
-export type SpecialType = 'normal' | 'horizontal' | 'vertical' | 'bomb' | 'color' | 'lightning';
-export interface Position {
-    row: number;
-    col: number;
-}
-export interface Gem {
-    id: string;
-    type: GemType;
-    special: SpecialType;
-    position: Position;
-    isMatched: boolean;
-    isMoving: boolean;
-    isFalling: boolean;
-    targetPosition?: Position;
-    metadata?: Record<string, unknown>;
-}
-export interface Match {
-    id: string;
-    gems: Gem[];
-    type: GemType;
-    length: number;
-    isHorizontal: boolean;
-    isVertical: boolean;
-    spawnsSpecial?: SpecialType;
-    score: number;
-}
-export interface Board {
-    width: number;
-    height: number;
-    grid: (Gem | null)[][];
-    moveCount: number;
-    score: number;
-    combo: number;
-    maxCombo: number;
-}
-export type ObjectiveType = 'score' | 'collect' | 'clear' | 'moves';
-export interface Objective {
-    id: string;
-    type: ObjectiveType;
-    target: number;
-    current: number;
-    gemType?: GemType;
-    specialType?: SpecialType;
-    isComplete: boolean;
-}
-export type Match3EventType = 'swap' | 'swap-fail' | 'match' | 'cascade' | 'gem-destroy' | 'gem-spawn' | 'gem-fall' | 'special-create' | 'special-activate' | 'combo' | 'objective-progress' | 'objective-complete' | 'level-complete' | 'game-over';
-export interface Match3Event {
-    type: Match3EventType;
-    timestamp: number;
-    data: unknown;
-}
-export type Match3EventCallback = (event: Match3Event) => void;
-export interface Match3Config {
-    /** Board width */
-    width: number;
-    /** Board height */
-    height: number;
-    /** Minimum match length */
-    minMatchLength: number;
-    /** Available gem types */
-    gemTypes: GemType[];
-    /** Score per gem */
-    scorePerGem: number;
-    /** Cascade multiplier */
-    cascadeMultiplier: number;
-    /** Match 4 creates special */
-    match4Special: SpecialType;
-    /** Match 5 creates special */
-    match5Special: SpecialType;
-    /** L/T match creates special */
-    lMatchSpecial: SpecialType;
-    /** Animation time for swapping (ms) */
-    swapTime: number;
-    /** Animation time for falling (ms) */
-    fallTime: number;
-}
-export declare const DEFAULT_MATCH3_CONFIG: Match3Config;
-export declare class NiceMatch3 {
-    private config;
-    private board;
-    private objectives;
-    private isProcessing;
-    private eventListeners;
-    private nextId;
-    constructor(config?: Partial<Match3Config>);
-    on(event: Match3EventType, callback: Match3EventCallback): () => void;
-    private emit;
-    createBoard(): Board;
-    private createGem;
-    private resolveInitialMatches;
-    getBoard(): Board | null;
-    getGem(row: number, col: number): Gem | null;
-    canSwap(pos1: Position, pos2: Position): boolean;
-    swap(pos1: Position, pos2: Position): Promise<boolean>;
-    private findAllMatches;
-    private createMatch;
-    private processMatches;
-    private removeMatchedGems;
-    private applyGravity;
-    private fillEmptySpaces;
-    activateSpecial(position: Position): Gem[];
-    setObjectives(objectives: Omit<Objective, 'current' | 'isComplete'>[]): void;
-    private updateObjectives;
-    private checkObjectives;
-    getObjectives(): Objective[];
-    findHint(): [Position, Position] | null;
-    private wouldCreateMatch;
-    private hasMatchAt;
-    shuffle(): void;
-    getScore(): number;
-    getCombo(): number;
-    getMaxCombo(): number;
-    getMoveCount(): number;
-    hasPossibleMoves(): boolean;
-    destroy(): void;
-}
-export declare function createMatch3System(config?: Partial<Match3Config>): NiceMatch3;