@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,163 +0,0 @@
-import { EventEmitter } from 'events';
-export type CropId = string;
-export type PlotId = string;
-export type CropTypeId = string;
-export type FarmerId = string;
-export type FertilizerId = string;
-export interface Vector2 {
-    x: number;
-    y: number;
-}
-export type Season = 'spring' | 'summer' | 'autumn' | 'winter';
-export interface GrowthStage {
-    name: string;
-    duration: number;
-    sprite?: string;
-    waterNeeded: number;
-    canHarvest?: boolean;
-    yield?: {
-        min: number;
-        max: number;
-    };
-}
-export interface CropType {
-    id: CropTypeId;
-    name: string;
-    description?: string;
-    seeds: string;
-    produce: string;
-    growthStages: GrowthStage[];
-    regrowable?: boolean;
-    regrowthStage?: number;
-    seasons: Season[];
-    minWaterLevel?: number;
-    minSoilQuality?: number;
-    optimalTemperature?: {
-        min: number;
-        max: number;
-    };
-    baseYield: {
-        min: number;
-        max: number;
-    };
-    qualityRange: {
-        min: number;
-        max: number;
-    };
-    soilDepletion: number;
-    experienceGain: number;
-    sellPrice: number;
-}
-export type PlotState = 'empty' | 'tilled' | 'planted' | 'growing' | 'harvestable' | 'dead' | 'weeds';
-export interface Plot {
-    id: PlotId;
-    position: Vector2;
-    size: Vector2;
-    ownerId: FarmerId;
-    state: PlotState;
-    soilQuality: number;
-    soilMoisture: number;
-    soilFertility: number;
-    crop?: PlantedCrop;
-    fertilizerId?: FertilizerId;
-    fertilizerRemaining?: number;
-    isWatered: boolean;
-    lastWateredAt?: number;
-    hasWeeds: boolean;
-    weedsGrowth: number;
-    hasPests: boolean;
-    pestType?: string;
-    hasDisease: boolean;
-    diseaseType?: string;
-}
-export interface PlantedCrop {
-    id: CropId;
-    typeId: CropTypeId;
-    currentStage: number;
-    stageProgress: number;
-    health: number;
-    quality: number;
-    plantedAt: number;
-    harvestCount: number;
-}
-export interface Fertilizer {
-    id: FertilizerId;
-    name: string;
-    description?: string;
-    growthSpeedBonus: number;
-    qualityBonus: number;
-    yieldBonus: number;
-    duration: number;
-    soilFertilityBonus: number;
-}
-export type FarmingEventType = 'plot-tilled' | 'crop-planted' | 'crop-watered' | 'crop-fertilized' | 'crop-stage-changed' | 'crop-harvestable' | 'crop-harvested' | 'crop-died' | 'crop-regrown' | 'weeds-appeared' | 'weeds-removed' | 'pest-appeared' | 'pest-treated' | 'disease-appeared' | 'disease-treated' | 'season-changed';
-export interface FarmingEvent {
-    type: FarmingEventType;
-    farmerId: FarmerId;
-    plotId: PlotId;
-    cropId?: CropId;
-    data?: Record<string, unknown>;
-}
-export interface FarmingSystemConfig {
-    defaultSoilQuality?: number;
-    moistureDecayRate?: number;
-    weedsGrowthRate?: number;
-    pestChance?: number;
-    diseaseChance?: number;
-    seasonLength?: number;
-    dayLength?: number;
-}
-export declare const DEFAULT_FARMING_CONFIG: FarmingSystemConfig;
-export declare class NiceFarming extends EventEmitter {
-    private cropTypes;
-    private fertilizers;
-    private plots;
-    private farmerPlots;
-    private nextPlotId;
-    private nextCropId;
-    private config;
-    private currentSeason;
-    private currentDay;
-    private currentHour;
-    private temperature;
-    private isRaining;
-    constructor(config?: Partial<FarmingSystemConfig>);
-    registerCropType(crop: CropType): void;
-    registerFertilizer(fertilizer: Fertilizer): void;
-    getCropType(typeId: CropTypeId): CropType | undefined;
-    getAllCropTypes(): CropType[];
-    getCropTypesForSeason(season: Season): CropType[];
-    setSeason(season: Season): void;
-    setTemperature(temp: number): void;
-    setRaining(raining: boolean): void;
-    getCurrentSeason(): Season;
-    createPlot(farmerId: FarmerId, position: Vector2, size?: Vector2): PlotId;
-    getPlot(plotId: PlotId): Plot | undefined;
-    getFarmerPlots(farmerId: FarmerId): Plot[];
-    till(plotId: PlotId): boolean;
-    canPlant(plotId: PlotId, cropTypeId: CropTypeId): {
-        canPlant: boolean;
-        reason?: string;
-    };
-    plant(plotId: PlotId, cropTypeId: CropTypeId): CropId | null;
-    private calculateInitialQuality;
-    water(plotId: PlotId, amount?: number): boolean;
-    fertilize(plotId: PlotId, fertilizerId: FertilizerId): boolean;
-    canHarvest(plotId: PlotId): boolean;
-    harvest(plotId: PlotId): {
-        produce: string;
-        quantity: number;
-        quality: number;
-    } | null;
-    removeWeeds(plotId: PlotId): boolean;
-    treatPests(plotId: PlotId): boolean;
-    treatDisease(plotId: PlotId): boolean;
-    private killCrop;
-    update(deltaTime: number): void;
-    private updatePlot;
-    private updateCropGrowth;
-}
-export declare function createFarmingSystem(config?: Partial<FarmingSystemConfig>): NiceFarming;
-export declare function defineCropType(crop: CropType): CropType;
-export declare function defineFertilizer(fertilizer: Fertilizer): Fertilizer;
-export default NiceFarming;

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

