@nice2dev/game-engine 1.1.5 → 1.1.6

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

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

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

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

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