Construct a new CollisionRateLimiterArray.

Construct a new entity manager.

create a new SORTED UpdatedEntityList by giving it a channel on which it will receive entity IDs.

create a new UpdatedEntityList by giving it a channel on which it will receive entity IDs.

Construct a new EventFilter which asks about Type and a user-given predicate.

translated from SDL2's SDL_HasIntersection(SDL_Rect * A, SDL_Rect * B) takes rectanges defined with pos in the center of the rect.

takes rectanges defined with pos in the center of the rect.

Construct a new EventFilter which only asks about the Type of the event.

Returns the index to insert x at (could be len(a) if it would be new max).

produce a function which will act like fmt.Sprintf but be silent or not based on a supplied boolean value (below the function definition in this file you can find all of them used).

a subscriber getting 4096 events in a single update tick is insane, but memory is plentiful so, allow some capacity to build up.

AudioManager stores audio as mix.Chunk pointers, keyed by strings (filenames).

Defines a kind of trianglular 2D array which allows you to store a RateLimiter at the intersection of each entity ID and each other entity ID, assuming they are indexed [i][j] where i < j ("collision-indexing") For example, the table would look like the following if we had MAX_ENTITIES = 5, where r is a rate limiter (atomic.Uint32): j 0 1 2 3 4 0 r r r r 1 r r r i 2 r r 3 r 4 */ The rows are actually slices of a contiguous backing array, to make sure the rate limiters are all loaded in the same cache line (the motiviation entirely behind maintaining this weird triangle despite having a tricky algoirthm to expand if we increase max entities at runtime; it would be far simpler to just use a 2d array, use only the handshake cells, and it is trivial to expand.

the EntityManager is requested to despawn an entity.

used by the EntityManager to hold info about the allocated entities.

Provides services related to entities.

a state val which can *set* modal values in the worldstate as the action chain runs forward, and which can *read* modal values when an action's pre is being checked.

moves entities according to their velocity.

Like the above, but it can be reset while sleeping.

used to store a set of logicUnits which want to be executed together and frequently, but which are tolerant of being partitioned in time in order to stay within a certain time constraint (for example, running all the world logic we can within 4 milliseocnds, picking up where we left off next Update() loop).

responsible for spawning screen message entities managing their lifecycles, and destroying their resources when needed.

used to compute the spatial hash tables given a list of entities.

a list of entities which have active = true, which receives updates to its contents via the Signal() method.

simple 2D vector geometry class.

used so that game code using the engine can define their own contiguous arrays of complex struct types and take advantage of cache-line performance rather than use the `Generic` component type which stores `interface{}` (thus involves dynamic allocation peppered through memory that won't have nice contigous cache lines) the user should define the Allocate() function so that it allocates the contiguous memory (slice), and Name() should return the name, for example, if the CCC is holding StateTree objects, the name should be "StateTree" notice that the accessor method is defined for generic pointer return, which corresponds to the Entity.GetCustom() method defined in component_table.go so, user code should cast to the appropriate type on retrieval for example: st := e.GetCustom("StateTree").(*StateTree).

used to communicate insert / remove events.

SpatialHashTable is the table of cells; the actual data structure is a gridX x gridY matrix where each cell is []*Entity.