@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,174 +0,0 @@
-export type WaveId = string;
-export type EnemyType = string;
-export type SpawnPointId = string;
-export interface SpawnEntry {
-    enemyType: EnemyType;
-    count: number;
-    delay?: number;
-    interval?: number;
-    spawnPoint?: SpawnPointId | SpawnPointId[];
-    modifiers?: EnemyModifier[];
-}
-export interface EnemyModifier {
-    type: 'health' | 'speed' | 'damage' | 'armor' | 'reward' | 'custom';
-    value: number;
-    operation: 'add' | 'multiply' | 'set';
-}
-export interface WaveDefinition {
-    id: WaveId;
-    name?: string;
-    spawns: SpawnEntry[];
-    duration?: number;
-    intermissionTime: number;
-    isBossWave: boolean;
-    bonusObjectives?: WaveObjective[];
-    startDelay?: number;
-    modifiers?: WaveModifier[];
-}
-export interface WaveObjective {
-    id: string;
-    description: string;
-    type: 'time' | 'no-damage' | 'kill-all' | 'custom';
-    target?: number;
-    reward?: {
-        type: string;
-        amount: number;
-    };
-}
-export interface WaveModifier {
-    id: string;
-    name: string;
-    description?: string;
-    effects: EnemyModifier[];
-    spawnRateMultiplier?: number;
-}
-export interface SpawnPoint {
-    id: SpawnPointId;
-    position: {
-        x: number;
-        y: number;
-        z?: number;
-    };
-    direction?: number;
-    active: boolean;
-    weight: number;
-    allowedTypes?: EnemyType[];
-    excludedTypes?: EnemyType[];
-}
-export type WaveState = 'idle' | 'starting' | 'active' | 'clearing' | 'intermission' | 'completed' | 'failed';
-export interface WaveProgress {
-    currentWave: number;
-    totalWaves: number;
-    state: WaveState;
-    waveStartTime: number;
-    waveElapsed: number;
-    intermissionRemaining: number;
-    enemiesSpawned: number;
-    enemiesKilled: number;
-    enemiesRemaining: number;
-    isEndless: boolean;
-}
-export interface SpawnRequest {
-    enemyType: EnemyType;
-    position: {
-        x: number;
-        y: number;
-        z?: number;
-    };
-    direction?: number;
-    modifiers: EnemyModifier[];
-    waveNumber: number;
-    spawnPointId: SpawnPointId;
-}
-export interface DifficultyScaling {
-    waveMultiplier: number;
-    healthScale: number;
-    damageScale: number;
-    speedScale: number;
-    spawnRateScale: number;
-    rewardScale: number;
-}
-export type WaveEventType = 'wave-starting' | 'wave-started' | 'wave-cleared' | 'wave-failed' | 'intermission-started' | 'intermission-ended' | 'enemy-spawned' | 'enemy-killed' | 'boss-spawned' | 'boss-killed' | 'objective-completed' | 'objective-failed' | 'all-waves-completed' | 'endless-milestone';
-export interface WaveEvent {
-    type: WaveEventType;
-    timestamp: number;
-    waveNumber?: number;
-    data?: unknown;
-}
-export type WaveEventCallback = (event: WaveEvent) => void;
-export interface WaveConfig {
-    /** Default intermission time */
-    defaultIntermission: number;
-    /** Auto-start waves */
-    autoStart: boolean;
-    /** Enable endless mode after defined waves */
-    enableEndless: boolean;
-    /** Endless mode difficulty increase per wave */
-    endlessDifficultyScale: number;
-    /** Base spawn rate (enemies/second) */
-    baseSpawnRate: number;
-    /** Count down timer for wave start */
-    startCountdown: number;
-}
-export declare const DEFAULT_WAVE_CONFIG: WaveConfig;
-export type SpawnCallback = (request: SpawnRequest) => void;
-export declare class NiceWave {
-    private config;
-    private waves;
-    private spawnPoints;
-    private currentWaveIndex;
-    private state;
-    private pendingSpawns;
-    private spawnCallback?;
-    private enemiesSpawned;
-    private enemiesKilled;
-    private activeEnemyIds;
-    private waveStartTime;
-    private intermissionEndTime;
-    private startCountdownTime;
-    private difficulty;
-    private activeObjectives;
-    private eventListeners;
-    constructor(config?: Partial<WaveConfig>);
-    on(event: WaveEventType, callback: WaveEventCallback): () => void;
-    private emit;
-    setSpawnCallback(callback: SpawnCallback): void;
-    defineWaves(waves: WaveDefinition[]): void;
-    addWave(wave: WaveDefinition): void;
-    getWave(index: number): WaveDefinition | undefined;
-    getCurrentWave(): WaveDefinition | undefined;
-    private generateEndlessWave;
-    addSpawnPoint(spawnPoint: SpawnPoint): void;
-    removeSpawnPoint(id: SpawnPointId): void;
-    setSpawnPointActive(id: SpawnPointId, active: boolean): void;
-    getSpawnPoints(): SpawnPoint[];
-    private selectSpawnPoint;
-    start(): void;
-    startWave(): void;
-    private beginSpawning;
-    skipIntermission(): void;
-    pause(): void;
-    resume(): void;
-    abort(): void;
-    reset(): void;
-    registerEnemy(enemyId: string): void;
-    onEnemyKilled(enemyId: string, isBoss?: boolean): void;
-    onEnemyEscaped(enemyId: string): void;
-    private checkWaveCleared;
-    private onWaveCleared;
-    update(deltaTime: number): void;
-    private updateStarting;
-    private updateActive;
-    private updateIntermission;
-    private spawnEnemy;
-    setDifficulty(scaling: Partial<DifficultyScaling>): void;
-    resetDifficulty(): void;
-    getDifficulty(): DifficultyScaling;
-    getProgress(): WaveProgress;
-    getState(): WaveState;
-    getActiveEnemyCount(): number;
-    getObjectiveProgress(objectiveId: string): number;
-    isObjectiveCompleted(objectiveId: string): boolean;
-    destroy(): void;
-}
-export declare function createWaveSystem(config?: Partial<WaveConfig>): NiceWave;

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