@@ -1,196 +0,0 @@
-import { EventEmitter } from 'events';
-export type FishId = string;
-export type FishSpeciesId = string;
-export type FishingSpotId = string;
-export type BaitId = string;
-export type TackleId = string;
-export type FisherId = string;
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export type FishRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary' | 'mythic';
-export interface FishSpecies {
-    id: FishSpeciesId;
-    name: string;
-    description?: string;
-    rarity: FishRarity;
-    baseWeight: {
-        min: number;
-        max: number;
-    };
-    baseLength: {
-        min: number;
-        max: number;
-    };
-    value: number;
-    experience: number;
-    minSkillLevel?: number;
-    requiredBait?: BaitId[];
-    requiredTime?: {
-        start: number;
-        end: number;
-    };
-    requiredWeather?: string[];
-    requiredSeason?: string[];
-    fightStrength: number;
-    escapeProbability: number;
-    biteAggressiveness: number;
-    trophyWeight?: number;
-    trophyLength?: number;
-}
-export interface FishingSpot {
-    id: FishingSpotId;
-    name: string;
-    position: Vector3;
-    radius: number;
-    depth: number;
-    fishPopulation: Map<FishSpeciesId, number>;
-    respawnRate: number;
-    maxFish: number;
-    currentFish: number;
-    requiredSkillLevel?: number;
-    spotType: 'freshwater' | 'saltwater' | 'brackish';
-    specialConditions?: string[];
-}
-export interface Bait {
-    id: BaitId;
-    name: string;
-    description?: string;
-    attractiveness: number;
-    durability: number;
-    rarityBonus?: number;
-    targetSpecies?: FishSpeciesId[];
-    excludeSpecies?: FishSpeciesId[];
-}
-export interface Tackle {
-    id: TackleId;
-    name: string;
-    description?: string;
-    lineStrength: number;
-    castDistance: number;
-    reelSpeed: number;
-    hookSize: number;
-    durability: number;
-    bonusCatchRate?: number;
-    bonusRarity?: number;
-}
-export type FishingState = 'idle' | 'casting' | 'waiting' | 'nibble' | 'bite' | 'fighting' | 'reeling' | 'caught' | 'escaped';
-export interface FishingSession {
-    id: string;
-    fisherId: FisherId;
-    spotId: FishingSpotId;
-    baitId?: BaitId;
-    tackleId?: TackleId;
-    state: FishingState;
-    castPosition: Vector3;
-    startTime: number;
-    hookedFish?: {
-        speciesId: FishSpeciesId;
-        weight: number;
-        length: number;
-        stamina: number;
-        tension: number;
-    };
-    baitRemaining: number;
-    lineIntegrity: number;
-    fishCaught: CaughtFish[];
-}
-export interface CaughtFish {
-    id: FishId;
-    speciesId: FishSpeciesId;
-    weight: number;
-    length: number;
-    caughtAt: number;
-    isTrophy: boolean;
-}
-export interface FisherStats {
-    fisherId: FisherId;
-    skillLevel: number;
-    experience: number;
-    totalCatches: number;
-    largestCatch: {
-        speciesId: FishSpeciesId;
-        weight: number;
-    } | null;
-    speciesCaught: Set<FishSpeciesId>;
-    trophies: Map<FishSpeciesId, CaughtFish>;
-}
-export type FishingEventType = 'session-started' | 'session-ended' | 'cast' | 'nibble' | 'bite' | 'hook' | 'fish-caught' | 'fish-escaped' | 'line-snapped' | 'bait-consumed' | 'skill-gained' | 'trophy-caught' | 'spot-depleted';
-export interface FishingEvent {
-    type: FishingEventType;
-    fisherId: FisherId;
-    spotId?: FishingSpotId;
-    data?: Record<string, unknown>;
-}
-export interface FishingSystemConfig {
-    baseWaitTime?: {
-        min: number;
-        max: number;
-    };
-    nibbleWindow?: number;
-    biteWindow?: number;
-    tensionDecayRate?: number;
-    tensionBuildRate?: number;
-    maxTension?: number;
-    experienceMultiplier?: number;
-    spotRespawnInterval?: number;
-}
-export declare const DEFAULT_FISHING_CONFIG: FishingSystemConfig;
-export declare class NiceFishing extends EventEmitter {
-    private fishSpecies;
-    private fishingSpots;
-    private baits;
-    private tackles;
-    private sessions;
-    private fisherStats;
-    private nextSessionId;
-    private nextFishId;
-    private config;
-    private currentTime;
-    private currentWeather;
-    private currentSeason;
-    constructor(config?: Partial<FishingSystemConfig>);
-    registerSpecies(species: FishSpecies): void;
-    registerSpot(spot: FishingSpot): void;
-    registerBait(bait: Bait): void;
-    registerTackle(tackle: Tackle): void;
-    setTimeOfDay(time: number): void;
-    setWeather(weather: string): void;
-    setSeason(season: string): void;
-    startSession(fisherId: FisherId, spotId: FishingSpotId, options?: {
-        baitId?: BaitId;
-        tackleId?: TackleId;
-    }): boolean;
-    endSession(fisherId: FisherId): CaughtFish[];
-    getSession(fisherId: FisherId): FishingSession | undefined;
-    cast(fisherId: FisherId, targetPosition: Vector3): boolean;
-    reel(fisherId: FisherId): boolean;
-    hook(fisherId: FisherId): boolean;
-    private selectFish;
-    private getRarityMultiplier;
-    reelIn(fisherId: FisherId, intensity?: number): void;
-    releaseTension(fisherId: FisherId): void;
-    private lineSnap;
-    update(deltaTime: number): void;
-    private updateSession;
-    private updateWaiting;
-    private nibbleTimers;
-    private biteTimers;
-    private updateNibble;
-    private updateBite;
-    private updateFighting;
-    private catchFish;
-    private getOrCreateStats;
-    getStats(fisherId: FisherId): FisherStats | undefined;
-    private addExperience;
-}
-export declare function createFishingSystem(config?: Partial<FishingSystemConfig>): NiceFishing;
-export declare function defineSpecies(species: FishSpecies): FishSpecies;
-export declare function defineFishingSpot(spot: Omit<FishingSpot, 'currentFish'> & {
-    fishPopulation: Record<string, number> | Map<string, number>;
-}): FishingSpot;
-export declare function defineBait(bait: Bait): Bait;
-export declare function defineTackle(tackle: Tackle): Tackle;
-export default NiceFishing;

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

