@nice2dev/game-engine 1.1.5 → 1.1.6

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

@@ -0,0 +1,271 @@
+export type EntityId = string;
+export type DamageTypeId = string;
+export type EffectId = string;
+export type AbilityId = string;
+export type DamageCategory = 'physical' | 'magical' | 'true' | 'environmental';
+export interface DamageTypeDefinition {
+    id: DamageTypeId;
+    name: string;
+    category: DamageCategory;
+    color?: string;
+    icon?: string;
+    /** Can crit */
+    canCrit: boolean;
+    /** Can be blocked */
+    canBlock: boolean;
+    /** Can be dodged */
+    canDodge: boolean;
+    /** Ignores armor */
+    ignoresArmor: boolean;
+    /** Applies lifesteal */
+    lifestealApplies: boolean;
+}
+export declare const DEFAULT_DAMAGE_TYPES: DamageTypeDefinition[];
+export interface CombatStats {
+    /** Maximum health */
+    maxHealth: number;
+    /** Current health */
+    currentHealth: number;
+    /** Health regeneration per second */
+    healthRegen: number;
+    /** Maximum shield */
+    maxShield: number;
+    /** Current shield */
+    currentShield: number;
+    /** Shield regeneration per second */
+    shieldRegen: number;
+    /** Shield regen delay after damage */
+    shieldRegenDelay: number;
+    /** Base damage */
+    baseDamage: number;
+    /** Damage multiplier */
+    damageMultiplier: number;
+    /** Armor (reduces physical damage) */
+    armor: number;
+    /** Magic resist (reduces magical damage) */
+    magicResist: number;
+    /** Damage reduction (percentage, 0-1) */
+    damageReduction: number;
+    /** Critical chance (0-1) */
+    critChance: number;
+    /** Critical damage multiplier */
+    critMultiplier: number;
+    /** Block chance (0-1) */
+    blockChance: number;
+    /** Block amount */
+    blockAmount: number;
+    /** Dodge chance (0-1) */
+    dodgeChance: number;
+    /** Lifesteal (0-1) */
+    lifesteal: number;
+    /** Resistances by damage type (0-1) */
+    resistances: Record<DamageTypeId, number>;
+    /** Vulnerabilities by damage type (multiplier) */
+    vulnerabilities: Record<DamageTypeId, number>;
+    /** Level for scaling */
+    level: number;
+}
+export declare const DEFAULT_COMBAT_STATS: CombatStats;
+export interface DamageInstance {
+    sourceId: EntityId;
+    targetId: EntityId;
+    baseAmount: number;
+    damageType: DamageTypeId;
+    abilityId?: AbilityId;
+    /** Modifiers to apply */
+    modifiers?: DamageModifier[];
+    /** Force crit */
+    forceCrit?: boolean;
+    /** Cannot crit */
+    cannotCrit?: boolean;
+    /** Ignore resistances */
+    ignoreResistances?: boolean;
+    /** Ignore armor */
+    ignoreArmor?: boolean;
+    /** Timestamp */
+    timestamp?: number;
+    /** Position for damage numbers */
+    position?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+}
+export interface DamageModifier {
+    type: 'flat' | 'percent' | 'multiplier';
+    value: number;
+    source: string;
+}
+export interface DamageResult {
+    instance: DamageInstance;
+    /** Final damage dealt */
+    finalDamage: number;
+    /** Damage before mitigation */
+    rawDamage: number;
+    /** Damage blocked */
+    blocked: number;
+    /** Damage absorbed by shield */
+    shieldAbsorbed: number;
+    /** Health damage */
+    healthDamage: number;
+    /** Overkill damage */
+    overkill: number;
+    /** Was critical hit */
+    isCrit: boolean;
+    /** Was blocked */
+    isBlocked: boolean;
+    /** Was dodged */
+    isDodged: boolean;
+    /** Was resisted */
+    isResisted: boolean;
+    /** Killer if fatal */
+    isFatal: boolean;
+    /** Lifesteal amount */
+    lifestealAmount: number;
+    /** Mitigation breakdown */
+    mitigation: {
+        armor: number;
+        resistance: number;
+        reduction: number;
+        total: number;
+    };
+}
+export interface DotEffect {
+    id: EffectId;
+    sourceId: EntityId;
+    targetId: EntityId;
+    damageType: DamageTypeId;
+    /** Total damage over duration */
+    totalDamage: number;
+    /** Duration in seconds */
+    duration: number;
+    /** Tick interval in seconds */
+    tickInterval: number;
+    /** Elapsed time */
+    elapsed: number;
+    /** Stack count */
+    stacks: number;
+    /** Max stacks */
+    maxStacks: number;
+    /** Can stack duration */
+    stacksDuration: boolean;
+    /** Can refresh */
+    refreshable: boolean;
+    /** Applied time */
+    appliedAt: number;
+}
+export interface HealInstance {
+    sourceId: EntityId;
+    targetId: EntityId;
+    amount: number;
+    abilityId?: AbilityId;
+    /** Can crit */
+    canCrit: boolean;
+    /** Heals shield too */
+    healsShield: boolean;
+    /** Overheal to shield */
+    overhealToShield: boolean;
+}
+export interface HealResult {
+    instance: HealInstance;
+    /** Actual healing done */
+    healingDone: number;
+    /** Overheal amount */
+    overheal: number;
+    /** Shield healed */
+    shieldHealed: number;
+    /** Was critical */
+    isCrit: boolean;
+}
+export interface CombatLogEntry {
+    id: number;
+    timestamp: number;
+    type: 'damage' | 'heal' | 'dot' | 'death' | 'resurrect' | 'shield' | 'buff' | 'debuff';
+    sourceId: EntityId;
+    targetId: EntityId;
+    abilityId?: AbilityId;
+    amount: number;
+    damageType?: DamageTypeId;
+    isCrit?: boolean;
+    isFatal?: boolean;
+}
+export interface DamageNumber {
+    id: number;
+    position: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    amount: number;
+    damageType?: DamageTypeId;
+    isCrit: boolean;
+    isHeal: boolean;
+    isBlocked: boolean;
+    isDodged: boolean;
+    createdAt: number;
+    duration: number;
+}
+export type DamageEventType = 'damage-dealt' | 'damage-taken' | 'heal-received' | 'shield-broken' | 'shield-restored' | 'dot-applied' | 'dot-tick' | 'dot-expired' | 'death' | 'resurrect' | 'combat-log';
+export interface DamageEvent {
+    type: DamageEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type DamageEventCallback = (event: DamageEvent) => void;
+export interface DamageConfig {
+    /** Armor formula type */
+    armorFormula: 'linear' | 'diminishing' | 'threshold';
+    /** Armor constant for diminishing formula */
+    armorConstant: number;
+    /** Enable combat log */
+    enableCombatLog: boolean;
+    /** Max combat log entries */
+    maxLogEntries: number;
+    /** Enable damage numbers */
+    enableDamageNumbers: boolean;
+    /** Damage number duration */
+    damageNumberDuration: number;
+    /** Enable lifesteal */
+    enableLifesteal: boolean;
+    /** Level scaling factor */
+    levelScaling: number;
+}
+export declare const DEFAULT_DAMAGE_CONFIG: DamageConfig;
+export declare class NiceDamage {
+    private config;
+    private damageTypes;
+    private entityStats;
+    private dotEffects;
+    private shieldRegenTimers;
+    private combatLog;
+    private damageNumbers;
+    private logIdCounter;
+    private dnIdCounter;
+    private eventListeners;
+    constructor(config?: Partial<DamageConfig>);
+    on(event: DamageEventType, callback: DamageEventCallback): () => void;
+    private emit;
+    registerDamageType(damageType: DamageTypeDefinition): void;
+    registerEntity(entityId: EntityId, stats?: Partial<CombatStats>): void;
+    unregisterEntity(entityId: EntityId): void;
+    getStats(entityId: EntityId): CombatStats | undefined;
+    setStats(entityId: EntityId, stats: Partial<CombatStats>): void;
+    calculateDamage(instance: DamageInstance): DamageResult;
+    dealDamage(instance: DamageInstance): DamageResult;
+    private calculateArmorMitigation;
+    heal(instance: HealInstance): HealResult;
+    applyDot(dot: Omit<DotEffect, 'elapsed' | 'appliedAt'>): void;
+    updateDots(deltaTime: number): void;
+    updateRegen(deltaTime: number): void;
+    private addCombatLog;
+    getCombatLog(): CombatLogEntry[];
+    clearCombatLog(): void;
+    private createDamageNumber;
+    getDamageNumbers(): DamageNumber[];
+    update(deltaTime: number): void;
+    isAlive(entityId: EntityId): boolean;
+    getHealthPercent(entityId: EntityId): number;
+    resurrect(entityId: EntityId, healthPercent?: number): void;
+    destroy(): void;
+}
+export declare function createDamageSystem(config?: Partial<DamageConfig>): NiceDamage;

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

@@ -0,0 +1,126 @@
+import { EventEmitter } from 'events';
+export type TimeEventId = string;
+export type SeasonId = string;
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+export type TimePeriod = 'dawn' | 'morning' | 'noon' | 'afternoon' | 'dusk' | 'evening' | 'night' | 'midnight';
+export interface TimePeriodConfig {
+    period: TimePeriod;
+    startHour: number;
+    endHour: number;
+    ambientColor: Color;
+    lightIntensity: number;
+    fogDensity?: number;
+}
+export type MoonPhase = 'new' | 'waxing-crescent' | 'first-quarter' | 'waxing-gibbous' | 'full' | 'waning-gibbous' | 'last-quarter' | 'waning-crescent';
+export interface SeasonConfig {
+    id: SeasonId;
+    name: string;
+    startMonth: number;
+    endMonth: number;
+    dayLengthModifier: number;
+    temperatureModifier: number;
+    ambientColorModifier?: Color;
+}
+export interface TimeState {
+    totalMinutes: number;
+    day: number;
+    hour: number;
+    minute: number;
+    period: TimePeriod;
+    season: SeasonId;
+    moonPhase: MoonPhase;
+    sunPosition: number;
+    ambientColor: Color;
+    lightIntensity: number;
+}
+export interface TimeEvent {
+    id: TimeEventId;
+    hour: number;
+    minute?: number;
+    days?: number[];
+    callback: () => void;
+    recurring: boolean;
+    fired?: boolean;
+}
+export type DayNightEventType = 'period-changed' | 'hour-changed' | 'day-changed' | 'season-changed' | 'moon-phase-changed' | 'dawn' | 'noon' | 'dusk' | 'midnight';
+export interface DayNightEvent {
+    type: DayNightEventType;
+    state: TimeState;
+    previousPeriod?: TimePeriod;
+    previousSeason?: SeasonId;
+}
+export interface DayNightConfig {
+    minutesPerDay?: number;
+    startHour?: number;
+    startDay?: number;
+    enableSeasons?: boolean;
+    enableMoonPhases?: boolean;
+    lunarCycleDays?: number;
+    timePeriods?: TimePeriodConfig[];
+    seasons?: SeasonConfig[];
+}
+export declare const DEFAULT_TIME_PERIODS: TimePeriodConfig[];
+export declare const DEFAULT_SEASONS: SeasonConfig[];
+export declare const DEFAULT_DAYNIGHT_CONFIG: DayNightConfig;
+export declare class NiceDayNight extends EventEmitter {
+    private totalMinutes;
+    private timeScale;
+    private paused;
+    private events;
+    private nextEventId;
+    private timePeriods;
+    private seasons;
+    private config;
+    private lastPeriod;
+    private lastHour;
+    private lastDay;
+    private lastSeason;
+    constructor(config?: Partial<DayNightConfig>);
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    setTimeScale(scale: number): void;
+    getTimeScale(): number;
+    setTime(hour: number, minute?: number): void;
+    setDay(day: number): void;
+    addTime(hours?: number, minutes?: number): void;
+    skipToHour(targetHour: number): void;
+    skipToNextPeriod(): void;
+    getHour(): number;
+    getMinute(): number;
+    getDay(): number;
+    getTimeOfDay(): number;
+    getFormattedTime(use24Hour?: boolean): string;
+    getPeriod(): TimePeriod;
+    getPeriodProgress(): number;
+    isDay(): boolean;
+    isNight(): boolean;
+    isDawn(): boolean;
+    isDusk(): boolean;
+    getSunPosition(): number;
+    getSunAngle(): number;
+    getMoonPhase(): MoonPhase;
+    getMoonBrightness(): number;
+    getSeason(): SeasonId;
+    getSeasonConfig(): SeasonConfig | undefined;
+    getAmbientColor(): Color;
+    getLightIntensity(): number;
+    private lerp;
+    private lerpColor;
+    getState(): TimeState;
+    scheduleEvent(hour: number, callback: () => void, options?: {
+        minute?: number;
+        days?: number[];
+        recurring?: boolean;
+    }): TimeEventId;
+    cancelEvent(id: TimeEventId): boolean;
+    private checkTimeEvents;
+    update(deltaTime: number): void;
+}
+export declare function createDayNightSystem(config?: Partial<DayNightConfig>): NiceDayNight;
+export default NiceDayNight;

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

@@ -0,0 +1,255 @@
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export type ProfilerCategory = 'update' | 'render' | 'physics' | 'ai' | 'audio' | 'network' | 'custom';
+export interface LogEntry {
+    timestamp: number;
+    level: LogLevel;
+    category: string;
+    message: string;
+    data?: unknown;
+    stack?: string;
+    frameNumber?: number;
+}
+export interface LogFilter {
+    levels?: LogLevel[];
+    categories?: string[];
+    search?: string;
+    minTimestamp?: number;
+    maxTimestamp?: number;
+}
+export interface ProfilerSample {
+    name: string;
+    category: ProfilerCategory;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    frameNumber: number;
+    depth: number;
+    parent?: string;
+    children: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface FrameStats {
+    frameNumber: number;
+    timestamp: number;
+    deltaTime: number;
+    fps: number;
+    frameTime: number;
+    updateTime: number;
+    renderTime: number;
+    idleTime: number;
+    drawCalls: number;
+    triangles: number;
+    entities: number;
+    memoryUsed?: number;
+}
+export interface ProfilerReport {
+    startTime: number;
+    endTime: number;
+    frameCount: number;
+    averageFps: number;
+    minFps: number;
+    maxFps: number;
+    averageFrameTime: number;
+    samples: ProfilerSample[];
+    hotspots: Array<{
+        name: string;
+        totalTime: number;
+        calls: number;
+        average: number;
+    }>;
+}
+export interface MemorySnapshot {
+    timestamp: number;
+    heapUsed: number;
+    heapTotal: number;
+    external?: number;
+    arrayBuffers?: number;
+    allocations: Map<string, number>;
+}
+export interface AllocationTracker {
+    type: string;
+    count: number;
+    bytes: number;
+    locations: string[];
+}
+export interface DebugLine {
+    from: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    to: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    color: string;
+    thickness: number;
+    duration: number;
+    depthTest: boolean;
+}
+export interface DebugCircle {
+    center: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    radius: number;
+    color: string;
+    filled: boolean;
+    segments: number;
+    duration: number;
+}
+export interface DebugBox {
+    min: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    color: string;
+    filled: boolean;
+    duration: number;
+}
+export interface DebugText {
+    position: {
+        x: number;
+        y: number;
+    };
+    text: string;
+    color: string;
+    fontSize: number;
+    duration: number;
+    screenSpace: boolean;
+}
+export type DebugPrimitive = DebugLine | DebugCircle | DebugBox | DebugText;
+export interface AssertionConfig {
+    enabled: boolean;
+    throwOnFail: boolean;
+    logOnFail: boolean;
+    breakOnFail: boolean;
+}
+export type DebugEventType = 'log' | 'profile-start' | 'profile-end' | 'frame-complete' | 'memory-snapshot' | 'assertion-failed' | 'breakpoint';
+export interface DebugEvent {
+    type: DebugEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export type DebugEventCallback = (event: DebugEvent) => void;
+export interface DebugConfig {
+    enabled: boolean;
+    logLevel: LogLevel;
+    maxLogs: number;
+    maxSamples: number;
+    trackMemory: boolean;
+    trackAllocations: boolean;
+    enableDebugDraw: boolean;
+    showOverlay: boolean;
+    profilerEnabled: boolean;
+    assertionsEnabled: boolean;
+    consoleOutput: boolean;
+}
+export declare const DEFAULT_DEBUG_CONFIG: DebugConfig;
+export declare class NiceDebug {
+    private config;
+    private logs;
+    private samples;
+    private frameStats;
+    private memorySnapshots;
+    private allocations;
+    private debugPrimitives;
+    private eventListeners;
+    private frameNumber;
+    private frameStartTime;
+    private lastFrameTime;
+    private fpsHistory;
+    private activeProfiles;
+    private profileDepth;
+    constructor(config?: Partial<DebugConfig>);
+    on(event: DebugEventType, callback: DebugEventCallback): () => void;
+    private emit;
+    log(level: LogLevel, category: string, message: string, data?: unknown): void;
+    trace(category: string, message: string, data?: unknown): void;
+    debug(category: string, message: string, data?: unknown): void;
+    info(category: string, message: string, data?: unknown): void;
+    warn(category: string, message: string, data?: unknown): void;
+    error(category: string, message: string, data?: unknown): void;
+    fatal(category: string, message: string, data?: unknown): void;
+    getLogs(filter?: LogFilter): LogEntry[];
+    clearLogs(): void;
+    beginProfile(name: string, category?: ProfilerCategory): void;
+    endProfile(name: string, metadata?: Record<string, unknown>): number;
+    profile<T>(name: string, fn: () => T, category?: ProfilerCategory): T;
+    profileAsync<T>(name: string, fn: () => Promise<T>, category?: ProfilerCategory): Promise<T>;
+    beginFrame(): void;
+    endFrame(stats?: Partial<FrameStats>): void;
+    getFrameStats(): FrameStats | undefined;
+    getAverageFps(): number;
+    getFrameNumber(): number;
+    private getMemoryUsage;
+    takeMemorySnapshot(): MemorySnapshot;
+    trackAllocation(type: string, bytes?: number): void;
+    trackDeallocation(type: string, bytes?: number): void;
+    getAllocationStats(): AllocationTracker[];
+    drawLine(from: {
+        x: number;
+        y: number;
+        z?: number;
+    }, to: {
+        x: number;
+        y: number;
+        z?: number;
+    }, options?: {
+        color?: string;
+        thickness?: number;
+        duration?: number;
+        depthTest?: boolean;
+    }): void;
+    drawCircle(center: {
+        x: number;
+        y: number;
+        z?: number;
+    }, radius: number, options?: {
+        color?: string;
+        filled?: boolean;
+        segments?: number;
+        duration?: number;
+    }): void;
+    drawBox(min: {
+        x: number;
+        y: number;
+        z?: number;
+    }, max: {
+        x: number;
+        y: number;
+        z?: number;
+    }, options?: {
+        color?: string;
+        filled?: boolean;
+        duration?: number;
+    }): void;
+    drawText(position: {
+        x: number;
+        y: number;
+    }, text: string, options?: {
+        color?: string;
+        fontSize?: number;
+        duration?: number;
+        screenSpace?: boolean;
+    }): void;
+    getDebugPrimitives(): DebugPrimitive[];
+    clearDebugDraw(): void;
+    assert(condition: boolean, message: string): void;
+    assertEqual<T>(actual: T, expected: T, message?: string): void;
+    assertDefined<T>(value: T | null | undefined, message?: string): asserts value is T;
+    generateReport(fromFrame?: number, toFrame?: number): ProfilerReport;
+    clear(): void;
+    destroy(): void;
+}
+export declare function createDebugSystem(config?: Partial<DebugConfig>): NiceDebug;
+export declare function getGlobalDebug(): NiceDebug;
+export declare function setGlobalDebug(debug: NiceDebug): void;