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

Continuous2DObstacles

open class Continuous2DObstacles<T> : LimitedContinuos2D<T> , EuclideanPhysics2DEnvironmentWithObstacles<W, T>

Parameters

<T>

concentration type

Inheritors

ImageEnvironment

Constructors

Continuous2DObstacles

constructor(incarnation: Incarnation<T, Euclidean2DPosition>)

Properties

globalReactions

val globalReactions: ListSet<GlobalReaction<T>>

open val incarnation: Incarnation<T, P>

val nodes: ListSet<Node<T>>

val shapeFactory: Euclidean2DShapeFactory

A factory of shapes compatible with this environment.

open var simulation: Simulation<T, P>

Functions

addGlobalReaction

open fun addGlobalReaction(p: GlobalReaction<T>)

fun addLayer(p: Molecule, p1: Layer<T, P>)

fun addNode(p: Node<T>, p1: P): Boolean

fun addObstacle(@Nonnull o: RectObstacle2D<Euclidean2DPosition>)

fun addTerminator(p: Predicate<Environment<T, P>>)

farthestPositionReachable

abstract fun farthestPositionReachable(node: Node<T>, desiredPosition: P, hitboxRadius: Double): P

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.

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

fun forEach(p: Consumer<in Node<T>>)

fun getDimensions(): Int

getDistanceBetweenNodes

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

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

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

Gets the heading of a node as a direction vector.

fun getLayer(p: Molecule): Optional<Layer<T, P>>

fun getLayers(): ListSet<Layer<T, P>>

fun getLinkingRule(): LinkingRule<T, P>

getNeighborhood

fun getNeighborhood(p: Node<T>): Neighborhood<T>

fun getNodeByID(p: Int): Node<T>

fun getNodeCount(): Int

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

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

getNodesWithinRange

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

@Nonnull

fun getObstacles(): List<RectObstacle2D<Euclidean2DPosition>>

getObstaclesInRange

@Nonnull

fun getObstaclesInRange(@Nonnull center: Euclidean2DPosition, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

@Nonnull

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

fun getOffset(): Array<Double>

open fun getOrigin(): P

open fun getOrigin(): Euclidean2DPosition

fun getPosition(p: Node<T>): P

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

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

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

getShapeFactory

abstract fun getShapeFactory(): F

A factory of shapes compatible with this environment.

fun getSize(): Array<Double>

getSizeInDistanceUnits

open fun getSizeInDistanceUnits(): Array<Double>

hasMobileObstacles

open fun hasMobileObstacles(): Boolean

Subclasses dealing with mobile obstacles may change this.

intersectsObstacle

fun intersectsObstacle(start: Euclidean2DPosition, end: Euclidean2DPosition): Boolean

fun isTerminated(): Boolean

fun iterator(): Iterator<Node<T>>

abstract fun iterator(): Iterator<T>

abstract fun makePosition(p: Array<Number>): P

open fun makePosition(p: Double, p1: Double): Euclidean2DPosition

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

Creates an euclidean position from the given coordinates.

open fun moveNode(p: Node<T>, p1: P)

moveNodeToPosition

open fun moveNodeToPosition(p: Node<T>, p1: P)

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

open fun moveNodeToPosition(@Nonnull node: Node<T>, newPos: Euclidean2DPosition)

Moves the node to the farthestPositionReachable towards the desired newPosition.

@Nonnull

fun next(@Nonnull current: Euclidean2DPosition, @Nonnull desired: Euclidean2DPosition): Euclidean2DPosition

fun next(ox: Double, oy: Double, nx: Double, ny: Double): Euclidean2DPosition

This method must calculate the ABSOLUTE next allowed position given the current position and the position in which the node wants to move.

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

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

removeGlobalReaction

open fun removeGlobalReaction(p: GlobalReaction<T>)

fun removeNode(p: Node<T>)

fun removeObstacle(@Nonnull o: RectObstacle2D<Euclidean2DPosition>): Boolean

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

Sets the heading of a node.

fun setLinkingRule(p: LinkingRule<T, P>)

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

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

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

open fun spliterator(): Spliterator<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 fun toString(): String