agentjs-core/dist/core/environment/ContinuousSpace.d.ts

A comprehensive agent-based modeling framework with built-in p5.js visualization

/**
 * ContinuousSpace - Continuous 2D spatial environment implementation
 */
import { Environment, SpatialQueryResult } from './Environment';
import type { Agent } from '../agents/Agent';
import type { Position } from '../../types/core';
import type { ContinuousSpaceConfig, NeighborQueryOptions, DistanceFunction } from '../../types/spatial';
/**
 * ContinuousSpace - 2D environment with floating-point coordinates
 *
 * Features:
 * - Floating-point position precision
 * - Spatial indexing with quadtree for performance
 * - Efficient neighbor queries within radius
 * - Multiple distance calculation methods
 * - Boundary condition handling
 *
 * Educational Context: Represents physical spaces where
 * community members can move freely with precise positioning,
 * such as geographic areas, meeting spaces, or virtual worlds.
 */
export declare class ContinuousSpace extends Environment {
    /** Spatial configuration */
    private readonly config;
    /** Quadtree root for spatial indexing */
    private quadtree;
    /** Distance calculation function */
    private distanceFunction;
    constructor(configOrWidth: ContinuousSpaceConfig | number, height?: number);
    /**
     * Find agents within radius of position
     */
    findNeighbors(position: Position, radius: number, options?: NeighborQueryOptions): SpatialQueryResult<Agent>;
    /**
     * Get agents at specific position (within small tolerance)
     */
    getAgentsAt(position: Position): ReadonlyArray<Agent>;
    /**
     * Set custom distance function
     */
    setDistanceFunction(fn: DistanceFunction): void;
    /**
     * Get Manhattan distance function
     */
    static getManhattanDistance(): DistanceFunction;
    /**
     * Get Euclidean distance function (default)
     */
    static getEuclideanDistance(): DistanceFunction;
    /**
     * Get Chebyshev distance function (max of x,y differences)
     */
    static getChebyshevDistance(): DistanceFunction;
    /**
     * Get current configuration
     */
    getConfig(): ContinuousSpaceConfig;
    /**
     * Update spatial configuration
     */
    updateConfig(newConfig: Partial<ContinuousSpaceConfig>): void;
    /**
     * Get quadtree statistics
     */
    getQuadtreeStats(): {
        nodeCount: number;
        maxDepth: number;
        agentCount: number;
    };
    /**
     * Force rebuild of spatial index
     */
    rebuildQuadtree(): void;
    /**
     * Check if quadtree needs rebalancing
     */
    needsRebalancing(): boolean;
    /**
     * Rebalance quadtree for optimal performance
     */
    rebalanceQuadtree(): void;
    /**
     * Sort agents by Morton code (Z-order) for better spatial locality
     */
    private sortByMortonCode;
    /**
     * Calculate Morton code (Z-order) for a position
     */
    private calculateMortonCode;
    /**
     * Merge quadtree nodes if they're underutilized
     */
    private tryMergeNode;
    /**
     * Optimize quadtree by merging underutilized nodes
     */
    optimizeQuadtree(): void;
    /**
     * Recursively optimize quadtree nodes
     */
    private optimizeNode;
    /**
     * Hook: Handle agent addition
     */
    protected onAgentAdded(agent: Agent, position: Position): void;
    /**
     * Hook: Handle agent removal
     */
    protected onAgentRemoved(agent: Agent): void;
    /**
     * Hook: Handle agent movement
     */
    protected onAgentMoved(agent: Agent, _oldPosition: Position, newPosition: Position): void;
    /**
     * Initialize quadtree structure
     */
    private initializeQuadtree;
    /**
     * Insert agent into quadtree
     */
    private insertIntoQuadtree;
    /**
     * Remove agent from quadtree
     */
    private removeFromQuadtree;
    /**
     * Insert agent into specific quadtree node
     */
    private insertIntoNode;
    /**
     * Remove agent from quadtree node
     */
    private removeFromNode;
    /**
     * Split quadtree node into four children
     */
    private splitNode;
    /**
     * Query quadtree for agents within radius
     */
    private queryQuadtree;
    /**
     * Query specific quadtree node
     */
    private queryNode;
    /**
     * Check if point is within bounds
     */
    private pointInBounds;
    /**
     * Check if circle intersects with bounds
     */
    private circleIntersectsBounds;
    /**
     * Calculate quadtree statistics
     */
    private calculateQuadtreeStats;
}
//# sourceMappingURL=ContinuousSpace.d.ts.map