@@ -1,156 +0,0 @@
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-export interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export type BoidRole = 'normal' | 'leader' | 'predator' | 'prey' | 'scout' | 'guard';
-export type FlockState = 'idle' | 'wandering' | 'hunting' | 'fleeing' | 'following' | 'defending' | 'formation';
-export interface Boid {
-    id: string;
-    flockId: string;
-    role: BoidRole;
-    position: Vec3;
-    velocity: Vec3;
-    acceleration: Vec3;
-    rotation: number;
-    maxSpeed: number;
-    maxForce: number;
-    mass: number;
-    perception: number;
-    isActive: boolean;
-    neighbors: string[];
-    distanceToLeader?: number;
-    targetPosition?: Vec3;
-    separationForce?: Vec3;
-    alignmentForce?: Vec3;
-    cohesionForce?: Vec3;
-    metadata?: Record<string, unknown>;
-}
-export interface Flock {
-    id: string;
-    name: string;
-    state: FlockState;
-    boids: Map<string, Boid>;
-    leaderId?: string;
-    weights: FlockWeights;
-    targetPosition?: Vec3;
-    targetEntity?: string;
-    formationType?: FormationType;
-    formationSpacing: number;
-    bounds?: FlockBounds;
-    metadata?: Record<string, unknown>;
-}
-export interface FlockWeights {
-    separation: number;
-    alignment: number;
-    cohesion: number;
-    avoidance: number;
-    wander: number;
-    seek: number;
-    flee: number;
-    follow: number;
-    formation: number;
-}
-export interface FlockBounds {
-    min: Vec3;
-    max: Vec3;
-    softEdge: number;
-    force: number;
-}
-export type FormationType = 'none' | 'line' | 'column' | 'wedge' | 'circle' | 'grid' | 'scatter';
-export interface FormationSlot {
-    index: number;
-    offset: Vec3;
-    boidId?: string;
-}
-export interface Obstacle {
-    id: string;
-    type: 'sphere' | 'box' | 'plane';
-    position: Vec3;
-    size: Vec3;
-    isStatic: boolean;
-}
-export type FlockingEventType = 'flock-create' | 'flock-destroy' | 'boid-join' | 'boid-leave' | 'state-change' | 'leader-change' | 'formation-change' | 'target-reached' | 'predator-nearby' | 'collision';
-export interface FlockingEvent {
-    type: FlockingEventType;
-    timestamp: number;
-    flockId: string;
-    data: unknown;
-}
-export type FlockingEventCallback = (event: FlockingEvent) => void;
-export interface FlockingConfig {
-    /** Default max speed */
-    defaultMaxSpeed: number;
-    /** Default max steering force */
-    defaultMaxForce: number;
-    /** Default perception radius */
-    defaultPerception: number;
-    /** Default separation distance */
-    separationDistance: number;
-    /** Spatial hash cell size */
-    cellSize: number;
-    /** Wander circle distance */
-    wanderDistance: number;
-    /** Wander circle radius */
-    wanderRadius: number;
-    /** Wander angle change */
-    wanderJitter: number;
-    /** Arrival slow radius */
-    arrivalRadius: number;
-    /** Default flock weights */
-    defaultWeights: FlockWeights;
-}
-export declare const DEFAULT_FLOCKING_CONFIG: FlockingConfig;
-export declare class NiceFlocking {
-    private config;
-    private flocks;
-    private allBoids;
-    private obstacles;
-    private spatialHash;
-    private eventListeners;
-    private nextId;
-    private wanderAngles;
-    constructor(config?: Partial<FlockingConfig>);
-    on(event: FlockingEventType, callback: FlockingEventCallback): () => void;
-    private emit;
-    createFlock(name: string, options?: Partial<Flock>): string;
-    destroyFlock(flockId: string): void;
-    getFlock(id: string): Flock | undefined;
-    addBoid(flockId: string, position: Vec3, options?: Partial<Boid>): string | null;
-    removeBoid(boidId: string): void;
-    getBoid(id: string): Boid | undefined;
-    setFlockState(flockId: string, state: FlockState): void;
-    setFlockTarget(flockId: string, target: Vec3 | string, state?: FlockState): void;
-    setFormation(flockId: string, type: FormationType): void;
-    addObstacle(obstacle: Omit<Obstacle, 'id'>): string;
-    removeObstacle(id: string): void;
-    update(deltaTime: number): void;
-    private updateFlock;
-    private calculateForces;
-    private seek;
-    private flee;
-    private wander;
-    private follow;
-    private avoidObstacles;
-    private distanceToObstacle;
-    private containWithinBounds;
-    private calculateFormationForce;
-    private getFormationOffset;
-    private applyForce;
-    private updateBoidPhysics;
-    private magnitude;
-    private normalize;
-    private limit;
-    private distance;
-    getFlockCenter(flockId: string): Vec3 | null;
-    getFlockVelocity(flockId: string): Vec3 | null;
-    getBoids(flockId: string): Boid[];
-    getAllFlocks(): Flock[];
-    getBoidsInRadius(position: Vec3, radius: number): Boid[];
-    destroy(): void;
-}
-export declare function createFlockingSystem(config?: Partial<FlockingConfig>): NiceFlocking;

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

