@nice2dev/game-engine 1.1.5 → 1.1.6

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

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

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

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