@nice2dev/game-engine 1.0.28 → 1.1.6

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

@@ -0,0 +1,168 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type PartyId = string;
+export type InviteId = string;
+export type QueueId = string;
+export type PartyType = 'party' | 'raid' | 'instance' | 'custom';
+export type PartyRole = 'leader' | 'assistant' | 'member';
+export type LootRule = 'free_for_all' | 'round_robin' | 'master_loot' | 'need_before_greed' | 'group_loot';
+export type QualityThreshold = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+export interface LootSettings {
+    rule: LootRule;
+    qualityThreshold: QualityThreshold;
+    master?: EntityId;
+    roundRobinIndex?: number;
+}
+export interface PartyMember {
+    entityId: EntityId;
+    role: PartyRole;
+    joinedAt: number;
+    groupNumber: number;
+    isOnline: boolean;
+    isReady: boolean;
+    class?: string;
+    specialization?: string;
+}
+export interface Party {
+    id: PartyId;
+    type: PartyType;
+    leaderId: EntityId;
+    members: Map<EntityId, PartyMember>;
+    maxSize: number;
+    groupCount: number;
+    lootSettings: LootSettings;
+    isPrivate: boolean;
+    name?: string;
+    instanceId?: string;
+    readyCheckActive: boolean;
+    readyCheckResponses: Map<EntityId, boolean>;
+    createdAt: number;
+}
+export interface PartyInvitation {
+    id: InviteId;
+    partyId: PartyId;
+    inviterId: EntityId;
+    inviteeId: EntityId;
+    createdAt: number;
+    expiresAt: number;
+}
+export type GroupFinderRole = 'tank' | 'healer' | 'damage' | 'support' | 'any';
+export interface GroupFinderListing {
+    id: string;
+    partyId?: PartyId;
+    leaderId: EntityId;
+    activityId: string;
+    activityName: string;
+    description: string;
+    requiredRoles: {
+        role: GroupFinderRole;
+        count: number;
+    }[];
+    filledRoles: {
+        role: GroupFinderRole;
+        entityIds: EntityId[];
+    }[];
+    minLevel?: number;
+    maxLevel?: number;
+    minItemLevel?: number;
+    isAutoAccept: boolean;
+    createdAt: number;
+}
+export interface GroupFinderApplication {
+    id: string;
+    listingId: string;
+    applicantId: EntityId;
+    role: GroupFinderRole;
+    message: string;
+    createdAt: number;
+}
+export interface QueueEntry {
+    id: QueueId;
+    entityId: EntityId;
+    partyId?: PartyId;
+    activityIds: string[];
+    roles: GroupFinderRole[];
+    queuedAt: number;
+    estimatedWait?: number;
+}
+export type PartyEventType = 'party-created' | 'party-disbanded' | 'member-joined' | 'member-left' | 'member-kicked' | 'leader-changed' | 'role-changed' | 'loot-settings-changed' | 'loot-rolled' | 'loot-distributed' | 'ready-check-started' | 'ready-check-response' | 'ready-check-completed' | 'converted-to-raid' | 'group-finder-listed' | 'group-finder-application' | 'queue-joined' | 'queue-popped' | 'party-message';
+export interface PartyEvent {
+    type: PartyEventType;
+    partyId?: PartyId;
+    entityId?: EntityId;
+    data?: Record<string, unknown>;
+}
+export interface PartySystemConfig {
+    maxPartySize?: number;
+    maxRaidSize?: number;
+    maxRaidGroups?: number;
+    invitationExpiryMs?: number;
+    readyCheckTimeoutMs?: number;
+    queueTimeoutMs?: number;
+    groupFinderRefreshMs?: number;
+}
+export declare const DEFAULT_PARTY_CONFIG: PartySystemConfig;
+export declare class NiceParty extends EventEmitter {
+    private parties;
+    private invitations;
+    private entityToParty;
+    private groupListings;
+    private applications;
+    private queues;
+    private entityQueue;
+    private nextPartyId;
+    private config;
+    constructor(config?: Partial<PartySystemConfig>);
+    createParty(leaderId: EntityId, type?: PartyType, name?: string): PartyId | null;
+    disbandParty(partyId: PartyId, disbanderId: EntityId): boolean;
+    invite(inviterId: EntityId, inviteeId: EntityId): InviteId | null;
+    acceptInvitation(inviteId: InviteId): boolean;
+    declineInvitation(inviteId: InviteId): void;
+    private findAvailableGroup;
+    leave(entityId: EntityId): boolean;
+    kick(kickerId: EntityId, targetId: EntityId): boolean;
+    setLeader(partyId: PartyId, requesterId: EntityId, newLeaderId: EntityId): boolean;
+    setRole(partyId: PartyId, requesterId: EntityId, targetId: EntityId, role: PartyRole): boolean;
+    setGroup(partyId: PartyId, requesterId: EntityId, targetId: EntityId, groupNumber: number): boolean;
+    setLootRule(partyId: PartyId, requesterId: EntityId, rule: LootRule, master?: EntityId): boolean;
+    setLootThreshold(partyId: PartyId, requesterId: EntityId, threshold: QualityThreshold): boolean;
+    distributeLoot(partyId: PartyId, itemId: string, recipients?: EntityId[]): EntityId | null;
+    startReadyCheck(partyId: PartyId, initiatorId: EntityId): boolean;
+    respondReadyCheck(partyId: PartyId, entityId: EntityId, isReady: boolean): boolean;
+    private completeReadyCheck;
+    convertToRaid(partyId: PartyId, requesterId: EntityId): boolean;
+    createListing(leaderId: EntityId, activityId: string, activityName: string, options?: {
+        description?: string;
+        requiredRoles?: {
+            role: GroupFinderRole;
+            count: number;
+        }[];
+        minLevel?: number;
+        maxLevel?: number;
+        minItemLevel?: number;
+        isAutoAccept?: boolean;
+    }): string | null;
+    applyToListing(listingId: string, applicantId: EntityId, role: GroupFinderRole, message?: string): boolean;
+    acceptApplication(applicationId: string, accepterId: EntityId): boolean;
+    declineApplication(applicationId: string, declinerId: EntityId): boolean;
+    removeListing(listingId: string): void;
+    searchListings(activityId?: string, options?: {
+        minLevel?: number;
+        maxLevel?: number;
+        hasRole?: GroupFinderRole;
+    }): GroupFinderListing[];
+    joinQueue(entityId: EntityId, activityIds: string[], roles: GroupFinderRole[]): QueueId | null;
+    leaveQueue(entityId: EntityId): boolean;
+    getQueuePosition(entityId: EntityId): number;
+    getParty(id: PartyId): Party | undefined;
+    getEntityParty(entityId: EntityId): Party | undefined;
+    getPartyMembers(partyId: PartyId): PartyMember[];
+    isInParty(entityId: EntityId): boolean;
+    isLeader(entityId: EntityId): boolean;
+    getInvitationsFor(entityId: EntityId): PartyInvitation[];
+    getApplicationsForListing(listingId: string): GroupFinderApplication[];
+    sendMessage(senderId: EntityId, message: string): void;
+    setOnlineStatus(entityId: EntityId, isOnline: boolean): void;
+}
+export declare function createPartySystem(config?: Partial<PartySystemConfig>): NiceParty;
+export default NiceParty;

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