@@ -1,137 +0,0 @@
-export type EntityId = string;
-export type TeamId = string;
-export interface Vector2 {
-    x: number;
-    y: number;
-}
-export type VisibilityState = 'hidden' | 'explored' | 'visible';
-export interface VisionSource {
-    id: EntityId;
-    position: Vector2;
-    /** Vision radius in world units */
-    radius: number;
-    /** Height for LOS calculations */
-    height?: number;
-    /** Team this source belongs to */
-    teamId?: TeamId;
-    /** Whether to use line of sight */
-    useLOS?: boolean;
-    /** Angle of cone vision (0 = full circle) */
-    coneAngle?: number;
-    /** Direction for cone vision */
-    coneDirection?: number;
-    active: boolean;
-}
-export interface VisionBlocker {
-    id: string;
-    position: Vector2;
-    radius: number;
-    height?: number;
-    /** Blocks vision completely or partially */
-    opacity: number;
-}
-export interface FogCell {
-    x: number;
-    y: number;
-    /** Current visibility state per team */
-    visibility: Map<TeamId, VisibilityState>;
-    /** Height for LOS */
-    height: number;
-    /** Blocks vision */
-    blocksVision: boolean;
-    /** Last time this cell was visible */
-    lastVisibleTime: Map<TeamId, number>;
-}
-export type FogEventType = 'visibility-changed' | 'area-revealed' | 'area-hidden' | 'entity-spotted' | 'entity-lost';
-export interface FogEvent {
-    type: FogEventType;
-    timestamp: number;
-    teamId?: TeamId;
-    data?: unknown;
-}
-export type FogEventCallback = (event: FogEvent) => void;
-export interface FogConfig {
-    /** Grid cell size in world units */
-    cellSize: number;
-    /** World bounds */
-    worldBounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    /** Default fog state */
-    defaultState: VisibilityState;
-    /** Enable line of sight */
-    enableLOS: boolean;
-    /** LOS ray count for accuracy */
-    losRayCount: number;
-    /** Fade time when losing vision (seconds) */
-    fadeTime: number;
-    /** Remember explored areas */
-    rememberExplored: boolean;
-    /** Update interval (0 = every frame) */
-    updateInterval: number;
-    /** Teams share vision */
-    sharedVision: Map<TeamId, TeamId[]>;
-}
-export declare const DEFAULT_FOG_CONFIG: FogConfig;
-export interface FogRenderData {
-    cells: Array<{
-        x: number;
-        y: number;
-        worldX: number;
-        worldY: number;
-        visibility: VisibilityState;
-        alpha: number;
-    }>;
-    cellSize: number;
-}
-export declare class NiceFog {
-    private config;
-    private grid;
-    private visionSources;
-    private visionBlockers;
-    private gridWidth;
-    private gridHeight;
-    private updateTimer;
-    private cachedVisibility;
-    private eventListeners;
-    constructor(config?: Partial<FogConfig>);
-    private initializeGrid;
-    private cellKey;
-    on(event: FogEventType, callback: FogEventCallback): () => void;
-    private emit;
-    addVisionSource(source: VisionSource): void;
-    updateVisionSource(id: EntityId, updates: Partial<VisionSource>): void;
-    removeVisionSource(id: EntityId): void;
-    getVisionSource(id: EntityId): VisionSource | undefined;
-    addBlocker(blocker: VisionBlocker): void;
-    removeBlocker(id: string): void;
-    setTerrainHeight(gridX: number, gridY: number, height: number, blocksVision?: boolean): void;
-    private invalidateCache;
-    private invalidateCacheAll;
-    private calculateVisibility;
-    private sharesVision;
-    private getVisibleCellsFromSource;
-    private angleDiff;
-    private hasLineOfSight;
-    update(deltaTime: number): void;
-    private updateVisibility;
-    forceUpdate(): void;
-    getVisibility(worldX: number, worldY: number, teamId: TeamId): VisibilityState;
-    isVisible(worldX: number, worldY: number, teamId: TeamId): boolean;
-    isExplored(worldX: number, worldY: number, teamId: TeamId): boolean;
-    isEntityVisible(entityId: EntityId, viewerTeamId: TeamId): boolean;
-    getVisibleEntities(teamId: TeamId): EntityId[];
-    revealArea(worldX: number, worldY: number, radius: number, teamId: TeamId): void;
-    revealAll(teamId: TeamId): void;
-    hideAll(teamId: TeamId): void;
-    getRenderData(teamId: TeamId): FogRenderData;
-    setSharedVision(teamId: TeamId, sharedWith: TeamId[]): void;
-    serialize(): string;
-    deserialize(json: string): void;
-    clear(): void;
-    destroy(): void;
-}
-export declare function createFogSystem(config?: Partial<FogConfig>): NiceFog;