@@ -1,165 +0,0 @@
-export type WaypointId = string;
-export type NetworkId = string;
-export type WaypointType = 'default' | 'city' | 'dungeon' | 'outpost' | 'shrine' | 'portal' | 'custom';
-export interface WaypointDefinition {
-    id: WaypointId;
-    name: string;
-    description?: string;
-    type: WaypointType;
-    position: {
-        x: number;
-        y: number;
-        z?: number;
-    };
-    zone: string;
-    region?: string;
-    networkId?: NetworkId;
-    levelRequired?: number;
-    questRequired?: string;
-    reputationRequired?: Array<{
-        factionId: string;
-        amount: number;
-    }>;
-    autoDiscover: boolean;
-    discoverRadius?: number;
-    canTravelFrom: boolean;
-    canTravelTo: boolean;
-    baseCost?: number;
-    currencyType?: string;
-    icon?: string;
-    color?: string;
-    enabled: boolean;
-    temporary?: boolean;
-    expiresAt?: number;
-    tags?: string[];
-}
-export interface WaypointNetwork {
-    id: NetworkId;
-    name: string;
-    description?: string;
-    bidirectional: boolean;
-    connections: WaypointConnection[];
-    accessRequirement?: string;
-    costMultiplier: number;
-}
-export interface WaypointConnection {
-    fromId: WaypointId;
-    toId: WaypointId;
-    levelRequired?: number;
-    questRequired?: string;
-    cost?: number;
-    travelTime?: number;
-    enabled: boolean;
-}
-export interface TravelRequest {
-    playerId: string;
-    fromWaypointId: WaypointId;
-    toWaypointId: WaypointId;
-    instant?: boolean;
-    skipCost?: boolean;
-    requestedAt: number;
-}
-export interface TravelResult {
-    success: boolean;
-    error?: string;
-    fromWaypoint: WaypointDefinition;
-    toWaypoint: WaypointDefinition;
-    costPaid?: number;
-    currencyType?: string;
-    travelTime?: number;
-    route?: WaypointId[];
-    timestamp: number;
-}
-export interface PlayerWaypointData {
-    playerId: string;
-    discoveredWaypoints: Set<WaypointId>;
-    discoveryHistory: Array<{
-        waypointId: WaypointId;
-        discoveredAt: number;
-    }>;
-    lastWaypointId?: WaypointId;
-    totalTravels: number;
-    totalDistanceTraveled: number;
-    totalCostSpent: number;
-    favoriteWaypoints: WaypointId[];
-    homeWaypointId?: WaypointId;
-    travelHistory: Array<{
-        from: WaypointId;
-        to: WaypointId;
-        timestamp: number;
-        cost: number;
-    }>;
-}
-export type WaypointEventType = 'waypoint-discovered' | 'waypoint-visited' | 'travel-started' | 'travel-completed' | 'travel-failed' | 'waypoint-enabled' | 'waypoint-disabled' | 'home-set' | 'favorite-added' | 'favorite-removed';
-export interface WaypointEvent {
-    type: WaypointEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type WaypointEventCallback = (event: WaypointEvent) => void;
-export interface WaypointConfig {
-    baseTravelCost: number;
-    costPerDistance: number;
-    maxTravelDistance: number;
-    instantTravel: boolean;
-    travelSpeed: number;
-    maxFavorites: number;
-    enableHomepoint: boolean;
-    homepointCooldown: number;
-    storageKey: string;
-}
-export declare const DEFAULT_WAYPOINT_CONFIG: WaypointConfig;
-export declare class NiceWaypoint {
-    private config;
-    private waypoints;
-    private networks;
-    private playerData;
-    private eventListeners;
-    private onCanTravelCheck?;
-    private onDeductCost?;
-    constructor(config?: Partial<WaypointConfig>);
-    on(event: WaypointEventType, callback: WaypointEventCallback): () => void;
-    private emit;
-    setCanTravelCheck(check: typeof this.onCanTravelCheck): void;
-    setCostDeductionHandler(handler: typeof this.onDeductCost): void;
-    registerWaypoint(waypoint: WaypointDefinition): void;
-    registerNetwork(network: WaypointNetwork): void;
-    addConnection(networkId: NetworkId, connection: WaypointConnection): void;
-    discoverWaypoint(playerId: string, waypointId: WaypointId): boolean;
-    checkAutoDiscover(playerId: string, position: {
-        x: number;
-        y: number;
-        z?: number;
-    }): WaypointDefinition[];
-    travel(request: TravelRequest): TravelResult;
-    teleportHome(playerId: string): TravelResult | null;
-    private calculateTravelCost;
-    getTravelCostPreview(playerId: string, fromWaypointId: WaypointId, toWaypointId: WaypointId): {
-        cost: number;
-        currencyType: string;
-        canAfford: boolean;
-    } | null;
-    addFavorite(playerId: string, waypointId: WaypointId): boolean;
-    removeFavorite(playerId: string, waypointId: WaypointId): boolean;
-    setHomeWaypoint(playerId: string, waypointId: WaypointId): boolean;
-    getWaypoint(id: WaypointId): WaypointDefinition | undefined;
-    getAllWaypoints(): WaypointDefinition[];
-    getEnabledWaypoints(): WaypointDefinition[];
-    getWaypointsByZone(zone: string): WaypointDefinition[];
-    getWaypointsByType(type: WaypointType): WaypointDefinition[];
-    getNetwork(id: NetworkId): WaypointNetwork | undefined;
-    getConnectedWaypoints(waypointId: WaypointId): WaypointDefinition[];
-    getDiscoveredWaypoints(playerId: string): WaypointDefinition[];
-    getFavoriteWaypoints(playerId: string): WaypointDefinition[];
-    getHomeWaypoint(playerId: string): WaypointDefinition | undefined;
-    getPlayerData(playerId: string): PlayerWaypointData | undefined;
-    isDiscovered(playerId: string, waypointId: WaypointId): boolean;
-    findPath(fromId: WaypointId, toId: WaypointId): WaypointId[] | null;
-    private calculateDistance;
-    private getOrCreatePlayerData;
-    private save;
-    private load;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createWaypointSystem(config?: Partial<WaypointConfig>): NiceWaypoint;

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

@@ -1,225 +0,0 @@
-export type WeatherId = string;
-export type BiomeId = string;
-export type SeasonId = 'spring' | 'summer' | 'autumn' | 'winter';
-export type TimeOfDay = 'night' | 'dawn' | 'morning' | 'noon' | 'afternoon' | 'dusk' | 'evening';
-export interface WeatherDefinition {
-    id: WeatherId;
-    name: string;
-    description: string;
-    intensity: number;
-    /** Base temperature modifier (celsius) */
-    temperatureModifier: number;
-    /** Visibility multiplier (0-1) */
-    visibility: number;
-    /** Wind speed (m/s) */
-    windSpeed: number;
-    /** Wind direction (degrees) */
-    windDirection: number;
-    /** Precipitation level (0-1) */
-    precipitation: number;
-    /** Cloud coverage (0-1) */
-    cloudCoverage: number;
-    /** Fog density (0-1) */
-    fogDensity: number;
-    /** Lightning chance per minute */
-    lightningChance: number;
-    /** Sound effects to play */
-    sounds?: string[];
-    /** Particle effects */
-    particles?: string[];
-    /** Can transition to */
-    transitions: WeatherId[];
-    /** Weight for random selection */
-    weight: number;
-    /** Seasons this weather can occur */
-    seasons: SeasonId[];
-    /** Biomes this weather can occur */
-    biomes?: BiomeId[];
-    /** Min/max duration in game hours */
-    duration: {
-        min: number;
-        max: number;
-    };
-    /** Custom data */
-    customData?: Record<string, unknown>;
-}
-export interface WeatherState {
-    current: WeatherId;
-    intensity: number;
-    transitioning: boolean;
-    transitionTarget?: WeatherId;
-    transitionProgress: number;
-    duration: number;
-    elapsed: number;
-}
-export interface WeatherForecast {
-    weather: WeatherId;
-    startTime: number;
-    duration: number;
-    intensity: number;
-}
-export interface TimeState {
-    /** Current game time in seconds */
-    time: number;
-    /** Current day */
-    day: number;
-    /** Current month (1-12) */
-    month: number;
-    /** Current year */
-    year: number;
-    /** Time of day category */
-    timeOfDay: TimeOfDay;
-    /** Hour (0-23) */
-    hour: number;
-    /** Minute (0-59) */
-    minute: number;
-    /** Second (0-59) */
-    second: number;
-    /** Time scale multiplier */
-    timeScale: number;
-    /** Is time paused */
-    paused: boolean;
-}
-export interface TimeConfig {
-    /** Real seconds per game hour */
-    secondsPerHour: number;
-    /** Days per month */
-    daysPerMonth: number;
-    /** Months per year */
-    monthsPerYear: number;
-    /** Starting year */
-    startYear: number;
-    /** Dawn hour */
-    dawnHour: number;
-    /** Dusk hour */
-    duskHour: number;
-}
-export interface SeasonDefinition {
-    id: SeasonId;
-    name: string;
-    months: number[];
-    temperatureBase: number;
-    dayLengthModifier: number;
-    weatherWeights: Partial<Record<WeatherId, number>>;
-}
-export interface BiomeDefinition {
-    id: BiomeId;
-    name: string;
-    baseTemperature: number;
-    baseHumidity: number;
-    weatherWeights: Partial<Record<WeatherId, number>>;
-    excludedWeather: WeatherId[];
-}
-export interface EnvironmentState {
-    /** Current ambient temperature (celsius) */
-    temperature: number;
-    /** Humidity (0-1) */
-    humidity: number;
-    /** Sun position (0-1, 0=midnight, 0.5=noon) */
-    sunPosition: number;
-    /** Sun intensity (0-1) */
-    sunIntensity: number;
-    /** Moon phase (0-7) */
-    moonPhase: number;
-    /** Moon intensity (0-1) */
-    moonIntensity: number;
-    /** Ambient light color */
-    ambientColor: {
-        r: number;
-        g: number;
-        b: number;
-    };
-    /** Sky color */
-    skyColor: {
-        r: number;
-        g: number;
-        b: number;
-    };
-    /** Is indoor */
-    isIndoor: boolean;
-    /** Stars visibility (0-1) */
-    starsVisibility: number;
-}
-export type WeatherEventType = 'weather-changed' | 'weather-transition-start' | 'weather-transition-end' | 'time-changed' | 'hour-changed' | 'day-changed' | 'season-changed' | 'time-of-day-changed' | 'lightning-strike' | 'update';
-export interface WeatherEvent {
-    type: WeatherEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type WeatherEventCallback = (event: WeatherEvent) => void;
-export interface WeatherSystemConfig {
-    time: TimeConfig;
-    /** Update interval in ms */
-    updateInterval: number;
-    /** Enable weather system */
-    enableWeather: boolean;
-    /** Enable time system */
-    enableTime: boolean;
-    /** Latitude for sun calculation (-90 to 90) */
-    latitude: number;
-    /** Auto-save state */
-    autoSave: boolean;
-    /** Storage key */
-    storageKey: string;
-}
-export declare const DEFAULT_WEATHER_CONFIG: WeatherSystemConfig;
-export declare const DEFAULT_WEATHER_PRESETS: WeatherDefinition[];
-export declare const DEFAULT_SEASONS: SeasonDefinition[];
-export declare class NiceWeather {
-    private config;
-    private weatherDefinitions;
-    private seasons;
-    private biomes;
-    private currentBiome;
-    private weatherState;
-    private timeState;
-    private environmentState;
-    private updateTimer;
-    private eventListeners;
-    private forecast;
-    constructor(config?: Partial<WeatherSystemConfig>);
-    on(event: WeatherEventType, callback: WeatherEventCallback): () => void;
-    private emit;
-    registerWeather(weather: WeatherDefinition): void;
-    registerWeathers(weathers: WeatherDefinition[]): void;
-    getWeather(id: WeatherId): WeatherDefinition | undefined;
-    getAllWeathers(): WeatherDefinition[];
-    registerSeason(season: SeasonDefinition): void;
-    getSeason(id: SeasonId): SeasonDefinition | undefined;
-    getCurrentSeason(): SeasonDefinition | undefined;
-    getSeasonForMonth(month: number): SeasonDefinition | undefined;
-    registerBiome(biome: BiomeDefinition): void;
-    setBiome(biomeId: BiomeId | null): void;
-    getCurrentBiome(): BiomeDefinition | undefined;
-    setWeather(weatherId: WeatherId, transition?: boolean): void;
-    private randomFloat;
-    private selectNextWeather;
-    setTime(hour: number, minute?: number, second?: number): void;
-    setDate(day: number, month: number, year: number): void;
-    setTimeScale(scale: number): void;
-    pauseTime(): void;
-    resumeTime(): void;
-    advanceTime(hours: number): void;
-    private advanceDay;
-    private updateTimeState;
-    private updateTimeOfDay;
-    setIndoor(indoor: boolean): void;
-    private startUpdateTimer;
-    update(deltaSeconds: number): void;
-    private updateWeather;
-    private updateEnvironment;
-    generateForecast(hours: number): WeatherForecast[];
-    getForecast(): WeatherForecast[];
-    getWeatherState(): WeatherState;
-    getTimeState(): TimeState;
-    getEnvironmentState(): EnvironmentState;
-    getCurrentWeatherDefinition(): WeatherDefinition | undefined;
-    getFormattedTime(): string;
-    getFormattedDate(): string;
-    save(): string;
-    load(data: string): void;
-    saveToStorage(): void;
-    loadFromStorage(): boolean;
-    destroy(): void;
-}
-export declare function createWeatherSystem(config?: Partial<WeatherSystemConfig>): NiceWeather;