geary-core/com.mineinabyss.geary.datatypes/Entity

Entity

@Serializable

@JvmInline

value class Entity(val id: EntityId)

A wrapper around EntityId that gets inlined to just a long (no performance degradation since no boxing occurs).

Provides some useful functions so we aren't forced to go through Engine every time we want to do some things.

Constructors

Entity

constructor(id: EntityId)

Functions

add

inline fun <T : Component> add(noEvent: Boolean = false)

Adds the type T to this entity's type, setting no data.

fun add(component: ComponentId, noEvent: Boolean = false)

Adds a component to this entity's type, setting no data.

addAll

fun addAll(components: Collection<ComponentId>, noEvent: Boolean = false)

Adds a list of components to this entity's type, setting no data.

addChild

fun Entity.addChild(child: Entity)

Adds a child entity to this entity.

addChildren

fun Entity.addChildren(children: Array<Entity>)

Adds a list of children entities to this entity.

addParent

fun Entity.addParent(parent: Entity)

Adds a parent entity to this entity.

addParents

fun Entity.addParents(parents: Array<Entity>)

Adds a list of parents entities to this entity.

addRelation

inline fun <K : Any, T : Any> addRelation(noEvent: Boolean = false)

inline fun <K : Any> addRelation(target: Entity, noEvent: Boolean = false)

callEvent

fun callEvent(event: Entity, source: Entity? = null)

Calls an event using a specific entity on this entity.

inline fun callEvent(source: Entity? = null, crossinline initEvent: Entity.() -> Unit)

Calls an event on this entity using a temporary entity that can be configured with initEvent.

fun callEvent(vararg components: Any, source: Entity? = null)

Calls an event with components attached to it and this entity as the target.

inline fun <T> callEvent(vararg components: Any, source: Entity? = null, crossinline result: (event: Entity) -> T): T

Calls an event with components attached to it and this entity as the target, calculating a result after all handlers have run.

inline fun <T> callEvent(crossinline init: Entity.() -> Unit, source: Entity? = null, crossinline result: (event: Entity) -> T): T

Calls an event on this entity using a temporary entity that can be configured with init, calculating a result after all handlers have run.

clear

fun clear()

Clears all components on this entity.

clearChildren

fun Entity.clearChildren()

Removes all of this entity's children, also unlinking this parent from them.

clearParents

fun Entity.clearParents()

Removes all of this entity's parents, also unlinking this child from them.

component1

operator fun component1(): EntityId

get

inline fun <T : Component> get(): T?

Gets a component of type T on this entity.

fun get(component: ComponentId): Component?

Gets a component which holds data from this entity. Use has if the component is not to hold data.

inline fun <T : Component> get(kClass: KClass<out T>): T?

getAll

fun getAll(): Set<Component>

Gets all the components on this entity, as well as relations in the form of RelationComponent.

getAllNotPersisting

fun getAllNotPersisting(): Set<Component>

Gets all non-persisting components on this entity.

getAllPersisting

fun getAllPersisting(): Set<Component>

Gets all persisting components on this entity.

getOrSet

inline fun <T : Component> getOrSet(kClass: KClass<out T> = T::class, default: () -> T): T

Gets a component of type T or sets a default if no component was present.

getOrSetPersisting

inline fun <T : Component> getOrSetPersisting(kClass: KClass<out T> = T::class, default: () -> T): T

Gets a persisting component of type T or adds a default if no component was present.

getRelation

inline fun <K : Component, T : Component> getRelation(): K?

Gets the data stored under the relation of kind K and target T.

inline fun <K : Component> getRelation(target: Entity): K?

Gets the data stored under the relation of kind K and target target.

getRelations

inline fun <K : Component?, T : Component?> getRelations(): List<Relation>

Queries for relations using the same format as AccessorOperations.getRelations.

fun getRelations(kind: ComponentId, target: EntityId): List<Relation>

getRelationsWithData

inline fun <K : Component?, T : Component?> getRelationsWithData(): List<RelationWithData<K, T>>

Like getRelations, but reads appropriate data as requested and puts it in a RelationWithData object.

has

inline fun <T : Component> has(): Boolean

Checks whether this entity has a component of type T, regardless of it holding data.

