alchemist-physics/it.unibo.alchemist.model.physics.environments/ContinuousPhysics2DEnvironment

ContinuousPhysics2DEnvironment

open class ContinuousPhysics2DEnvironment<T>(incarnation: Incarnation<T, Euclidean2DPosition>) : Continuous2DEnvironment<T> , Physics2DEnvironment<T> (source)

Implementation of Physics2DEnvironment.

Inheritors

AbstractLimitedContinuous2D

Constructors

ContinuousPhysics2DEnvironment

constructor(incarnation: Incarnation<T, Euclidean2DPosition>)

Properties

currentPosition

open val Node<T>.currentPosition: Euclidean2DPosition

override val dimensions: Int

override val incarnation: Incarnation<T, Euclidean2DPosition>

open override val isTerminated: Boolean

override val layers: Map<Molecule, Layer<T, Euclidean2DPosition>>

open val Node<T>.neighborhood: Observable<Neighborhood<T>>

override var networkModel: NetworkModel<T>

override val nodeCount: Observable<Int>

open override val nodes: ObservableList<Node<T>>

override val offset: DoubleArray

open override val origin: Euclidean2DPosition

open val Node<T>.position: Observable<Euclidean2DPosition>

open override val reactions: ObservableList<Reaction<T>>

open override val shapeFactory: Euclidean2DShapeFactory

A factory of shapes compatible with this environment.

override var simulation: Simulation<T, Euclidean2DPosition>

simulationOrNull

override var simulationOrNull: Simulation<T, Euclidean2DPosition>?

override val size: DoubleArray

sizeInDistanceUnits

open override val sizeInDistanceUnits: DoubleArray

Functions

open override fun addLayer(molecule: Molecule, layer: Layer<T, Euclidean2DPosition>)

open override fun addNode(node: Node<T>, position: Euclidean2DPosition): Boolean

open override fun addReaction(reaction: Reaction<T>)

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

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

open operator override fun contains(node: Node<T>): Boolean

currentPositionOf

open override fun currentPositionOf(node: Node<T>): Euclidean2DPosition

distanceBetween

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

open fun Node<T>.distanceTo(other: Node<T>): Double

farthestReachablePosition

open override fun farthestReachablePosition(node: Node<T>, desired: Euclidean2DPosition): Euclidean2DPosition

The farthest position reachable by node towards desired, avoiding node overlapping. Other nodes, considered through circular hitboxes of radius equal to the one of their shape, stop the movement where the hitbox of node first touches theirs; nodes already colliding with node stop it at its current position. Shapeless nodes do not collide.

open override fun getHeading(node: Node<T>): Euclidean2DPosition

Gets the heading of a node as a direction vector.

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

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

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

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

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

open fun makePosition(coordinates: DoubleArray): Euclidean2DPosition

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

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

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

open override fun makePosition(vararg coordinates: Number): Euclidean2DPosition

Creates an euclidean position from the given coordinates.

open fun Node<T>.moveBy(displacement: Euclidean2DPosition)

open fun moveNodeBy(node: Node<T>, displacement: Euclidean2DPosition)

open override fun moveNodeTo(node: Node<T>, position: Euclidean2DPosition)

open fun Node<T>.moveTo(position: Euclidean2DPosition)

open override fun neighborhoodOf(node: Node<T>): Observable<Neighborhood<T>>

open override fun nodesAround(position: Euclidean2DPosition, range: Double): List<Node<T>>

open override fun nodesAround(node: Node<T>, range: Double): List<Node<T>>

open fun Euclidean2DPosition.nodesInRange(range: Double): List<Node<T>>

open fun Node<T>.nodesInRange(range: Double): List<Node<T>>

open override fun nodeWithId(id: Int): Node<T>

observeLayerValue

open override fun observeLayerValue(molecule: Molecule, node: Node<T>): Observable<T?>

observeNodesAround

open override fun observeNodesAround(position: Euclidean2DPosition, range: Double): ObservableSet<Node<T>>

open override fun observeNodesAround(node: Node<T>, range: Double): ObservableSet<Node<T>>

observeNodesInRange

open fun Euclidean2DPosition.observeNodesInRange(range: Double): ObservableSet<Node<T>>

open fun Node<T>.observeNodesInRange(range: Double): ObservableSet<Node<T>>

open override fun positionOf(node: Node<T>): Observable<Euclidean2DPosition>

open fun Node<T>.remove()

open fun Reaction<T>.remove()

open override fun removeNode(node: Node<T>)

open override fun removeReaction(reaction: Reaction<T>)

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

Sets the heading of a node.

open fun DoubleArray.toPosition(): Euclidean2DPosition

open override fun toString(): String