36.0.11

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

InfiniteHalls

class InfiniteHalls<T> : LimitedContinuos2D<T> (source)

Parameters

<T>

concentration type

Constructors

constructor(incarnation: Incarnation<T, Euclidean2DPosition>)

Default builder.

constructor(incarnation: Incarnation<T, Euclidean2DPosition>, size: Double)

constructor(incarnation: Incarnation<T, Euclidean2DPosition>, allOpen: Boolean)

constructor(incarnation: Incarnation<T, Euclidean2DPosition>, size: Double, allOpen: Boolean)

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 addTerminator(p: Predicate<Environment<T, P>>)

open fun allowed(xp: Double, yp: Double): Boolean

Checks whether a position is allowed or not.

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

open fun getHallSize(): 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>>

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>

open fun isDoorsOpen(): 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.

removeGlobalReaction

open fun removeGlobalReaction(p: GlobalReaction<T>)

fun removeNode(p: Node<T>)

open fun setDoorsOpen(isOpen: Boolean)

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

Sets the heading of a node.

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

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

open fun spliterator(): Spliterator<T>

open fun toString(): String