fun has(component: ComponentId): Boolean

Checks whether this entity has a component, regardless of it holding data.

inline fun <T : Component> has(kClass: KClass<out T>): Boolean

hasAll

fun hasAll(components: Collection<KClass<*>>): Boolean

Checks whether an entity has all of components set or added.

hasRelation

inline fun <K : Component, T : Component> hasRelation(): Boolean

inline fun <K : Component?> hasRelation(target: Entity): Boolean

instanceOf

fun instanceOf(entity: Entity): Boolean

Checks whether this entity is an instance of another entity (the other is the prefab this entity was made from).

nullOrError

inline fun <T : Component?> Entity.nullOrError(): T

Gets a component of type T from an entity, returning null if T is nullable, or an error otherwise.

onParent

inline fun Entity.onParent(parent: Entity? = this.parent, run: Entity.() -> Unit)

Runs code on the first parent of this entity.

remove

inline fun <T : Component> remove(): Boolean

Removes a component of type T from this entity.

fun remove(component: ComponentId): Boolean

Removes a component with id component from this entity.

fun remove(kClass: KClass<*>): Boolean

Removes a component whose class is kClass from this entity.

removeAll

fun removeAll(components: Collection<ComponentId>): Boolean

Removes a list of components from this entity.

removeChild

fun Entity.removeChild(child: Entity)

Removes a child, also unlinking this parent from that child.

removeEntity

fun removeEntity()

Remove this entity from the ECS.

removeParent

fun Entity.removeParent(parent: Entity)

Removes a parent, also unlinking this child from that parent.

removeRelation

inline fun <K : Component, T : Component> removeRelation(): Boolean

Removes a relation key of type K and value of type V.

inline fun <K : Any> removeRelation(target: Entity): Boolean

set

fun set(components: Collection<Component>)

fun set(component: Component, componentId: ComponentId, noEvent: Boolean = false)

inline fun <T : Component> set(component: T, kClass: KClass<out T> = T::class, noEvent: Boolean = false)

Sets a component that holds data for this entity

setAll

fun setAll(components: Collection<Component>, override: Boolean = true)

Sets components that hold data for this entity

setAllPersisting

fun setAllPersisting(components: Collection<Component>, override: Boolean = true, noEvent: Boolean = false)

Sets a list of persisting components on this entity.

setPersisting

fun setPersisting(components: Collection<Component>): Collection<Component>

inline fun <T : Component> setPersisting(component: T, kClass: KClass<out T> = T::class, noEvent: Boolean = false): T

Sets a persisting component on this entity, which will be serialized if possible.

setRelation

inline fun <K : Any, T : Any> setRelation(data: K, noEvent: Boolean = false)

inline fun <K : Any> setRelation(data: K, target: Entity, noEvent: Boolean = false)

with

inline fun <R, T : Component?> Entity.with(let: (T) -> R): R?

inline fun <R, T : Component?, T2 : Component?> Entity.with(let: (T, T2) -> R): R?

inline fun <T : Component, T2 : Component, T3 : Component> Entity.with(let: (T, T2, T3) -> Unit): Unit?

inline fun <T : Component, T2 : Component, T3 : Component, T4 : Component> Entity.with(let: (T, T2, T3, T4) -> Unit): Unit?

inline fun <T : Component, T2 : Component, T3 : Component, T4 : Component, T5 : Component> Entity.with(let: (T, T2, T3, T4, T5) -> Unit): Unit?

inline fun <T : Component, T2 : Component, T3 : Component, T4 : Component, T5 : Component, T6 : Component> Entity.with(let: (T, T2, T3, T4, T5, T6) -> Unit): Unit?

inline fun <T : Component, T2 : Component, T3 : Component, T4 : Component, T5 : Component, T6 : Component, T7 : Component> Entity.with(let: (T, T2, T3, T4, T5, T6, T7) -> Unit): Unit?

Runs when an entity has all passed components present.

Properties

children

val children: List<Entity>

val id: EntityId

instances

val instances: List<Entity>

parent

val Entity.parent: Entity?

Gets the first parent of this entity

parents

val Entity.parents: Set<Entity>

type

val type: EntityType

Gets this entity's type (the ids of components added to it) or throws an error if it is no longer active on the koinGet().