alchemist-physics/it.unibo.alchemist.model.physics/PhysicsEnvironment

PhysicsEnvironment

interface PhysicsEnvironment<T, P : Position, Vector, A : Transformation, F : GeometricShapeFactory<P, A>> : EuclideanEnvironment<T, P> (source)

An environment supporting physics and nodes shapes. Note: due to the high number of parameters it's highly recommended not to use this interface directly, but to create an apposite interface extending this one instead.

Parameters

factory of shapes compatible with this environment

Inheritors

Physics2DEnvironment

PhysicsEnvironmentWithObstacles

Properties

currentPosition

open val Node<T>.currentPosition: P

dimensions

abstract val dimensions: Int

incarnation

abstract val incarnation: Incarnation<T, P>

isTerminated

abstract val isTerminated: Boolean

layers

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

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: P

position

open val Node<T>.position: Observable

reactions

abstract val reactions: ObservableList<Reaction<T>>

shapeFactory

abstract val shapeFactory: F

A factory of shapes compatible with this environment.

simulation

abstract var simulation: Simulation<T, P>

simulationOrNull

abstract val simulationOrNull: Simulation<T, P>?

size

abstract val size: DoubleArray

sizeInDistanceUnits

abstract val sizeInDistanceUnits: DoubleArray

Functions

addLayer

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

addNode

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

addReaction

abstract fun addReaction(reaction: Reaction<T>)

addTerminator

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

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

contains

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

currentPositionOf

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

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: P): P

getHeading

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

Gets the heading of a node as a direction vector.

getNodesWithin

abstract fun getNodesWithin(shape: Shape<P, A>): List<Node<T>>

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

getShape

abstract fun getShape(node: Node<T>): Shape<P, A>

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

layerFor

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

makePosition

abstract fun makePosition(coordinates: DoubleArray): P

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

abstract fun makePosition(vararg coordinates: Number): P

moveBy

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

moveNodeBy

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

moveNodeTo

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

moveTo

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

neighborhoodOf

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

nodesAround

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

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

nodesInRange

open fun P.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: P, range: Double): ObservableSet<Node<T>>

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

observeNodesInRange

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

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

positionOf

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

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: P)

Sets the heading of a node.

toPosition

open fun DoubleArray.toPosition(): P