@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,148 @@
+export type LocaleId = string;
+export type TranslationKey = string;
+export type Namespace = string;
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export type Gender = 'masculine' | 'feminine' | 'neutral' | 'other';
+export interface TranslationValue {
+    /** Simple string value */
+    value?: string;
+    /** Plural forms */
+    plural?: Partial<Record<PluralCategory, string>>;
+    /** Gender forms */
+    gender?: Partial<Record<Gender, string>>;
+    /** Context-specific variations */
+    context?: Record<string, string>;
+    /** Rich text markup */
+    richText?: boolean;
+}
+export interface TranslationEntry {
+    key: TranslationKey;
+    value: string | TranslationValue;
+    /** Last modified timestamp */
+    updated?: number;
+    /** Translator notes */
+    notes?: string;
+    /** Max character length */
+    maxLength?: number;
+    /** Tags for organization */
+    tags?: string[];
+}
+export interface TranslationNamespace {
+    id: Namespace;
+    name: string;
+    translations: Map<TranslationKey, TranslationEntry>;
+}
+export interface LocaleDefinition {
+    id: LocaleId;
+    name: string;
+    nativeName: string;
+    /** Language code (ISO 639-1) */
+    language: string;
+    /** Country code (ISO 3166-1) */
+    country?: string;
+    /** Script (ISO 15924) */
+    script?: string;
+    /** Text direction */
+    direction: 'ltr' | 'rtl';
+    /** Fallback locales */
+    fallback?: LocaleId[];
+    /** Plural rules function */
+    pluralRule?: (count: number) => PluralCategory;
+    /** Date format */
+    dateFormat?: string;
+    /** Time format */
+    timeFormat?: string;
+    /** Number formatting */
+    numberFormat?: Intl.NumberFormatOptions;
+    /** Currency */
+    currency?: string;
+    /** Namespaces */
+    namespaces: Map<Namespace, TranslationNamespace>;
+}
+export interface InterpolationOptions {
+    /** Variable values */
+    vars?: Record<string, string | number | boolean>;
+    /** Count for pluralization */
+    count?: number;
+    /** Gender for gender-aware text */
+    gender?: Gender;
+    /** Context key */
+    context?: string;
+    /** Default value if key not found */
+    defaultValue?: string;
+    /** Namespace override */
+    ns?: Namespace;
+    /** Skip post-processing */
+    skipPostProcess?: boolean;
+}
+export type LocaleEventType = 'locale-changed' | 'namespace-loaded' | 'translation-added' | 'missing-key' | 'error';
+export interface LocaleEvent {
+    type: LocaleEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type LocaleEventCallback = (event: LocaleEvent) => void;
+export interface LocalizationConfig {
+    /** Default locale */
+    defaultLocale: LocaleId;
+    /** Supported locales */
+    supportedLocales: LocaleId[];
+    /** Default namespace */
+    defaultNamespace: Namespace;
+    /** Fallback locale */
+    fallbackLocale?: LocaleId;
+    /** Interpolation prefix */
+    interpolationPrefix: string;
+    /** Interpolation suffix */
+    interpolationSuffix: string;
+    /** Missing key handler */
+    missingKeyHandler?: 'warn' | 'error' | 'silent' | 'fallback';
+    /** Auto-detect browser locale */
+    detectBrowserLocale: boolean;
+    /** Storage key for persist */
+    storageKey: string;
+    /** Debug mode */
+    debug: boolean;
+}
+export declare const DEFAULT_LOCALIZATION_CONFIG: LocalizationConfig;
+export declare class NiceLocalization {
+    private config;
+    private locales;
+    private currentLocale;
+    private loadedNamespaces;
+    private eventListeners;
+    private missingKeys;
+    private formatters;
+    constructor(config?: Partial<LocalizationConfig>);
+    on(event: LocaleEventType, callback: LocaleEventCallback): () => void;
+    private emit;
+    registerLocale(locale: Omit<LocaleDefinition, 'namespaces'>): void;
+    addTranslations(localeId: LocaleId, namespace: Namespace, translations: Record<TranslationKey, string | TranslationValue>): void;
+    setLocale(localeId: LocaleId): boolean;
+    getLocale(): LocaleId;
+    getLocaleInfo(): LocaleDefinition | undefined;
+    getSupportedLocales(): LocaleId[];
+    t(key: TranslationKey, options?: InterpolationOptions): string;
+    private lookupKey;
+    private interpolate;
+    private escapeRegex;
+    private getPluralCategory;
+    formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+    formatCurrency(value: number, currency?: string): string;
+    formatPercent(value: number, decimals?: number): string;
+    formatDate(date: Date | number, options?: Intl.DateTimeFormatOptions): string;
+    formatRelativeTime(date: Date | number, style?: 'long' | 'short' | 'narrow'): string;
+    formatDuration(seconds: number, format?: 'short' | 'long'): string;
+    formatList(items: string[], style?: 'conjunction' | 'disjunction'): string;
+    exists(key: TranslationKey, namespace?: Namespace): boolean;
+    getDirection(): 'ltr' | 'rtl';
+    getMissingKeys(): string[];
+    clearMissingKeys(): void;
+    loadTranslationsFromJSON(localeId: LocaleId, namespace: Namespace, json: Record<string, unknown>): void;
+    private flattenObject;
+    exportTranslations(localeId: LocaleId, namespace?: Namespace): Record<string, Record<string, string | TranslationValue>>;
+    save(): void;
+    destroy(): void;
+}
+export declare function createLocalizationSystem(config?: Partial<LocalizationConfig>): NiceLocalization;
+export type TFunction = (key: TranslationKey, options?: InterpolationOptions) => string;

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

@@ -0,0 +1,398 @@
+/**
+ * NiceLocomotion - Advanced Character Movement System
+ *
+ * Comprehensive locomotion system for various movement types including
+ * walking, running, jumping, swimming, climbing, and more.
+ *
+ * Features:
+ * - Multiple movement modes
+ * - Ground/air detection
+ * - Slope handling
+ * - Step climbing
+ * - Jumping & double jump
+ * - Dashing
+ * - Swimming
+ * - Climbing
+ * - Wall running
+ * - Crouch & slide
+ * - Momentum system
+ * - Root motion support
+ * - Movement modifiers
+ * - Movement prediction
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique entity ID */
+export type EntityId = string;
+/** Movement mode */
+export type MovementMode = 'walking' | 'running' | 'sprinting' | 'crouching' | 'prone' | 'jumping' | 'falling' | 'flying' | 'swimming' | 'climbing' | 'sliding' | 'wall_running' | 'dashing' | 'custom';
+/** Ground state */
+export type GroundState = 'grounded' | 'airborne' | 'sliding' | 'water';
+/** Surface type */
+export type SurfaceType = 'default' | 'grass' | 'dirt' | 'stone' | 'metal' | 'wood' | 'water' | 'ice' | 'sand' | 'snow' | 'mud';
+/** 3D Vector */
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** 2D Vector */
+export interface Vector2 {
+    x: number;
+    y: number;
+}
+/** Movement input */
+export interface MovementInput {
+    forward: number;
+    right: number;
+    up: number;
+    jump: boolean;
+    sprint: boolean;
+    crouch: boolean;
+    dash: boolean;
+}
+/** Character state */
+export interface CharacterState {
+    entityId: EntityId;
+    position: Vector3;
+    velocity: Vector3;
+    rotation: Vector3;
+    groundState: GroundState;
+    movementMode: MovementMode;
+    surfaceType: SurfaceType;
+    slopeAngle: number;
+    isMoving: boolean;
+    currentSpeed: number;
+    maxSpeed: number;
+    stamina: number;
+    maxStamina: number;
+}
+/** Ground check result */
+export interface GroundCheckResult {
+    isGrounded: boolean;
+    groundNormal: Vector3;
+    groundPoint: Vector3;
+    slopeAngle: number;
+    surfaceType: SurfaceType;
+    groundEntity?: EntityId;
+    distance: number;
+}
+/** Movement settings per mode */
+export interface ModeSettings {
+    maxSpeed: number;
+    acceleration: number;
+    deceleration: number;
+    friction: number;
+    canJump: boolean;
+    staminaCost: number;
+    animationState?: string;
+}
+/** Jump settings */
+export interface JumpSettings {
+    enabled: boolean;
+    jumpForce: number;
+    maxJumps: number;
+    jumpCooldown: number;
+    airControl: number;
+    coyoteTime: number;
+    jumpBufferTime: number;
+    variableJumpHeight: boolean;
+    jumpCutMultiplier: number;
+    staminaCost: number;
+}
+/** Dash settings */
+export interface DashSettings {
+    enabled: boolean;
+    dashForce: number;
+    dashDuration: number;
+    dashCooldown: number;
+    maxDashes: number;
+    dashDirection: 'movement' | 'facing' | 'input';
+    canDashInAir: boolean;
+    staminaCost: number;
+}
+/** Swim settings */
+export interface SwimSettings {
+    enabled: boolean;
+    swimSpeed: number;
+    diveSpeed: number;
+    surfaceSpeed: number;
+    buoyancy: number;
+    waterDrag: number;
+    staminaDrainRate: number;
+}
+/** Climb settings */
+export interface ClimbSettings {
+    enabled: boolean;
+    climbSpeed: number;
+    maxClimbAngle: number;
+    climbStaminaCost: number;
+    canClimbLedges: boolean;
+    ledgeClimbDuration: number;
+}
+/** Wall run settings */
+export interface WallRunSettings {
+    enabled: boolean;
+    wallRunSpeed: number;
+    maxWallRunTime: number;
+    wallRunGravity: number;
+    minWallRunSpeed: number;
+    wallJumpForce: Vector2;
+    staminaCost: number;
+}
+/** Slide settings */
+export interface SlideSettings {
+    enabled: boolean;
+    slideSpeed: number;
+    slideDuration: number;
+    slideCooldown: number;
+    minSlideSpeed: number;
+    slopeBoost: number;
+    staminaCost: number;
+}
+/** Step settings */
+export interface StepSettings {
+    enabled: boolean;
+    maxStepHeight: number;
+    stepSmoothing: number;
+    stepSearchDistance: number;
+}
+/** Slope settings */
+export interface SlopeSettings {
+    maxWalkAngle: number;
+    slideAngle: number;
+    slopeSpeedMultiplier: number;
+    uphillMultiplier: number;
+    downhillMultiplier: number;
+}
+/** Modifier effect */
+export interface MovementModifier {
+    id: string;
+    name: string;
+    speedMultiplier: number;
+    jumpMultiplier: number;
+    gravityMultiplier: number;
+    staminaMultiplier: number;
+    duration?: number;
+    startTime?: number;
+    stackable: boolean;
+}
+/** Prediction data */
+export interface MovementPrediction {
+    futurePosition: Vector3;
+    futureVelocity: Vector3;
+    timeToLand?: number;
+    landingPosition?: Vector3;
+    willCollide: boolean;
+    collisionTime?: number;
+}
+/** Locomotion statistics */
+export interface LocomotionStatistics {
+    totalDistanceTraveled: number;
+    totalJumps: number;
+    totalDashes: number;
+    maxSpeedReached: number;
+    timeInAir: number;
+    timeSwimming: number;
+    timeClimbing: number;
+    fallDamageReceived: number;
+}
+/** Locomotion event types */
+export type LocomotionEventType = 'mode_changed' | 'ground_state_changed' | 'jumped' | 'landed' | 'dashed' | 'wall_run_started' | 'wall_run_ended' | 'climb_started' | 'climb_ended' | 'swim_started' | 'swim_ended' | 'slide_started' | 'slide_ended' | 'stamina_depleted' | 'stamina_recovered' | 'modifier_applied' | 'modifier_removed' | 'footstep' | 'fall_damage';
+/** Locomotion event data */
+export interface LocomotionEvent {
+    type: LocomotionEventType;
+    timestamp: number;
+    entityId: EntityId;
+    data?: unknown;
+}
+/** Locomotion event callback */
+export type LocomotionEventCallback = (event: LocomotionEvent) => void;
+/** Locomotion system configuration */
+export interface LocomotionConfig {
+    gravity: number;
+    terminalVelocity: number;
+    airResistance: number;
+    groundCheckDistance: number;
+    skinWidth: number;
+    maxStamina: number;
+    staminaRegenRate: number;
+    staminaRegenDelay: number;
+    enableFootsteps: boolean;
+    footstepInterval: number;
+    enableFallDamage: boolean;
+    fallDamageThreshold: number;
+    fallDamageMultiplier: number;
+}
+/** Default configuration */
+export declare const DEFAULT_LOCOMOTION_CONFIG: LocomotionConfig;
+/** Default mode settings */
+export declare const DEFAULT_MODE_SETTINGS: Record<MovementMode, ModeSettings>;
+/**
+ * Advanced character locomotion system
+ */
+export declare class NiceLocomotion extends EventEmitter {
+    private config;
+    private characters;
+    private modeSettings;
+    private modifiers;
+    private statistics;
+    private jumpSettings;
+    private dashSettings;
+    private swimSettings;
+    private climbSettings;
+    private wallRunSettings;
+    private slideSettings;
+    private stepSettings;
+    private slopeSettings;
+    private jumpCounts;
+    private dashCounts;
+    private lastJumpTime;
+    private lastDashTime;
+    private lastGroundedTime;
+    private jumpBufferTime;
+    private lastStaminaUseTime;
+    private lastFootstepTime;
+    private airTime;
+    private wallRunTime;
+    private slideTime;
+    constructor(config?: Partial<LocomotionConfig>);
+    /**
+     * Emit locomotion event
+     */
+    private emitEvent;
+    /**
+     * Register character
+     */
+    registerCharacter(entityId: EntityId, initialPosition?: Vector3): CharacterState;
+    /**
+     * Unregister character
+     */
+    unregisterCharacter(entityId: EntityId): boolean;
+    /**
+     * Get character state
+     */
+    getCharacterState(entityId: EntityId): CharacterState | undefined;
+    /**
+     * Create statistics object
+     */
+    private createStatistics;
+    /**
+     * Update locomotion
+     */
+    update(entityId: EntityId, input: MovementInput, deltaTime: number, groundCheck: GroundCheckResult): CharacterState | undefined;
+    /**
+     * Update ground state
+     */
+    private updateGroundState;
+    /**
+     * Process input
+     */
+    private processInput;
+    /**
+     * Apply gravity
+     */
+    private applyGravity;
+    /**
+     * Apply movement
+     */
+    private applyMovement;
+    /**
+     * Handle jump
+     */
+    private handleJump;
+    /**
+     * Handle dash
+     */
+    private handleDash;
+    /**
+     * Handle slide
+     */
+    private handleSlide;
+    /**
+     * Update stamina
+     */
+    private updateStamina;
+    /**
+     * Add movement modifier
+     */
+    addModifier(entityId: EntityId, modifier: MovementModifier): void;
+    /**
+     * Remove modifier
+     */
+    removeModifier(entityId: EntityId, modifierId: string): boolean;
+    /**
+     * Update modifiers
+     */
+    private updateModifiers;
+    /**
+     * Get combined speed modifier
+     */
+    private getSpeedModifier;
+    /**
+     * Get combined jump modifier
+     */
+    private getJumpModifier;
+    /**
+     * Get combined gravity modifier
+     */
+    private getGravityModifier;
+    /**
+     * Get combined stamina modifier
+     */
+    private getStaminaModifier;
+    /**
+     * Handle footsteps
+     */
+    private handleFootsteps;
+    /**
+     * Update statistics
+     */
+    private updateStatistics;
+    /**
+     * Get statistics
+     */
+    getStatistics(entityId: EntityId): LocomotionStatistics | undefined;
+    /**
+     * Move towards target
+     */
+    private moveTowards;
+    /**
+     * Get vector magnitude
+     */
+    private getVectorMagnitude;
+    /**
+     * Normalize 2D vector
+     */
+    private normalizeVector2;
+    /**
+     * Predict future position
+     */
+    predictMovement(entityId: EntityId, time: number): MovementPrediction | undefined;
+    /**
+     * Get jump settings
+     */
+    getJumpSettings(): JumpSettings;
+    /**
+     * Update jump settings
+     */
+    updateJumpSettings(settings: Partial<JumpSettings>): void;
+    /**
+     * Get dash settings
+     */
+    getDashSettings(): DashSettings;
+    /**
+     * Update dash settings
+     */
+    updateDashSettings(settings: Partial<DashSettings>): void;
+    /**
+     * Destroy locomotion system
+     */
+    destroy(): void;
+}
+/**
+ * Create locomotion system instance
+ */
+export declare function createLocomotionSystem(config?: Partial<LocomotionConfig>): NiceLocomotion;
+export default NiceLocomotion;

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

@@ -0,0 +1,117 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export type LogCategory = string;
+export declare const LOG_LEVELS: Record<LogLevel, number>;
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: number;
+    category?: LogCategory;
+    data?: Record<string, unknown>;
+    stack?: string;
+    context?: string;
+}
+export interface LogTransport {
+    name: string;
+    write(entry: LogEntry): void | Promise<void>;
+    flush?(): void | Promise<void>;
+}
+export interface ConsoleTransportConfig {
+    colors?: boolean;
+    timestamps?: boolean;
+    showCategory?: boolean;
+    showData?: boolean;
+}
+export declare class ConsoleTransport implements LogTransport {
+    name: string;
+    private config;
+    private colors;
+    private reset;
+    constructor(config?: ConsoleTransportConfig);
+    write(entry: LogEntry): void;
+}
+export declare class MemoryTransport implements LogTransport {
+    name: string;
+    logs: LogEntry[];
+    maxEntries: number;
+    constructor(maxEntries?: number);
+    write(entry: LogEntry): void;
+    clear(): void;
+    getByLevel(level: LogLevel): LogEntry[];
+    getByCategory(category: LogCategory): LogEntry[];
+}
+export interface RemoteTransportConfig {
+    url: string;
+    batchSize?: number;
+    flushInterval?: number;
+    headers?: Record<string, string>;
+}
+export declare class RemoteTransport implements LogTransport {
+    name: string;
+    private config;
+    private buffer;
+    private timer;
+    constructor(config: RemoteTransportConfig);
+    write(entry: LogEntry): void;
+    flush(): Promise<void>;
+    dispose(): void;
+}
+export interface LoggerConfig {
+    level?: LogLevel;
+    transports?: LogTransport[];
+    defaultCategory?: LogCategory;
+    enableMetrics?: boolean;
+    context?: string;
+}
+export declare const DEFAULT_LOGGER_CONFIG: LoggerConfig;
+export declare class NiceLogger {
+    private minLevel;
+    private transports;
+    private defaultCategory;
+    private enableMetrics;
+    private context?;
+    private metrics;
+    private timers;
+    private groupDepth;
+    constructor(config?: LoggerConfig);
+    debug(message: string, data?: Record<string, unknown>, category?: LogCategory): void;
+    info(message: string, data?: Record<string, unknown>, category?: LogCategory): void;
+    warn(message: string, data?: Record<string, unknown>, category?: LogCategory): void;
+    error(message: string, error?: Error | Record<string, unknown>, category?: LogCategory): void;
+    fatal(message: string, error?: Error | Record<string, unknown>, category?: LogCategory): void;
+    private log;
+    group(label: string, category?: LogCategory): void;
+    groupEnd(): void;
+    time(label: string): void;
+    timeEnd(label: string, category?: LogCategory): number;
+    private recordMetric;
+    getMetrics(): Map<string, {
+        count: number;
+        totalTime: number;
+        avgTime: number;
+    }>;
+    clearMetrics(): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    addTransport(transport: LogTransport): void;
+    removeTransport(name: string): boolean;
+    child(category: LogCategory, context?: string): NiceLogger;
+    flush(): Promise<void>;
+}
+export declare function getGlobalLogger(): NiceLogger;
+export declare function setGlobalLogger(logger: NiceLogger): void;
+export declare const log: {
+    debug: (message: string, data?: Record<string, unknown>, category?: LogCategory) => void;
+    info: (message: string, data?: Record<string, unknown>, category?: LogCategory) => void;
+    warn: (message: string, data?: Record<string, unknown>, category?: LogCategory) => void;
+    error: (message: string, error?: Error | Record<string, unknown>, category?: LogCategory) => void;
+    fatal: (message: string, error?: Error | Record<string, unknown>, category?: LogCategory) => void;
+    time: (label: string) => void;
+    timeEnd: (label: string, category?: LogCategory) => number;
+    group: (label: string, category?: LogCategory) => void;
+    groupEnd: () => void;
+};
+export declare function createLogger(config?: LoggerConfig): NiceLogger;
+export declare function createConsoleTransport(config?: ConsoleTransportConfig): ConsoleTransport;
+export declare function createMemoryTransport(maxEntries?: number): MemoryTransport;
+export declare function createRemoteTransport(config: RemoteTransportConfig): RemoteTransport;
+export default NiceLogger;