This steering behavior produces a force that directs an agent toward a target position.
Unlike {@link SeekBehavior}, it decelerates so the agent comes to a gentle halt at the target position.
Class representing a bounding volume hierarchy. The current implementation
represents single BVH nodes as AABBs. It accepts arbitrary branching factors
and can subdivide the given geometry until a defined hierarchy depth has been reached.
Besides, the hierarchy finalruction is performed top-down and the algorithm only
performs splits along the cardinal axes.
This class is used for cell-space partitioning, a basic approach for implementing
a spatial index. The 3D space is divided up into a number of cells. A cell contains a
list of references to all the entities it contains. Compared to other spatial indices like
octrees, the division of the 3D space is coarse and often not balanced but the computational
overhead for calculating the index of a specific cell based on a position vector is very fast.
Class representing a convex hull. This is an implementation of the Quickhull algorithm
based on the presentation {@link http://media.steampowered.com/apps/valve/2014/DirkGregorius_ImplementingQuickHull.pdf Implementing QuickHull}
by Dirk Gregorius (Valve Software) from GDC 2014. The algorithm has an average runtime
complexity of O(nlog(n)), whereas in the worst case it takes O(n²).
Class for representing a fuzzy module. Instances of this class are used by
game entities for fuzzy inference. A fuzzy module is a collection of fuzzy variables
and the rules that operate on them.
Base class for fuzzy sets. This type of sets are defined by a membership function
which can be any arbitrary shape but are typically triangular or trapezoidal. They define
a gradual transition from regions completely outside the set to regions completely
within the set, thereby enabling a value to have partial membership to a set.
Class for representing a fuzzy linguistic variable (FLV). A FLV is the
composition of one or more fuzzy sets to represent a concept or domain
qualitatively. For example fuzzs sets "Dumb", "Average", and "Clever"
are members of the fuzzy linguistic variable "IQ".
Class representing a sparse graph implementation based on adjacency lists.
A sparse graph can be used to model many different types of graphs like navigation
graphs (pathfinding), dependency graphs (e.g. technology trees) or state graphs
(a representation of every possible state in a game).
Class for representing a heuristic for graph search algorithms based
on the euclidean distance. The heuristic assumes that the node have
a position property of type {@link Vector3}.
Class for representing a heuristic for graph search algorithms based
on the squared euclidean distance. The heuristic assumes that the node
have a position property of type {@link Vector3}.
Class for representing a heuristic for graph search algorithms based
on the manhattan distance. The heuristic assumes that the node
have a position property of type {@link Vector3}.
This class is the core of the messaging system for game entities and used by the
{ @link EntityManager}. The implementation can directly dispatch messages or use a
delayed delivery for deferred communication. This can be useful if a game entity
wants to inform itself about a particular event in the future.
Implementation of a navigation mesh. A navigation mesh is a network of convex polygons
which define the walkable areas of a game environment. A convex polygon allows unobstructed travel
from any point in the polygon to any other. This is useful because it enables the navigation mesh
to be represented using a graph where each node represents a convex polygon and their respective edges
represent the neighborly relations to other polygons. More compact navigation graphs lead
to faster graph search execution.
Class for loading navigation meshes as glTF assets. The loader supports
glTF and glb files, embedded buffers, index and non-indexed geometries.
Interleaved geometry data are not yet supported.
Class representing an oriented bounding box (OBB). Similar to an AABB, it's a
rectangular block but with an arbitrary orientation. When using {@link OBB#fromPoints},
the implementation tries to provide a tight-fitting oriented bounding box. In
many cases, the result is better than an AABB or bounding sphere but worse than a
convex hull. However, it's more efficient to work with OBBs compared to convex hulls.
In general, OBB's are a good compromise between performance and tightness.
This steering behavior produces a force that keeps a vehicle close to its path. It is intended
to use it in combination with {@link FollowPathBehavior} in order to realize a more strict path following.
Base class for polyhedra. It is primarily designed for the internal usage in Yuka.
Objects of this class are always build up from faces. The edges, vertices and
the polyhedron's centroid have to be derived from a valid face definition with the
respective methods.
Class for representing a binary heap priority queue that enables
more efficient sorting of arrays. The implementation is based on
{ @link https://github.com/mourner/tinyqueue tinyqueue}.
Not all components of an AI system need to be updated in each simulation step.
This class can be used to control the update process by defining how many updates
should be executed per second.
This class can be used to smooth the result of a vector calculation. One use case
is the smoothing of the velocity vector of game entities in order to avoid a shaky
movements due to conflicting forces.
Base class for all concrete steering behaviors. They produce a force that describes
where an agent should move and how fast it should travel to get there.
This class is responsible for managing the steering of a single vehicle. The steering manager
can manage multiple steering behaviors and combine their produced force into a single one used
by the vehicle.
This class is used for task management. Tasks are processed in an asynchronous
way when there is idle time within a single simulation step or after a defined amount
of time (deadline). The class is a wrapper around {@link https://w3.org/TR/requestidlecallback|requestidlecallback()},
a JavaScript API for cooperative scheduling of background tasks.
Class for representing a telegram, an envelope which contains a message
and certain metadata like sender and receiver. Part of the messaging system
for game entities.
Base class for representing trigger regions. It's a predefine region in 3D space,
owned by one or more triggers. The shape of the trigger can be arbitrary.
This type of game entity implements a special type of locomotion, the so called
Vehicle Model. The class uses basic physical metrics in order to implement a
realistic movement.
This steering behavior produces a steering force that will give the
impression of a random walk through the agent’s environment. The behavior only
produces a 2D force (XZ).
