On this page

# AgentList.js

    import * as util from './utils.js'
    import AgentArray from './AgentArray.js'

    /**
     * Geometry methods for patches, turtles, and other AgentArrays
     * Return all agents within rect, radius, cone from given agent.
     * If meToo, include given object, default excludes it
     * Typically the AgentArray is a subset of larger sets, reducing
     * the size, then uses these inRect, inRadius or inCone methods
     */

    class AgentList extends AgentArray {
        /**
         *
         * @param {Model} model The Model this AgentList belongs to
         * @param  {...any} args The arguments passed to super
         */
        constructor(model, ...args) {
            if (!model) throw Error('AgentList requires model')
            super(...args)
            this.model = model
        }

        /**
         * Return all agents within rectangle from given agent.
         * dx & dy are (float) half width/height of rect
         *
         * @param {Agent} agent
         * @param {number} dx
         * @param {number} dy
         * @param {boolean} meToo
         * @returns An AgentList of agents within the rect. Include agent if metoo
         */
        inRect(agent, dx, dy = dx, meToo = false) {
            const agents = new AgentList(this.model)
            const minX = agent.x - dx // ok if max/min off-world, agent, a are in-world
            const maxX = agent.x + dx
            const minY = agent.y - dy
            const maxY = agent.y + dy
            this.ask(a => {
                if (minX <= a.x && a.x <= maxX && minY <= a.y && a.y <= maxY) {
                    if (meToo || agent !== a) agents.push(a)
                }
            })
            return agents
        }

        /**
         * Return all agents in AgentArray within radius from given agent.
         *
         * @param {Agent} agent
         * @param {number} radius
         * @param {boolean} meToo
         * @returns An AgentList of agents within the radius. Include agent if metoo
         */
        inRadius(agent, radius, meToo = false) {
            const agents = new AgentList(this.model)
            // const {x, y} = agent // perf?
            const d2 = radius * radius
            const sqDistance = util.sqDistance // Local function 2-3x faster, inlined?
            this.ask(a => {
                if (sqDistance(agent.x, agent.y, a.x, a.y) <= d2) {
                    if (meToo || agent !== a) agents.push(a)
                }
            })
            return agents
        }

        /**
         * As above, but also limited to the angle `coneAngle` around
         * an `angle` from object `agent`. coneAngle and direction in radians.
         *
         * @param {Agent} agent
         * @param {number} radius
         * @param {number} coneAngle
         * @param {number} heading
         * @param {boolean} meToo
         * @returns An AgentList of agents within the angle. Include agent if metoo
         */
        inCone(agent, radius, coneAngle, heading, meToo = false) {
            heading = this.model.toRads(heading)
            coneAngle = this.model.toAngleRads(coneAngle)

            const agents = new AgentList(this.model)
            this.ask(a => {
                if (
                    util.inCone(
                        a.x,
                        a.y,
                        radius,
                        coneAngle,
                        heading,
                        agent.x,
                        agent.y
                    )
                ) {
                    if (meToo || agent !== a) agents.push(a)
                }
            })
            return agents
        }
    }

    export default AgentList

Type anything to view search result