alchemist-cognitive-agents/it.unibo.alchemist.model.cognitive.environments/EnvironmentWithDynamics

EnvironmentWithDynamics

class EnvironmentWithDynamics<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String? = null, zoom: Double = 1.0, dx: Double = 0.0, dy: Double = 0.0, obstaclesColor: Int = Color.BLACK.rgb, roomsColor: Int = Color.BLUE.rgb, backingEnvironment: Physics2DEnvironment<T> = path?.let { ImageEnvironmentWithGraph(incarnation, it, zoom, dx, dy, obstaclesColor, roomsColor) } ?: ContinuousPhysics2DEnvironment(incarnation)) : Dynamics2DEnvironment<T> , EuclideanPhysics2DEnvironmentWithObstacles<RectObstacle2D<Euclidean2DPosition>, T> (source)

This Environment uses hooks provided by Dynamics2DEnvironment to update the physical world, It also applies physical properties to any added node to perform collision detection and response. If an image path is provided a backing ImageEnvironmentWithGraph is used, otherwise the Continuous2DEnvironment will be used.

Constructors

EnvironmentWithDynamics

constructor(incarnation: Incarnation<T, Euclidean2DPosition>, path: String? = null, zoom: Double = 1.0, dx: Double = 0.0, dy: Double = 0.0, obstaclesColor: Int = Color.BLACK.rgb, roomsColor: Int = Color.BLUE.rgb, backingEnvironment: Physics2DEnvironment<T> = path?.let { ImageEnvironmentWithGraph(incarnation, it, zoom, dx, dy, obstaclesColor, roomsColor) } ?: ContinuousPhysics2DEnvironment(incarnation))

Properties

currentPosition

open override val Node<T>.currentPosition: Euclidean2DPosition

open override val dimensions: Int

open override val incarnation: Incarnation<T, Euclidean2DPosition>

open override val isTerminated: Boolean

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

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

open override var networkModel: NetworkModel<T>

open override val nodeCount: Observable<Int>

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

open override val obstacles: List<RectObstacle2D<Euclidean2DPosition>>

open override val offset: DoubleArray

open override val origin: Euclidean2DPosition

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

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

open override val shapeFactory: Euclidean2DShapeFactory

open override var simulation: Simulation<T, Euclidean2DPosition>

simulationOrNull

open override val simulationOrNull: Simulation<T, Euclidean2DPosition>?

open 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 addObstacle(obstacle: RectObstacle2D<Euclidean2DPosition>)

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

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

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

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 override fun Node<T>.distanceTo(other: Node<T>): Double

farthestReachablePosition

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

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

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

getObstaclesInRange

open override fun getObstaclesInRange(center: Euclidean2DPosition, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

open override fun getObstaclesInRange(centerx: Double, centery: Double, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

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

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

hasMobileObstacles

open override fun hasMobileObstacles(): Boolean

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

open override fun makePosition(coordinates: DoubleArray): Euclidean2DPosition

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

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

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

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

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

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

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

Moves node in the backing environment, which enforces its obstacles, then aligns its physical body.

open override 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 override fun Euclidean2DPosition.nodesInRange(range: Double): List<Node<T>>

open override 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 override fun Euclidean2DPosition.observeNodesInRange(range: Double): ObservableSet<Node<T>>

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

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

open override fun Node<T>.remove()

open override fun RectObstacle2D<Euclidean2DPosition>.remove(): Boolean

open override fun Reaction<T>.remove()

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

open override fun removeObstacle(obstacle: RectObstacle2D<Euclidean2DPosition>): Boolean

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

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

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

shortestPathIntersectsObstacle

open override fun shortestPathIntersectsObstacle(start: Euclidean2DPosition, end: Euclidean2DPosition): Boolean

shortestPathToIntersectsObstacle

open override fun Euclidean2DPosition.shortestPathToIntersectsObstacle(other: Euclidean2DPosition): Boolean

open override fun DoubleArray.toPosition(): Euclidean2DPosition

open override fun updatePhysics(elapsedTime: Double)