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

ContinuousPhysics2DEnvironment

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

Implementation of Physics2DEnvironment.

Inheritors

LimitedContinuos2D

Constructors

ContinuousPhysics2DEnvironment

constructor(incarnation: Incarnation<T, Euclidean2DPosition>)

Properties

globalReactions

val globalReactions: ListSet<GlobalReaction<T>>

val nodes: ListSet<Node<T>>

open override val origin: Euclidean2DPosition

open override val shapeFactory: Euclidean2DShapeFactory

A factory of shapes compatible with this environment.

Functions

addGlobalReaction

open override fun addGlobalReaction(p0: GlobalReaction<T>)

override fun addLayer(p0: Molecule, p1: Layer<T, Euclidean2DPosition>)

override fun addNode(p0: Node<T>, p1: Euclidean2DPosition): Boolean

override fun addTerminator(p0: Predicate<Environment<T, Euclidean2DPosition>>)

farthestPositionReachable

open override fun farthestPositionReachable(node: Node<T>, desiredPosition: Euclidean2DPosition, hitboxRadius: Double): Euclidean2DPosition

Computes the farthest position reachable by a node towards a desiredPosition, avoiding node overlapping. If no node is located in between, desiredPosition is returned. Otherwise, the first position where the node collides with someone else is returned. For collision purposes, hitboxes are used: each node is given a circular hitbox of radius equal to its shape's radius (shapeless nodes can't cause overlapping). The client can specify a different radius for the hitbox of the moving node.

override fun forEach(p0: Consumer<in Node<T>>)

override fun getDimensions(): Int

getDistanceBetweenNodes

override fun getDistanceBetweenNodes(p0: Node<T>, p1: Node<T>): Double

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

Gets the heading of a node as a direction vector.

@Nonnull

override fun getIncarnation(): Incarnation<T, Euclidean2DPosition>

override fun getLayer(p0: Molecule): Optional<Layer<T, Euclidean2DPosition>>

override fun getLayers(): ListSet<Layer<T, Euclidean2DPosition>>

override fun getLinkingRule(): LinkingRule<T, Euclidean2DPosition>

getNeighborhood

override fun getNeighborhood(@Nonnull p0: Node<T>): Neighborhood<T>

override fun getNodeByID(p0: Int): Node<T>

override fun getNodeCount(): Int

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

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

getNodesWithinRange

override fun getNodesWithinRange(p0: Node<T>, p1: Double): ListSet<Node<T>>

override fun getNodesWithinRange(p0: Euclidean2DPosition, p1: Double): ListSet<Node<T>>

override fun getOffset(): DoubleArray

@Nonnull

override fun getPosition(p0: Node<T>): Euclidean2DPosition

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

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

@Nonnull

override fun getSimulation(): Simulation<T, Euclidean2DPosition>

override fun getSize(): DoubleArray

getSizeInDistanceUnits

open override fun getSizeInDistanceUnits(): DoubleArray

override fun isTerminated(): Boolean

@Nonnull

operator override fun iterator(): MutableIterator<Node<T>>

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

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

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

Creates an euclidean position from the given coordinates.

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

moveNodeToPosition

open override fun moveNodeToPosition(node: Node<T>, newPosition: Euclidean2DPosition)

Moves the node to the farthestPositionReachable towards the desired newPosition. If the node is shapeless, it is simply moved to newPosition.

fun <R> Iterable<R>.randomElement(randomGenerator: RandomGenerator): R

Returns a random element of the Iterable using the provided randomGenerator.

removeGlobalReaction

open override fun removeGlobalReaction(p0: GlobalReaction<T>)

override fun removeNode(@Nonnull p0: Node<T>)

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

Sets the heading of a node.

override fun setLinkingRule(p0: LinkingRule<T, Euclidean2DPosition>)

override fun setSimulation(p0: Simulation<T, Euclidean2DPosition>)

fun <R> Iterable<R>.shuffled(randomGenerator: RandomGenerator): Iterable<R>

Fisher–Yates shuffle algorithm using a RandomGenerator. More information on Wikipedia.

override fun spliterator(): Spliterator<Node<T>>

subscriptionMonitor

fun <T, P : Position<out P>> Environment<T, P>.subscriptionMonitor(): EnvironmentSubscriptionMonitor<T, P>

Returns the EnvironmentSubscriptionMonitor of this Environment.

toGraphQLEnvironmentSurrogate

fun <T, P : Position<out P>> Environment<T, P>.toGraphQLEnvironmentSurrogate(): EnvironmentSurrogate<T, P>

Converts an Environment to a EnvironmentSurrogate.

open override fun toString(): String