@nice2dev/game-engine 1.1.5 → 1.1.6

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

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

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

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

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