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

LimitedContinuos2D

abstract class LimitedContinuos2D<T> : ContinuousPhysics2DEnvironment<T>

This class represents a 2D continuous environment with spatial limitations. Those limitations will prevent nodes to move in positions which are not allowed.

Parameters

<T>

concentration type

Inheritors

Continuous2DObstacles

Constructors

LimitedContinuos2D

constructor(incarnation: Incarnation<T, Euclidean2DPosition>)

Properties

val Companion: ContinuousPhysics2DEnvironment.Companion

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(reaction: GlobalReaction<T>)

fun addLayer(m: Molecule, l: Layer<T, P>)

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

fun addTerminator(terminator: 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(action: Consumer<in Node<T>>)

fun getDimensions(): Int

getDistanceBetweenNodes

fun getDistanceBetweenNodes(n1: Node<T>, n2: 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(m: Molecule): Optional<Layer<T, P>>

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

fun getLinkingRule(): LinkingRule<T, P>

getNeighborhood

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

fun getNodeByID(id: 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(center: Node<T>, range: Double): ListSet<Node<T>>

fun getOffset(): Array<Double>

open fun getOrigin(): P

open fun getOrigin(): Euclidean2DPosition

fun getPosition(node: 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>

fun isTerminated(): Boolean

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

abstract fun iterator(): Iterator<T>

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

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

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

Creates an euclidean position from the given coordinates.

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

moveNodeToPosition

open fun moveNodeToPosition(node: Node<T>, newpos: P)

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

Moves the node to the farthestPositionReachable towards the desired newPosition.

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

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

removeGlobalReaction

open fun removeGlobalReaction(reaction: GlobalReaction<T>)

fun removeNode(node: Node<T>)

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

Sets the heading of a node.

fun setLinkingRule(r: 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