This method allows to add a new node to this environment in a specific position. The environment is responsible to call the right method of the simulation in order to ensure that the reaction is properly scheduled. The function returns true if the node is added to the environment.

addTerminator

open fun addTerminator(terminator: (Environment<T, Euclidean2DPosition>) -> Boolean)

Add a terminator indicating whether the simulation should be considered finished.

open override fun addTerminator(terminator: TerminationPredicate<T, Euclidean2DPosition>)

Add a terminator indicating whether the simulation should be considered finished.

farthestPositionReachable

open override fun farthestPositionReachable(node: Node<T>, desiredPosition: Euclidean2DPosition, hitboxRadius: Double): Euclidean2DPosition

Computes the farthest position reachable by a node towards a desiredPosition, avoiding node overlapping. If no node is located in between, desiredPosition is returned. Otherwise, the first position where the node collides with someone else is returned. For collision purposes, hitboxes are used: each node is given a circular hitbox of radius equal to its shape's radius (shapeless nodes can't cause overlapping). The client can specify a different radius for the hitbox of the moving node.

forEach

override fun forEach(action: Consumer<in Node<T>>)

getDistanceBetweenNodes

override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double

Measures the distance between two nodes (n1, n2) in the environment.

getHeading

open override fun getHeading(node: Node<T>): <Error class: unknown class>

Gets the heading of a node as a direction vector.

getLayer

override fun getLayer(molecule: Molecule): Layer<T, Euclidean2DPosition>?

Get the Layer associate to the given molecule. If no Layer is associated with the given molecule, return null.

getNeighborhood

override fun getNeighborhood(node: Node<T>): Neighborhood<T>

Given a node, this method returns its neighborhood.

getNodeByID

override fun getNodeByID(id: Int): Node<T>

Allows to access a Node in this Environment known its id. Depending on the implementation, this method may or not be optimized (namely, id could run in constant or linear time with the number of nodes).

getNodesWithin

open override fun getNodesWithin(shape: Euclidean2DShape): List<Node<T>>

Gets all nodes whose shape.intersect is true for the given shape.

getNodesWithinRange

override fun getNodesWithinRange(node: Node<T>, range: Double): ListSet

Given a node this method returns a list of all the surroundings nodes within the given range. Note that this method (depending on the implementation) might be not optimized, and it's consequently much better to use Environment.getNeighborhood and filter the neighborhood if you are sure that all the nodes within the range are connected to the center.

override fun getNodesWithinRange(position: Euclidean2DPosition, range: Double): ListSet

Given a position this method returns a list of all the surroundings nodes within the given range. Note that this method (depending on the implementation) might be not optimized.

getPosition

override fun getPosition(node: Node<T>): Euclidean2DPosition

Calculates the position of a node.

getShape

open override fun getShape(node: Node<T>): Euclidean2DShape

Gets the shape of a node relatively to its position and heading in the environment.

iterator

operator override fun iterator(): Iterator<Node<T>>

makePosition

open fun makePosition(coordinates: List<Number>): Euclidean2DPosition

Given the coordinates of the point, returns a Position compatible with this environment.

open fun makePosition(x: Double, y: Double): Euclidean2DPosition

open fun makePosition(x: Number, y: Number): Euclidean2DPosition

Creates a new Euclidean2DPosition.

open override fun makePosition(vararg coordinates: Number): <Error class: unknown class>

Creates an euclidean position from the given coordinates.

moveNode

open fun moveNode(node: Node<T>, direction: Euclidean2DPosition)

This method moves a node in the environment toward some direction. If node move is unsupported, it does nothing. Subclasses may override this method if they want to change the way a node moves towards some direction. The current implementation internally calls {@link #moveNodeToPosition(Node, Position2D)}, as such, overriding that method may suffice.

moveNodeToPosition

open override fun moveNodeToPosition(node: Node<T>, newPosition: Euclidean2DPosition)

Moves the node to the farthestPositionReachable towards the desired newPosition. If the node is shapeless, it is simply moved to newPosition.

randomElement

fun <R> Iterable<R>.randomElement(randomGenerator: <Error class: unknown class>): R

Returns a random element of the Iterable using the provided randomGenerator.

removeGlobalReaction

open override fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

removeNode

override fun removeNode(node: Node<T>)

This method allows to remove a node. If node removal is unsupported, it does nothing.

setHeading

open override fun setHeading(node: Node<T>, direction: Euclidean2DPosition)

Sets the heading of a node.

shuffled

fun <R> Iterable<R>.shuffled(randomGenerator: <Error class: unknown class>): Iterable<R>

Fisher–Yates shuffle algorithm using a RandomGenerator. More information on Wikipedia.

spliterator

override fun spliterator(): Spliterator<Node<T>>

subscriptionMonitor

fun <T, P : Position<out P>> Environment<T, P>.subscriptionMonitor(): EnvironmentSubscriptionMonitor<T, P>

Returns the EnvironmentSubscriptionMonitor of this Environment.

toEnvironmentSurrogate

fun <T, P : Position<out P>, TS : Any> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS): EnvironmentSurrogate<TS, PositionSurrogate>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate). Use the toSuitablePositionSurrogate strategy for PositionSurrogate mapping.

fun <T, P : Position<out P>, TS : Any, PS : PositionSurrogate> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS, toPositionSurrogate: (P) -> PS): EnvironmentSurrogate<TS, PS>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate).

toGraphQLEnvironmentSurrogate

fun <T, P : Position<out P>> Environment<T, P>.toGraphQLEnvironmentSurrogate(): EnvironmentSurrogate<T, P>

Converts an Environment to a EnvironmentSurrogate.

toString

open override fun toString(): String

Not used internally. Override as you please.