@@ -0,0 +1,144 @@
+import { EventEmitter } from 'events';
+export type MetricId = string;
+export type TimerId = string;
+export interface FrameMetrics {
+    fps: number;
+    frameTime: number;
+    deltaTime: number;
+    frameNumber: number;
+    timestamp: number;
+    jitter: number;
+    dropped: number;
+}
+export interface TimingMetrics {
+    min: number;
+    max: number;
+    avg: number;
+    median: number;
+    p95: number;
+    p99: number;
+    total: number;
+    count: number;
+}
+export interface MemoryMetrics {
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+    usage: number;
+}
+export interface GPUMetrics {
+    drawCalls: number;
+    triangles: number;
+    vertices: number;
+    textureMemory: number;
+    shaderSwitches: number;
+    stateChanges: number;
+}
+export interface PerformanceBudget {
+    maxFrameTime: number;
+    targetFPS: number;
+    maxMemory: number;
+    maxDrawCalls: number;
+    maxTriangles: number;
+    customBudgets?: Record<MetricId, number>;
+}
+export interface BudgetViolation {
+    metric: MetricId;
+    budget: number;
+    actual: number;
+    severity: 'warning' | 'critical';
+    timestamp: number;
+}
+export interface PerformanceMarker {
+    id: TimerId;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    category?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface PerformanceConfig {
+    enabled?: boolean;
+    sampleSize?: number;
+    updateInterval?: number;
+    budgets?: Partial<PerformanceBudget>;
+    trackMemory?: boolean;
+    trackGPU?: boolean;
+    autoAdjustQuality?: boolean;
+    qualityLevels?: QualityLevel[];
+}
+export interface QualityLevel {
+    id: string;
+    name: string;
+    targetFPS: number;
+    settings: Record<string, unknown>;
+}
+export declare const DEFAULT_PERFORMANCE_CONFIG: PerformanceConfig;
+export type PerformanceEventType = 'frame-update' | 'budget-violation' | 'quality-change' | 'marker-complete' | 'report-generated';
+export interface PerformanceEvent {
+    type: PerformanceEventType;
+    frameMetrics?: FrameMetrics;
+    violation?: BudgetViolation;
+    qualityLevel?: string;
+    marker?: PerformanceMarker;
+}
+export declare class NicePerformance extends EventEmitter {
+    private config;
+    private frameCount;
+    private lastFrameTime;
+    private frameTimes;
+    private activeMarkers;
+    private completedMarkers;
+    private customMetrics;
+    private gpuMetrics;
+    private currentQualityLevel?;
+    private violations;
+    private lastUpdateTime;
+    private startTime;
+    constructor(config?: Partial<PerformanceConfig>);
+    private getDefaultGPUMetrics;
+    beginFrame(): void;
+    endFrame(): void;
+    private calculateJitter;
+    private countDroppedFrames;
+    private checkBudgets;
+    private reportViolation;
+    mark(name: string, category?: string): TimerId;
+    measure(id: TimerId, metadata?: Record<string, unknown>): number;
+    recordMetric(id: MetricId, value: number): void;
+    getMetric(id: MetricId): TimingMetrics | null;
+    setGPUMetrics(metrics: Partial<GPUMetrics>): void;
+    getGPUMetrics(): GPUMetrics;
+    resetGPUMetrics(): void;
+    getMemoryMetrics(): MemoryMetrics | null;
+    getFPS(): number;
+    getAverageFrameTime(): number;
+    getFrameTimeMetrics(): TimingMetrics;
+    private calculateTimingMetrics;
+    setQualityLevel(levelId: string): void;
+    getQualityLevel(): string | undefined;
+    private decreaseQuality;
+    private increaseQuality;
+    generateReport(): PerformanceReport;
+    reset(): void;
+}
+export interface PerformanceReport {
+    timestamp: number;
+    duration: number;
+    frameCount: number;
+    fps: number;
+    frameMetrics: TimingMetrics;
+    memory: MemoryMetrics | null;
+    gpu: GPUMetrics;
+    customMetrics: Record<MetricId, TimingMetrics>;
+    violations: BudgetViolation[];
+    markers: Array<{
+        name: string;
+        duration: number;
+        category?: string;
+    }>;
+    qualityLevel?: string;
+}
+export declare function createPerformanceMonitor(config?: Partial<PerformanceConfig>): NicePerformance;
+export default NicePerformance;

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

@@ -0,0 +1,167 @@
+import { EventEmitter } from 'events';
+export type PetId = string;
+export type OwnerId = string;
+export type PetSpeciesId = string;
+export type PetAbilityId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface PetSpecies {
+    id: PetSpeciesId;
+    name: string;
+    description?: string;
+    baseStats: PetStats;
+    growthRates: Partial<PetStats>;
+    maxLevel: number;
+    abilities: PetAbilityId[];
+    abilityUnlockLevels: Map<PetAbilityId, number>;
+    evolutionOptions?: EvolutionOption[];
+    needs: PetNeedsConfig;
+    size: 'tiny' | 'small' | 'medium' | 'large' | 'huge';
+    movementSpeed: number;
+    flightCapable?: boolean;
+    swimCapable?: boolean;
+}
+export interface EvolutionOption {
+    targetSpecies: PetSpeciesId;
+    requiredLevel: number;
+    requirements?: EvolutionRequirement[];
+}
+export interface EvolutionRequirement {
+    type: 'item' | 'stat' | 'bond' | 'location' | 'time';
+    value: string | number;
+}
+export interface PetStats {
+    health: number;
+    stamina: number;
+    attack: number;
+    defense: number;
+    speed: number;
+    intelligence: number;
+}
+export interface PetNeeds {
+    hunger: number;
+    happiness: number;
+    energy: number;
+    cleanliness: number;
+    affection: number;
+}
+export interface PetNeedsConfig {
+    hungerDecayRate: number;
+    happinessDecayRate: number;
+    energyDecayRate: number;
+    cleanlinessDecayRate: number;
+    affectionDecayRate: number;
+}
+export type PetBehaviorMode = 'follow' | 'guard' | 'patrol' | 'rest' | 'play' | 'hunt' | 'gather' | 'assist' | 'stay';
+export interface PetBehaviorConfig {
+    mode: PetBehaviorMode;
+    followDistance?: number;
+    guardRadius?: number;
+    patrolPoints?: Vector3[];
+    targetId?: string;
+    aggressiveness?: number;
+}
+export interface PetAbility {
+    id: PetAbilityId;
+    name: string;
+    description?: string;
+    cooldown: number;
+    staminaCost: number;
+    type: 'passive' | 'active' | 'combat' | 'utility';
+    effect: (pet: Pet, target?: string) => void;
+}
+export interface Pet {
+    id: PetId;
+    name: string;
+    speciesId: PetSpeciesId;
+    ownerId: OwnerId;
+    level: number;
+    experience: number;
+    stats: PetStats;
+    currentHealth: number;
+    currentStamina: number;
+    needs: PetNeeds;
+    bondLevel: number;
+    position: Vector3;
+    behavior: PetBehaviorConfig;
+    abilities: Set<PetAbilityId>;
+    abilityCooldowns: Map<PetAbilityId, number>;
+    active: boolean;
+    summoned: boolean;
+    createdAt: number;
+    traits: string[];
+    customData: Record<string, unknown>;
+}
+export type PetEventType = 'pet-created' | 'pet-removed' | 'pet-summoned' | 'pet-dismissed' | 'pet-leveled-up' | 'pet-evolved' | 'pet-ability-used' | 'pet-ability-learned' | 'pet-need-critical' | 'pet-bond-changed' | 'pet-behavior-changed' | 'pet-died';
+export interface PetEvent {
+    type: PetEventType;
+    petId: PetId;
+    ownerId?: OwnerId;
+    data?: Record<string, unknown>;
+}
+export interface PetSystemConfig {
+    maxPetsPerOwner?: number;
+    maxActivePets?: number;
+    experienceMultiplier?: number;
+    bondGainRate?: number;
+    needsUpdateInterval?: number;
+}
+export declare const DEFAULT_PET_CONFIG: PetSystemConfig;
+export declare class NicePet extends EventEmitter {
+    private pets;
+    private species;
+    private abilities;
+    private ownerPets;
+    private activePets;
+    private nextPetId;
+    private config;
+    constructor(config?: Partial<PetSystemConfig>);
+    registerSpecies(speciesData: PetSpecies): void;
+    getSpecies(speciesId: PetSpeciesId): PetSpecies | undefined;
+    getAllSpecies(): PetSpecies[];
+    registerAbility(ability: PetAbility): void;
+    getAbility(abilityId: PetAbilityId): PetAbility | undefined;
+    create(ownerId: OwnerId, speciesId: PetSpeciesId, name: string, options?: {
+        level?: number;
+        traits?: string[];
+    }): PetId | null;
+    private calculateStatsForLevel;
+    private unlockAbilitiesForLevel;
+    remove(petId: PetId): boolean;
+    get(petId: PetId): Pet | undefined;
+    getByOwner(ownerId: OwnerId): Pet[];
+    summon(petId: PetId, position: Vector3): boolean;
+    dismiss(petId: PetId): boolean;
+    getActivePets(ownerId: OwnerId): Pet[];
+    addExperience(petId: PetId, amount: number): boolean;
+    private levelUp;
+    canEvolve(petId: PetId, targetSpeciesId?: PetSpeciesId): EvolutionOption | null;
+    private checkEvolutionRequirement;
+    evolve(petId: PetId, targetSpeciesId: PetSpeciesId): boolean;
+    useAbility(petId: PetId, abilityId: PetAbilityId, targetId?: string): boolean;
+    getAbilityCooldown(petId: PetId, abilityId: PetAbilityId): number;
+    setBehavior(petId: PetId, behavior: PetBehaviorConfig): void;
+    updateNeeds(deltaTime: number): void;
+    private checkCriticalNeeds;
+    feed(petId: PetId, amount: number): void;
+    play(petId: PetId, duration: number): void;
+    rest(petId: PetId, duration: number): void;
+    groom(petId: PetId): void;
+    pet(petId: PetId): void;
+    increaseBond(petId: PetId, amount: number): void;
+    getBondLevel(petId: PetId): number;
+    getBondRank(bondLevel: number): string;
+    update(deltaTime: number): void;
+    damage(petId: PetId, amount: number): void;
+    heal(petId: PetId, amount: number): void;
+    revive(petId: PetId, healthPercentage?: number): boolean;
+}
+export declare function createPetSystem(config?: Partial<PetSystemConfig>): NicePet;
+export declare function defineSpecies(data: PetSpecies): PetSpecies;
+export declare function defineAbility(data: Omit<PetAbility, 'effect'> & {
+    effect?: PetAbility['effect'];
+}): PetAbility;
+export default NicePet;