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

PhysicsEnvironmentWithObstacles

interface PhysicsEnvironmentWithObstacles<W : Obstacle, T, P : Position, Vector, A : Transformation, N : ConvexShape<P, A>, E, F : GeometricShapeFactory<P, A>> : EnvironmentWithGraph<W, T, P, A, N, E> , PhysicsEnvironment<T, P, A, F> (source)

An EnvironmentWithGraph supporting physics.

Inheritors

EuclideanPhysics2DEnvironmentWithGraph

Properties

currentPosition

open val Node<T>.currentPosition: P

dimensions

abstract val dimensions: Int

graph

abstract val graph: NavigationGraph<P, A, N, E>

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

obstacles

abstract val obstacles: List<W>

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

addObstacle

abstract fun addObstacle(obstacle: W)

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 W.remove(): Boolean

open fun Reaction<T>.remove()

removeNode

abstract fun removeNode(node: Node<T>)

removeObstacle

abstract fun removeObstacle(obstacle: W): Boolean

removeReaction

abstract fun removeReaction(reaction: Reaction<T>)

setHeading

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

Sets the heading of a node.

shortestPathIntersectsObstacle

abstract fun shortestPathIntersectsObstacle(start: P, end: P): Boolean

shortestPathToIntersectsObstacle

open fun P.shortestPathToIntersectsObstacle(other: P): Boolean

toPosition

open fun DoubleArray.toPosition(): P