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

Dynamics2DEnvironment

interface Dynamics2DEnvironment<T> : Physics2DEnvironment<T> , Euclidean2DEnvironment<T> (source)

Any implementing Environment should take care of physical dynamics, in particular collision detection and response. This interface provides some hooks in order to be able to manage some of the node's physical state.

Properties

currentPosition

open val Node<T>.currentPosition: Euclidean2DPosition

dimensions

abstract val dimensions: Int

incarnation

abstract val incarnation: Incarnation<T, Euclidean2DPosition>

isTerminated

abstract val isTerminated: Boolean

layers

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

neighborhood

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

networkModel

abstract var networkModel: NetworkModel<T>

nodeCount

abstract val nodeCount: Observable<Int>

nodes

abstract val nodes: ObservableList<Node<T>>

offset

abstract val offset: DoubleArray

origin

open val origin: Euclidean2DPosition

position

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

reactions

abstract val reactions: ObservableList<Reaction<T>>

shapeFactory

abstract val shapeFactory: Euclidean2DShapeFactory

A factory of shapes compatible with this environment.

simulation

abstract var simulation: Simulation<T, Euclidean2DPosition>

simulationOrNull

abstract val simulationOrNull: Simulation<T, Euclidean2DPosition>?

size

abstract val size: DoubleArray

sizeInDistanceUnits

abstract val sizeInDistanceUnits: DoubleArray

Functions

addLayer

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

addNode

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

addReaction

abstract fun addReaction(reaction: Reaction<T>)

addTerminator

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

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

contains

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

currentPositionOf

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

distanceBetween

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

distanceTo

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

farthestReachablePosition

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

getHeading

abstract fun getHeading(node: Node<T>): Euclidean2DPosition

Gets the heading of a node as a direction vector.

getNodesWithin

abstract fun getNodesWithin(shape: Shape<Euclidean2DPosition, Euclidean2DTransformation>): List<Node<T>>

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

getShape

abstract fun getShape(node: Node<T>): Shape<Euclidean2DPosition, Euclidean2DTransformation>

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

getVelocity

abstract fun getVelocity(node: Node<T>): Euclidean2DPosition

Get node's current linear velocity.

layerFor

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

makePosition

open fun makePosition(coordinates: DoubleArray): Euclidean2DPosition

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

open fun makePosition(vararg coordinates: Number): Euclidean2DPosition

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

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

moveBy

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

moveNodeBy

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

moveNodeTo

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

moveTo

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

neighborhoodOf

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

nodesAround

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

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

nodesInRange

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

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

nodeWithId

abstract fun nodeWithId(id: Int): Node<T>

observeLayerValue

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

observeNodesAround

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

abstract 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>>

positionOf

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

remove

open fun Node<T>.remove()

open fun Reaction<T>.remove()

removeNode

abstract fun removeNode(node: Node<T>)

removeReaction

abstract fun removeReaction(reaction: Reaction<T>)

setHeading

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

Sets the heading of a node.

setVelocity

abstract fun setVelocity(node: Node<T>, velocity: Euclidean2DPosition)

Set node's current linear velocity.

toPosition

open fun DoubleArray.toPosition(): Euclidean2DPosition

updatePhysics

abstract fun updatePhysics(elapsedTime: Double)

Compute any collision response and update node positions.