generic

package
v0.9.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 7, 2023 License: MIT Imports: 3 Imported by: 43

Documentation

Overview

Package generic contains Arche's generic API.

See the top level module github.com/mlange-42/arche for an overview.

Outline

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Comp 

type Comp reflect.Type

Comp is an alias for component types.

func T 

func T[A any]() Comp

T provides a component type from a generic type argument.

func T1 

func T1[A any]() []Comp

T1 creates a component type list for one component types.

func T2 

func T2[A any, B any]() []Comp

T2 creates a component type list for two component types.

func T3 

func T3[A any, B any, C any]() []Comp

T3 creates a component type list for three component types.

func T4 

func T4[A any, B any, C any, D any]() []Comp

T4 creates a component type list for four component types.

func T5 

func T5[A any, B any, C any, D any, E any]() []Comp

T5 creates a component type list for five component types.

func T6 

func T6[A any, B any, C any, D any, E any, F any]() []Comp

T6 creates a component type list for six component types.

func T7 

func T7[A any, B any, C any, D any, E any, F any, G any]() []Comp

T7 creates a component type list for seven component types.

func T8 

func T8[A any, B any, C any, D any, E any, F any, G any, H any]() []Comp

T8 creates a component type list for eight component types.

type Exchange 

type Exchange struct {
	// contains filtered or unexported fields
}

Exchange is a helper for adding, removing and exchanging components.

Set it up like this: 

ex := NewExchange(&world).
          Adds(T3[A, B, C]()...).
          Removes(T2[D, E]()...)

For only adding or removing components, see also Map1, Map2 etc.

func NewExchange 

func NewExchange(w *ecs.World) *Exchange

NewExchange creates a new Exchange object.

func (*Exchange) Add 

func (m *Exchange) Add(entity ecs.Entity)

Add the components set via Exchange.Adds to the given entity.

See also ecs.World.Add.

func (*Exchange) Adds 

func (m *Exchange) Adds(add ...Comp) *Exchange

Adds sets components to add in calls to Exchange.Add and Exchange.Exchange.

Create the required mask items with T.

func (*Exchange) Exchange 

func (m *Exchange) Exchange(entity ecs.Entity)

Exchange components on an entity.

Removes the components set via Exchange.Removes. Adds the components set via Exchange.Adds.

See also ecs.World.Exchange.

func (*Exchange) NewEntity 

func (m *Exchange) NewEntity() ecs.Entity

NewEntity creates a new ecs.Entity with the components set via Exchange.Adds.

See also ecs.World.NewEntity.

func (*Exchange) Remove 

func (m *Exchange) Remove(entity ecs.Entity)

Remove the components set via Exchange.Removes from the given entity.

See also ecs.World.Remove.

func (*Exchange) Removes 

func (m *Exchange) Removes(remove ...Comp) *Exchange

Removes sets components to remove in calls to Exchange.Remove and Exchange.Exchange.

Create the required mask items with T.

type Filter0 

type Filter0 filter

Filter0 is a helper for building Query0 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter0()
query := filter.Query(&world)

complexFilter :=
	NewFilter0().
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter0 

func NewFilter0() *Filter0

NewFilter0 creates a generic Filter0 for zero components.

See also ecs.World.Query.

func (*Filter0) Query 

func (q *Filter0) Query(w *ecs.World, target ...ecs.Entity) Query0

Query builds a Query0 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter0) Register added in v0.6.0 

func (q *Filter0) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter0) Unregister added in v0.6.0 

func (q *Filter0) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter0) With 

func (q *Filter0) With(mask ...Comp) *Filter0

With adds components that are required, but not accessible via [Query0.Get].

Create the required mask items with T.

func (*Filter0) WithRelation added in v0.8.0 

func (q *Filter0) WithRelation(comp Comp, target ...ecs.Entity) *Filter0

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter0.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter0) Without 

func (q *Filter0) Without(mask ...Comp) *Filter0

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter1 

type Filter1[A any] filter

Filter1 is a helper for building Query1 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter1[A]()
query := filter.Query(&world)

complexFilter :=
	NewFilter1[A]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter1 

func NewFilter1[A any]() *Filter1[A]

NewFilter1 creates a generic Filter1 for one components.

See also ecs.World.Query.

func (*Filter1[A]) Optional 

func (q *Filter1[A]) Optional(mask ...Comp) *Filter1[A]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter1[A]) Query 

func (q *Filter1[A]) Query(w *ecs.World, target ...ecs.Entity) Query1[A]

Query builds a Query1 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter1[A]) Register added in v0.6.0 

func (q *Filter1[A]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter1[A]) Unregister added in v0.6.0 

func (q *Filter1[A]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter1[A]) With 

func (q *Filter1[A]) With(mask ...Comp) *Filter1[A]

With adds components that are required, but not accessible via Query1.Get.

Create the required mask items with T.

func (*Filter1[A]) WithRelation added in v0.8.0 

func (q *Filter1[A]) WithRelation(comp Comp, target ...ecs.Entity) *Filter1[A]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter1.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter1[A]) Without 

func (q *Filter1[A]) Without(mask ...Comp) *Filter1[A]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter2 

type Filter2[A any, B any] filter

Filter2 is a helper for building Query2 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter2[A, B]()
query := filter.Query(&world)

complexFilter :=
	NewFilter2[A, B]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter2 

func NewFilter2[A any, B any]() *Filter2[A, B]

NewFilter2 creates a generic Filter2 for two components.

See also ecs.World.Query.

func (*Filter2[A, B]) Optional 

func (q *Filter2[A, B]) Optional(mask ...Comp) *Filter2[A, B]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter2[A, B]) Query 

func (q *Filter2[A, B]) Query(w *ecs.World, target ...ecs.Entity) Query2[A, B]

Query builds a Query2 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter2[A, B]) Register added in v0.6.0 

func (q *Filter2[A, B]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter2[A, B]) Unregister added in v0.6.0 

func (q *Filter2[A, B]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter2[A, B]) With 

func (q *Filter2[A, B]) With(mask ...Comp) *Filter2[A, B]

With adds components that are required, but not accessible via Query2.Get.

Create the required mask items with T.

func (*Filter2[A, B]) WithRelation added in v0.8.0 

func (q *Filter2[A, B]) WithRelation(comp Comp, target ...ecs.Entity) *Filter2[A, B]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter2.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter2[A, B]) Without 

func (q *Filter2[A, B]) Without(mask ...Comp) *Filter2[A, B]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter3 

type Filter3[A any, B any, C any] filter

Filter3 is a helper for building Query3 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter3[A, B, C]()
query := filter.Query(&world)

complexFilter :=
	NewFilter3[A, B, C]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter3 

func NewFilter3[A any, B any, C any]() *Filter3[A, B, C]

NewFilter3 creates a generic Filter3 for three components.

See also ecs.World.Query.

func (*Filter3[A, B, C]) Optional 

func (q *Filter3[A, B, C]) Optional(mask ...Comp) *Filter3[A, B, C]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter3[A, B, C]) Query 

func (q *Filter3[A, B, C]) Query(w *ecs.World, target ...ecs.Entity) Query3[A, B, C]

Query builds a Query3 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter3[A, B, C]) Register added in v0.6.0 

func (q *Filter3[A, B, C]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter3[A, B, C]) Unregister added in v0.6.0 

func (q *Filter3[A, B, C]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter3[A, B, C]) With 

func (q *Filter3[A, B, C]) With(mask ...Comp) *Filter3[A, B, C]

With adds components that are required, but not accessible via Query3.Get.

Create the required mask items with T.

func (*Filter3[A, B, C]) WithRelation added in v0.8.0 

func (q *Filter3[A, B, C]) WithRelation(comp Comp, target ...ecs.Entity) *Filter3[A, B, C]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter3.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter3[A, B, C]) Without 

func (q *Filter3[A, B, C]) Without(mask ...Comp) *Filter3[A, B, C]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter4 

type Filter4[A any, B any, C any, D any] filter

Filter4 is a helper for building Query4 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter4[A, B, C, D]()
query := filter.Query(&world)

complexFilter :=
	NewFilter4[A, B, C, D]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter4 

func NewFilter4[A any, B any, C any, D any]() *Filter4[A, B, C, D]

NewFilter4 creates a generic Filter4 for four components.

See also ecs.World.Query.

func (*Filter4[A, B, C, D]) Optional 

func (q *Filter4[A, B, C, D]) Optional(mask ...Comp) *Filter4[A, B, C, D]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter4[A, B, C, D]) Query 

func (q *Filter4[A, B, C, D]) Query(w *ecs.World, target ...ecs.Entity) Query4[A, B, C, D]

Query builds a Query4 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter4[A, B, C, D]) Register added in v0.6.0 

func (q *Filter4[A, B, C, D]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter4[A, B, C, D]) Unregister added in v0.6.0 

func (q *Filter4[A, B, C, D]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter4[A, B, C, D]) With 

func (q *Filter4[A, B, C, D]) With(mask ...Comp) *Filter4[A, B, C, D]

With adds components that are required, but not accessible via Query4.Get.

Create the required mask items with T.

func (*Filter4[A, B, C, D]) WithRelation added in v0.8.0 

func (q *Filter4[A, B, C, D]) WithRelation(comp Comp, target ...ecs.Entity) *Filter4[A, B, C, D]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter4.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter4[A, B, C, D]) Without 

func (q *Filter4[A, B, C, D]) Without(mask ...Comp) *Filter4[A, B, C, D]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter5 

type Filter5[A any, B any, C any, D any, E any] filter

Filter5 is a helper for building Query5 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter5[A, B, C, D, E]()
query := filter.Query(&world)

complexFilter :=
	NewFilter5[A, B, C, D, E]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter5 

func NewFilter5[A any, B any, C any, D any, E any]() *Filter5[A, B, C, D, E]

NewFilter5 creates a generic Filter5 for five components.

See also ecs.World.Query.

func (*Filter5[A, B, C, D, E]) Optional 

func (q *Filter5[A, B, C, D, E]) Optional(mask ...Comp) *Filter5[A, B, C, D, E]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter5[A, B, C, D, E]) Query 

func (q *Filter5[A, B, C, D, E]) Query(w *ecs.World, target ...ecs.Entity) Query5[A, B, C, D, E]

Query builds a Query5 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter5[A, B, C, D, E]) Register added in v0.6.0 

func (q *Filter5[A, B, C, D, E]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter5[A, B, C, D, E]) Unregister added in v0.6.0 

func (q *Filter5[A, B, C, D, E]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter5[A, B, C, D, E]) With 

func (q *Filter5[A, B, C, D, E]) With(mask ...Comp) *Filter5[A, B, C, D, E]

With adds components that are required, but not accessible via Query5.Get.

Create the required mask items with T.

func (*Filter5[A, B, C, D, E]) WithRelation added in v0.8.0 

func (q *Filter5[A, B, C, D, E]) WithRelation(comp Comp, target ...ecs.Entity) *Filter5[A, B, C, D, E]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter5.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter5[A, B, C, D, E]) Without 

func (q *Filter5[A, B, C, D, E]) Without(mask ...Comp) *Filter5[A, B, C, D, E]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter6 

type Filter6[A any, B any, C any, D any, E any, F any] filter

Filter6 is a helper for building Query6 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter6[A, B, C, D, E, F]()
query := filter.Query(&world)

complexFilter :=
	NewFilter6[A, B, C, D, E, F]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter6 

func NewFilter6[A any, B any, C any, D any, E any, F any]() *Filter6[A, B, C, D, E, F]

NewFilter6 creates a generic Filter6 for six components.

See also ecs.World.Query.

func (*Filter6[A, B, C, D, E, F]) Optional 

func (q *Filter6[A, B, C, D, E, F]) Optional(mask ...Comp) *Filter6[A, B, C, D, E, F]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter6[A, B, C, D, E, F]) Query 

func (q *Filter6[A, B, C, D, E, F]) Query(w *ecs.World, target ...ecs.Entity) Query6[A, B, C, D, E, F]

Query builds a Query6 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter6[A, B, C, D, E, F]) Register added in v0.6.0 

func (q *Filter6[A, B, C, D, E, F]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter6[A, B, C, D, E, F]) Unregister added in v0.6.0 

func (q *Filter6[A, B, C, D, E, F]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter6[A, B, C, D, E, F]) With 

func (q *Filter6[A, B, C, D, E, F]) With(mask ...Comp) *Filter6[A, B, C, D, E, F]

With adds components that are required, but not accessible via Query6.Get.

Create the required mask items with T.

func (*Filter6[A, B, C, D, E, F]) WithRelation added in v0.8.0 

func (q *Filter6[A, B, C, D, E, F]) WithRelation(comp Comp, target ...ecs.Entity) *Filter6[A, B, C, D, E, F]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter6.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter6[A, B, C, D, E, F]) Without 

func (q *Filter6[A, B, C, D, E, F]) Without(mask ...Comp) *Filter6[A, B, C, D, E, F]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter7 

type Filter7[A any, B any, C any, D any, E any, F any, G any] filter

Filter7 is a helper for building Query7 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter7[A, B, C, D, E, F, G]()
query := filter.Query(&world)

complexFilter :=
	NewFilter7[A, B, C, D, E, F, G]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter7 

func NewFilter7[A any, B any, C any, D any, E any, F any, G any]() *Filter7[A, B, C, D, E, F, G]

NewFilter7 creates a generic Filter7 for seven components.

See also ecs.World.Query.

func (*Filter7[A, B, C, D, E, F, G]) Optional 

func (q *Filter7[A, B, C, D, E, F, G]) Optional(mask ...Comp) *Filter7[A, B, C, D, E, F, G]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter7[A, B, C, D, E, F, G]) Query 

func (q *Filter7[A, B, C, D, E, F, G]) Query(w *ecs.World, target ...ecs.Entity) Query7[A, B, C, D, E, F, G]

Query builds a Query7 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter7[A, B, C, D, E, F, G]) Register added in v0.6.0 

func (q *Filter7[A, B, C, D, E, F, G]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter7[A, B, C, D, E, F, G]) Unregister added in v0.6.0 

func (q *Filter7[A, B, C, D, E, F, G]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter7[A, B, C, D, E, F, G]) With 

func (q *Filter7[A, B, C, D, E, F, G]) With(mask ...Comp) *Filter7[A, B, C, D, E, F, G]

With adds components that are required, but not accessible via Query7.Get.

Create the required mask items with T.

func (*Filter7[A, B, C, D, E, F, G]) WithRelation added in v0.8.0 

func (q *Filter7[A, B, C, D, E, F, G]) WithRelation(comp Comp, target ...ecs.Entity) *Filter7[A, B, C, D, E, F, G]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter7.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter7[A, B, C, D, E, F, G]) Without 

func (q *Filter7[A, B, C, D, E, F, G]) Without(mask ...Comp) *Filter7[A, B, C, D, E, F, G]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Filter8 

type Filter8[A any, B any, C any, D any, E any, F any, G any, H any] filter

Filter8 is a helper for building Query8 query iterators.

Example 

world := ecs.NewWorld()

filter := NewFilter8[A, B, C, D, E, F, G, H]()
query := filter.Query(&world)

complexFilter :=
	NewFilter8[A, B, C, D, E, F, G, H]().
		Optional(T[A]()).
		With(T2[V, W]()...).
		Without(T3[X, Y, Z]()...).

func NewFilter8 

func NewFilter8[A any, B any, C any, D any, E any, F any, G any, H any]() *Filter8[A, B, C, D, E, F, G, H]

NewFilter8 creates a generic Filter8 for eight components.

See also ecs.World.Query.

func (*Filter8[A, B, C, D, E, F, G, H]) Optional 

func (q *Filter8[A, B, C, D, E, F, G, H]) Optional(mask ...Comp) *Filter8[A, B, C, D, E, F, G, H]

Optional makes some of the query's components optional.

Create the required mask items with T.

Only affects component types that were specified in the query.

func (*Filter8[A, B, C, D, E, F, G, H]) Query 

func (q *Filter8[A, B, C, D, E, F, G, H]) Query(w *ecs.World, target ...ecs.Entity) Query8[A, B, C, D, E, F, G, H]

Query builds a Query8 query for iteration, with an optional relation target.

A relation target can't be used:

Panics in these cases.

func (*Filter8[A, B, C, D, E, F, G, H]) Register added in v0.6.0 

func (q *Filter8[A, B, C, D, E, F, G, H]) Register(w *ecs.World)

Register the filter for caching.

See ecs.Cache for details on filter caching.

func (*Filter8[A, B, C, D, E, F, G, H]) Unregister added in v0.6.0 

func (q *Filter8[A, B, C, D, E, F, G, H]) Unregister(w *ecs.World)

Unregister the filter from caching.

See ecs.Cache for details on filter caching.

func (*Filter8[A, B, C, D, E, F, G, H]) With 

func (q *Filter8[A, B, C, D, E, F, G, H]) With(mask ...Comp) *Filter8[A, B, C, D, E, F, G, H]

With adds components that are required, but not accessible via Query8.Get.

Create the required mask items with T.

func (*Filter8[A, B, C, D, E, F, G, H]) WithRelation added in v0.8.0 

func (q *Filter8[A, B, C, D, E, F, G, H]) WithRelation(comp Comp, target ...ecs.Entity) *Filter8[A, B, C, D, E, F, G, H]

WithRelation sets the filter's ecs.Relation component and optionally restricts the query to entities that have the given relation target.

Use without the optional argument to specify the relation target in Filter8.Query. If the optional argument is provided, the filter's relation target is set permanently.

Create the required component ID with T.

func (*Filter8[A, B, C, D, E, F, G, H]) Without 

func (q *Filter8[A, B, C, D, E, F, G, H]) Without(mask ...Comp) *Filter8[A, B, C, D, E, F, G, H]

Without excludes entities with any of the given components from the query.

Create the required mask items with T.

type Map 

type Map[T any] struct {
	// contains filtered or unexported fields
}

Map provides a type-safe way to access a component type by entity ID.

Create one with NewMap.

Example 
// Create a world.
world := ecs.NewWorld()

// Spawn some entities using the generic API.
spawner := NewMap2[Position, Velocity](&world)
entity := spawner.New()

// Create a new Map.
mapper := NewMap[Position](&world)

// Get the map's component.
pos := mapper.Get(entity)
pos.X, pos.Y = 10, 5

// Get the map's component, optimized for cases when the entity is guaranteed to be still alive.
pos = mapper.GetUnchecked(entity)
pos.X, pos.Y = 10, 5

Output:

func NewMap 

func NewMap[T any](w *ecs.World) Map[T]

NewMap creates a new Map for a component type.

Map provides a type-safe way to access a component type by entity ID.

See also ecs.World.Get, ecs.World.Has and ecs.World.Set.

func (*Map[T]) Get 

func (g *Map[T]) Get(entity ecs.Entity) *T

Get gets the component for the given entity.

See Map.HasUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map[T]) GetRelation added in v0.8.0 

func (g *Map[T]) GetRelation(entity ecs.Entity) ecs.Entity

GetRelation returns the target entity for the given entity and the Map's relation component.

Panics:

  • if the entity does not have a component of that type.
  • if the component is not an ecs.Relation.
  • if the entity has been removed/recycled.

See also ecs.World.GetRelation.

func (*Map[T]) GetRelationUnchecked added in v0.8.0 

func (g *Map[T]) GetRelationUnchecked(entity ecs.Entity) ecs.Entity

GetRelation returns the target entity for the given entity and the Map's relation component.

Returns the zero entity if the entity does not have the given component, or if the component is not an ecs.Relation.

GetRelationUnchecked is an optimized version of Map.GetRelation. Does not check if the entity is alive or that the component ID is applicable.

See also ecs.World.GetRelationUnchecked.

func (*Map[T]) GetUnchecked added in v0.7.0 

func (g *Map[T]) GetUnchecked(entity ecs.Entity) *T

GetUnchecked gets the component for the given entity.

GetUnchecked is an optimized version of Map.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map[T]) Has 

func (g *Map[T]) Has(entity ecs.Entity) bool

Has returns whether the entity has the component.

See Map.HasUnchecked for an optimized version for static entities. See also ecs.World.Has.

func (*Map[T]) HasUnchecked added in v0.7.0 

func (g *Map[T]) HasUnchecked(entity ecs.Entity) bool

HasUnchecked returns whether the entity has the component.

HasUnchecked is an optimized version of Map.Has, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.HasUnchecked.

func (*Map[T]) ID 

func (g *Map[T]) ID() ecs.ID

ID returns the component ID for this Map.

func (*Map[T]) Set 

func (g *Map[T]) Set(entity ecs.Entity, comp *T) *T

Set overwrites the component for the given entity.

Panics if the entity does not have a component of that type.

See also ecs.World.Set.

func (*Map[T]) SetRelation added in v0.8.0 

func (g *Map[T]) SetRelation(entity, target ecs.Entity)

SetRelation sets the target entity for the given entity and the Map's relation component.

Panics if the entity does not have a component of that type. Panics if the component is not a relation.

See also ecs.World.SetRelation.

type Map1 

type Map1[A any] struct {
	// contains filtered or unexported fields
}

Map1 is a helper for mapping one components.

Example 

world := ecs.NewWorld()

mapper := NewMap1[A](&world)

entity := mapper.NewEntity()
a := mapper.Get(entity)

func NewMap1 

func NewMap1[A any](w *ecs.World, relation ...Comp) Map1[A]

NewMap1 creates a new Map1 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map1[A]) Add 

func (m *Map1[A]) Add(entity ecs.Entity)

Add the Map1's components to the given entity.

See also ecs.World.Add.

func (*Map1[A]) Assign 

func (m *Map1[A]) Assign(entity ecs.Entity, a *A)

Assign the Map1's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map1[A]) Get 

func (m *Map1[A]) Get(entity ecs.Entity) *A

Get all the Map1's components for the given entity.

See Map1.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map1[A]) GetUnchecked added in v0.7.0 

func (m *Map1[A]) GetUnchecked(entity ecs.Entity) *A

GetUnchecked all the Map1's components for the given entity.

GetUnchecked is an optimized version of Map1.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map1[A]) New added in v0.8.0 

func (m *Map1[A]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map1's components.

The optional argument can be used to set the target ecs.Entity for the Map1's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map1[A]) NewBatch added in v0.8.0 

func (m *Map1[A]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map1's components.

The optional argument can be used to set the target ecs.Entity for the Map1's ecs.Relation.

See also Map1.NewBatchQ and ecs.Batch.NewBatch.

func (*Map1[A]) NewBatchQ added in v0.8.0 

func (m *Map1[A]) NewBatchQ(count int, target ...ecs.Entity) Query1[A]

NewBatchQ creates entities with the Map1's components. It returns a Query1 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map1's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map1.NewBatch and ecs.Builder.NewBatchQ.

func (*Map1[A]) NewWith added in v0.8.0 

func (m *Map1[A]) NewWith(a *A, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map1's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map1's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map1[A]) Remove 

func (m *Map1[A]) Remove(entity ecs.Entity)

Remove the Map1's components from the given entity.

See also ecs.World.Remove.

func (*Map1[A]) RemoveEntities added in v0.6.0 

func (m *Map1[A]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map1's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map2 

type Map2[A any, B any] struct {
	// contains filtered or unexported fields
}

Map2 is a helper for mapping two components.

Example 

world := ecs.NewWorld()

mapper := NewMap2[A, B](&world)

entity := mapper.NewEntity()
a, b := mapper.Get(entity)

func NewMap2 

func NewMap2[A any, B any](w *ecs.World, relation ...Comp) Map2[A, B]

NewMap2 creates a new Map2 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map2[A, B]) Add 

func (m *Map2[A, B]) Add(entity ecs.Entity)

Add the Map2's components to the given entity.

See also ecs.World.Add.

func (*Map2[A, B]) Assign 

func (m *Map2[A, B]) Assign(entity ecs.Entity, a *A, b *B)

Assign the Map2's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map2[A, B]) Get 

func (m *Map2[A, B]) Get(entity ecs.Entity) (*A, *B)

Get all the Map2's components for the given entity.

See Map2.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map2[A, B]) GetUnchecked added in v0.7.0 

func (m *Map2[A, B]) GetUnchecked(entity ecs.Entity) (*A, *B)

GetUnchecked all the Map2's components for the given entity.

GetUnchecked is an optimized version of Map2.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map2[A, B]) New added in v0.8.0 

func (m *Map2[A, B]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map2's components.

The optional argument can be used to set the target ecs.Entity for the Map2's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map2[A, B]) NewBatch added in v0.8.0 

func (m *Map2[A, B]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map2's components.

The optional argument can be used to set the target ecs.Entity for the Map2's ecs.Relation.

See also Map2.NewBatchQ and ecs.Batch.NewBatch.

func (*Map2[A, B]) NewBatchQ added in v0.8.0 

func (m *Map2[A, B]) NewBatchQ(count int, target ...ecs.Entity) Query2[A, B]

NewBatchQ creates entities with the Map2's components. It returns a Query2 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map2's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map2.NewBatch and ecs.Builder.NewBatchQ.

func (*Map2[A, B]) NewWith added in v0.8.0 

func (m *Map2[A, B]) NewWith(a *A, b *B, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map2's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map2's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map2[A, B]) Remove 

func (m *Map2[A, B]) Remove(entity ecs.Entity)

Remove the Map2's components from the given entity.

See also ecs.World.Remove.

func (*Map2[A, B]) RemoveEntities added in v0.6.0 

func (m *Map2[A, B]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map2's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map3 

type Map3[A any, B any, C any] struct {
	// contains filtered or unexported fields
}

Map3 is a helper for mapping three components.

Example 

world := ecs.NewWorld()

mapper := NewMap3[A, B, C](&world)

entity := mapper.NewEntity()
a, b, c := mapper.Get(entity)

func NewMap3 

func NewMap3[A any, B any, C any](w *ecs.World, relation ...Comp) Map3[A, B, C]

NewMap3 creates a new Map3 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map3[A, B, C]) Add 

func (m *Map3[A, B, C]) Add(entity ecs.Entity)

Add the Map3's components to the given entity.

See also ecs.World.Add.

func (*Map3[A, B, C]) Assign 

func (m *Map3[A, B, C]) Assign(entity ecs.Entity, a *A, b *B, c *C)

Assign the Map3's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map3[A, B, C]) Get 

func (m *Map3[A, B, C]) Get(entity ecs.Entity) (*A, *B, *C)

Get all the Map3's components for the given entity.

See Map3.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map3[A, B, C]) GetUnchecked added in v0.7.0 

func (m *Map3[A, B, C]) GetUnchecked(entity ecs.Entity) (*A, *B, *C)

GetUnchecked all the Map3's components for the given entity.

GetUnchecked is an optimized version of Map3.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map3[A, B, C]) New added in v0.8.0 

func (m *Map3[A, B, C]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map3's components.

The optional argument can be used to set the target ecs.Entity for the Map3's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map3[A, B, C]) NewBatch added in v0.8.0 

func (m *Map3[A, B, C]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map3's components.

The optional argument can be used to set the target ecs.Entity for the Map3's ecs.Relation.

See also Map3.NewBatchQ and ecs.Batch.NewBatch.

func (*Map3[A, B, C]) NewBatchQ added in v0.8.0 

func (m *Map3[A, B, C]) NewBatchQ(count int, target ...ecs.Entity) Query3[A, B, C]

NewBatchQ creates entities with the Map3's components. It returns a Query3 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map3's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map3.NewBatch and ecs.Builder.NewBatchQ.

func (*Map3[A, B, C]) NewWith added in v0.8.0 

func (m *Map3[A, B, C]) NewWith(a *A, b *B, c *C, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map3's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map3's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map3[A, B, C]) Remove 

func (m *Map3[A, B, C]) Remove(entity ecs.Entity)

Remove the Map3's components from the given entity.

See also ecs.World.Remove.

func (*Map3[A, B, C]) RemoveEntities added in v0.6.0 

func (m *Map3[A, B, C]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map3's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map4 

type Map4[A any, B any, C any, D any] struct {
	// contains filtered or unexported fields
}

Map4 is a helper for mapping four components.

Example 

world := ecs.NewWorld()

mapper := NewMap4[A, B, C, D](&world)

entity := mapper.NewEntity()
a, b, c, d := mapper.Get(entity)

func NewMap4 

func NewMap4[A any, B any, C any, D any](w *ecs.World, relation ...Comp) Map4[A, B, C, D]

NewMap4 creates a new Map4 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map4[A, B, C, D]) Add 

func (m *Map4[A, B, C, D]) Add(entity ecs.Entity)

Add the Map4's components to the given entity.

See also ecs.World.Add.

func (*Map4[A, B, C, D]) Assign 

func (m *Map4[A, B, C, D]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D)

Assign the Map4's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map4[A, B, C, D]) Get 

func (m *Map4[A, B, C, D]) Get(entity ecs.Entity) (*A, *B, *C, *D)

Get all the Map4's components for the given entity.

See Map4.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map4[A, B, C, D]) GetUnchecked added in v0.7.0 

func (m *Map4[A, B, C, D]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D)

GetUnchecked all the Map4's components for the given entity.

GetUnchecked is an optimized version of Map4.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map4[A, B, C, D]) New added in v0.8.0 

func (m *Map4[A, B, C, D]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map4's components.

The optional argument can be used to set the target ecs.Entity for the Map4's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map4[A, B, C, D]) NewBatch added in v0.8.0 

func (m *Map4[A, B, C, D]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map4's components.

The optional argument can be used to set the target ecs.Entity for the Map4's ecs.Relation.

See also Map4.NewBatchQ and ecs.Batch.NewBatch.

func (*Map4[A, B, C, D]) NewBatchQ added in v0.8.0 

func (m *Map4[A, B, C, D]) NewBatchQ(count int, target ...ecs.Entity) Query4[A, B, C, D]

NewBatchQ creates entities with the Map4's components. It returns a Query4 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map4's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map4.NewBatch and ecs.Builder.NewBatchQ.

func (*Map4[A, B, C, D]) NewWith added in v0.8.0 

func (m *Map4[A, B, C, D]) NewWith(a *A, b *B, c *C, d *D, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map4's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map4's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map4[A, B, C, D]) Remove 

func (m *Map4[A, B, C, D]) Remove(entity ecs.Entity)

Remove the Map4's components from the given entity.

See also ecs.World.Remove.

func (*Map4[A, B, C, D]) RemoveEntities added in v0.6.0 

func (m *Map4[A, B, C, D]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map4's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map5 

type Map5[A any, B any, C any, D any, E any] struct {
	// contains filtered or unexported fields
}

Map5 is a helper for mapping five components.

Example 

world := ecs.NewWorld()

mapper := NewMap5[A, B, C, D, E](&world)

entity := mapper.NewEntity()
a, b, c, d, e := mapper.Get(entity)

func NewMap5 

func NewMap5[A any, B any, C any, D any, E any](w *ecs.World, relation ...Comp) Map5[A, B, C, D, E]

NewMap5 creates a new Map5 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map5[A, B, C, D, E]) Add 

func (m *Map5[A, B, C, D, E]) Add(entity ecs.Entity)

Add the Map5's components to the given entity.

See also ecs.World.Add.

func (*Map5[A, B, C, D, E]) Assign 

func (m *Map5[A, B, C, D, E]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D, e *E)

Assign the Map5's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map5[A, B, C, D, E]) Get 

func (m *Map5[A, B, C, D, E]) Get(entity ecs.Entity) (*A, *B, *C, *D, *E)

Get all the Map5's components for the given entity.

See Map5.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map5[A, B, C, D, E]) GetUnchecked added in v0.7.0 

func (m *Map5[A, B, C, D, E]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D, *E)

GetUnchecked all the Map5's components for the given entity.

GetUnchecked is an optimized version of Map5.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map5[A, B, C, D, E]) New added in v0.8.0 

func (m *Map5[A, B, C, D, E]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map5's components.

The optional argument can be used to set the target ecs.Entity for the Map5's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map5[A, B, C, D, E]) NewBatch added in v0.8.0 

func (m *Map5[A, B, C, D, E]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map5's components.

The optional argument can be used to set the target ecs.Entity for the Map5's ecs.Relation.

See also Map5.NewBatchQ and ecs.Batch.NewBatch.

func (*Map5[A, B, C, D, E]) NewBatchQ added in v0.8.0 

func (m *Map5[A, B, C, D, E]) NewBatchQ(count int, target ...ecs.Entity) Query5[A, B, C, D, E]

NewBatchQ creates entities with the Map5's components. It returns a Query5 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map5's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map5.NewBatch and ecs.Builder.NewBatchQ.

func (*Map5[A, B, C, D, E]) NewWith added in v0.8.0 

func (m *Map5[A, B, C, D, E]) NewWith(a *A, b *B, c *C, d *D, e *E, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map5's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map5's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map5[A, B, C, D, E]) Remove 

func (m *Map5[A, B, C, D, E]) Remove(entity ecs.Entity)

Remove the Map5's components from the given entity.

See also ecs.World.Remove.

func (*Map5[A, B, C, D, E]) RemoveEntities added in v0.6.0 

func (m *Map5[A, B, C, D, E]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map5's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map6 

type Map6[A any, B any, C any, D any, E any, F any] struct {
	// contains filtered or unexported fields
}

Map6 is a helper for mapping six components.

Example 

world := ecs.NewWorld()

mapper := NewMap6[A, B, C, D, E, F](&world)

entity := mapper.NewEntity()
a, b, c, d, e, f := mapper.Get(entity)

func NewMap6 

func NewMap6[A any, B any, C any, D any, E any, F any](w *ecs.World, relation ...Comp) Map6[A, B, C, D, E, F]

NewMap6 creates a new Map6 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map6[A, B, C, D, E, F]) Add 

func (m *Map6[A, B, C, D, E, F]) Add(entity ecs.Entity)

Add the Map6's components to the given entity.

See also ecs.World.Add.

func (*Map6[A, B, C, D, E, F]) Assign 

func (m *Map6[A, B, C, D, E, F]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D, e *E, f *F)

Assign the Map6's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map6[A, B, C, D, E, F]) Get 

func (m *Map6[A, B, C, D, E, F]) Get(entity ecs.Entity) (*A, *B, *C, *D, *E, *F)

Get all the Map6's components for the given entity.

See Map6.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map6[A, B, C, D, E, F]) GetUnchecked added in v0.7.0 

func (m *Map6[A, B, C, D, E, F]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D, *E, *F)

GetUnchecked all the Map6's components for the given entity.

GetUnchecked is an optimized version of Map6.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map6[A, B, C, D, E, F]) New added in v0.8.0 

func (m *Map6[A, B, C, D, E, F]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map6's components.

The optional argument can be used to set the target ecs.Entity for the Map6's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map6[A, B, C, D, E, F]) NewBatch added in v0.8.0 

func (m *Map6[A, B, C, D, E, F]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map6's components.

The optional argument can be used to set the target ecs.Entity for the Map6's ecs.Relation.

See also Map6.NewBatchQ and ecs.Batch.NewBatch.

func (*Map6[A, B, C, D, E, F]) NewBatchQ added in v0.8.0 

func (m *Map6[A, B, C, D, E, F]) NewBatchQ(count int, target ...ecs.Entity) Query6[A, B, C, D, E, F]

NewBatchQ creates entities with the Map6's components. It returns a Query6 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map6's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map6.NewBatch and ecs.Builder.NewBatchQ.

func (*Map6[A, B, C, D, E, F]) NewWith added in v0.8.0 

func (m *Map6[A, B, C, D, E, F]) NewWith(a *A, b *B, c *C, d *D, e *E, f *F, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map6's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map6's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map6[A, B, C, D, E, F]) Remove 

func (m *Map6[A, B, C, D, E, F]) Remove(entity ecs.Entity)

Remove the Map6's components from the given entity.

See also ecs.World.Remove.

func (*Map6[A, B, C, D, E, F]) RemoveEntities added in v0.6.0 

func (m *Map6[A, B, C, D, E, F]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map6's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map7 

type Map7[A any, B any, C any, D any, E any, F any, G any] struct {
	// contains filtered or unexported fields
}

Map7 is a helper for mapping seven components.

Example 

world := ecs.NewWorld()

mapper := NewMap7[A, B, C, D, E, F, G](&world)

entity := mapper.NewEntity()
a, b, c, d, e, f, g := mapper.Get(entity)

func NewMap7 

func NewMap7[A any, B any, C any, D any, E any, F any, G any](w *ecs.World, relation ...Comp) Map7[A, B, C, D, E, F, G]

NewMap7 creates a new Map7 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map7[A, B, C, D, E, F, G]) Add 

func (m *Map7[A, B, C, D, E, F, G]) Add(entity ecs.Entity)

Add the Map7's components to the given entity.

See also ecs.World.Add.

func (*Map7[A, B, C, D, E, F, G]) Assign 

func (m *Map7[A, B, C, D, E, F, G]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D, e *E, f *F, g *G)

Assign the Map7's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map7[A, B, C, D, E, F, G]) Get 

func (m *Map7[A, B, C, D, E, F, G]) Get(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G)

Get all the Map7's components for the given entity.

See Map7.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map7[A, B, C, D, E, F, G]) GetUnchecked added in v0.7.0 

func (m *Map7[A, B, C, D, E, F, G]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G)

GetUnchecked all the Map7's components for the given entity.

GetUnchecked is an optimized version of Map7.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map7[A, B, C, D, E, F, G]) New added in v0.8.0 

func (m *Map7[A, B, C, D, E, F, G]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map7's components.

The optional argument can be used to set the target ecs.Entity for the Map7's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map7[A, B, C, D, E, F, G]) NewBatch added in v0.8.0 

func (m *Map7[A, B, C, D, E, F, G]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map7's components.

The optional argument can be used to set the target ecs.Entity for the Map7's ecs.Relation.

See also Map7.NewBatchQ and ecs.Batch.NewBatch.

func (*Map7[A, B, C, D, E, F, G]) NewBatchQ added in v0.8.0 

func (m *Map7[A, B, C, D, E, F, G]) NewBatchQ(count int, target ...ecs.Entity) Query7[A, B, C, D, E, F, G]

NewBatchQ creates entities with the Map7's components. It returns a Query7 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map7's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map7.NewBatch and ecs.Builder.NewBatchQ.

func (*Map7[A, B, C, D, E, F, G]) NewWith added in v0.8.0 

func (m *Map7[A, B, C, D, E, F, G]) NewWith(a *A, b *B, c *C, d *D, e *E, f *F, g *G, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map7's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map7's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map7[A, B, C, D, E, F, G]) Remove 

func (m *Map7[A, B, C, D, E, F, G]) Remove(entity ecs.Entity)

Remove the Map7's components from the given entity.

See also ecs.World.Remove.

func (*Map7[A, B, C, D, E, F, G]) RemoveEntities added in v0.6.0 

func (m *Map7[A, B, C, D, E, F, G]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map7's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Map8 

type Map8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
	// contains filtered or unexported fields
}

Map8 is a helper for mapping eight components.

Example 

world := ecs.NewWorld()

mapper := NewMap8[A, B, C, D, E, F, G, H](&world)

entity := mapper.NewEntity()
a, b, c, d, e, f, g, h := mapper.Get(entity)

func NewMap8 

func NewMap8[A any, B any, C any, D any, E any, F any, G any, H any](w *ecs.World, relation ...Comp) Map8[A, B, C, D, E, F, G, H]

NewMap8 creates a new Map8 object.

The optional argument can be used to set an ecs.Relation component type.

func (*Map8[A, B, C, D, E, F, G, H]) Add 

func (m *Map8[A, B, C, D, E, F, G, H]) Add(entity ecs.Entity)

Add the Map8's components to the given entity.

See also ecs.World.Add.

func (*Map8[A, B, C, D, E, F, G, H]) Assign 

func (m *Map8[A, B, C, D, E, F, G, H]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H)

Assign the Map8's components to the given entity, using the supplied values.

See also ecs.World.Assign.

func (*Map8[A, B, C, D, E, F, G, H]) Get 

func (m *Map8[A, B, C, D, E, F, G, H]) Get(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G, *H)

Get all the Map8's components for the given entity.

See Map8.GetUnchecked for an optimized version for static entities. See also ecs.World.Get.

func (*Map8[A, B, C, D, E, F, G, H]) GetUnchecked added in v0.7.0 

func (m *Map8[A, B, C, D, E, F, G, H]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G, *H)

GetUnchecked all the Map8's components for the given entity.

GetUnchecked is an optimized version of Map8.Get, for cases where entities are static or checked with ecs.World.Alive in user code.

See also ecs.World.GetUnchecked.

func (*Map8[A, B, C, D, E, F, G, H]) New added in v0.8.0 

func (m *Map8[A, B, C, D, E, F, G, H]) New(target ...ecs.Entity) ecs.Entity

New creates a new ecs.Entity with the Map8's components.

The optional argument can be used to set the target ecs.Entity for the Map8's ecs.Relation.

See also ecs.World.NewEntity.

func (*Map8[A, B, C, D, E, F, G, H]) NewBatch added in v0.8.0 

func (m *Map8[A, B, C, D, E, F, G, H]) NewBatch(count int, target ...ecs.Entity)

NewBatch creates entities with the Map8's components.

The optional argument can be used to set the target ecs.Entity for the Map8's ecs.Relation.

See also Map8.NewBatchQ and ecs.Batch.NewBatch.

func (*Map8[A, B, C, D, E, F, G, H]) NewBatchQ added in v0.8.0 

func (m *Map8[A, B, C, D, E, F, G, H]) NewBatchQ(count int, target ...ecs.Entity) Query8[A, B, C, D, E, F, G, H]

NewBatchQ creates entities with the Map8's components. It returns a Query8 over the new entities.

The optional argument can be used to set the target ecs.Entity for the Map8's ecs.Relation.

Listener notification is delayed until the query is closed of fully iterated.

See also Map8.NewBatch and ecs.Builder.NewBatchQ.

func (*Map8[A, B, C, D, E, F, G, H]) NewWith added in v0.8.0 

func (m *Map8[A, B, C, D, E, F, G, H]) NewWith(a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H, target ...ecs.Entity) ecs.Entity

NewWith creates a new ecs.Entity with the Map8's components, using the supplied values.

The optional argument can be used to set the target ecs.Entity for the Map8's ecs.Relation.

See also ecs.NewBuilderWith.

func (*Map8[A, B, C, D, E, F, G, H]) Remove 

func (m *Map8[A, B, C, D, E, F, G, H]) Remove(entity ecs.Entity)

Remove the Map8's components from the given entity.

See also ecs.World.Remove.

func (*Map8[A, B, C, D, E, F, G, H]) RemoveEntities added in v0.6.0 

func (m *Map8[A, B, C, D, E, F, G, H]) RemoveEntities(exclusive bool) int

RemoveEntities removes all entities from the world that match the Map8's components.

The argument determines whether to match the components exactly (i.e. no other components are allowed), or to use a simple filter that does not restrict further components.

Returns the number of removed entities.

See also ecs.World.NewEntityWith.

type Query0 

type Query0 struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query0 is a generic query iterator for zero components.

Create it with NewFilter0 and Filter0.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter0()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
}

func (*Query0) Relation added in v0.8.0 

func (q *Query0) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter0 was not prepared for relations using Filter0.WithRelation.

type Query1 

type Query1[A any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query1 is a generic query iterator for one components.

Create it with NewFilter1 and Filter1.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter1[A]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a := query.Get()
}

func (*Query1[A]) Get 

func (q *Query1[A]) Get() *A

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query1[A]) Relation added in v0.8.0 

func (q *Query1[A]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter1 was not prepared for relations using Filter1.WithRelation.

type Query2 

type Query2[A any, B any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query2 is a generic query iterator for two components.

Create it with NewFilter2 and Filter2.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter2[A, B]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b := query.Get()
}

func (*Query2[A, B]) Get 

func (q *Query2[A, B]) Get() (*A, *B)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query2[A, B]) Relation added in v0.8.0 

func (q *Query2[A, B]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter2 was not prepared for relations using Filter2.WithRelation.

type Query3 

type Query3[A any, B any, C any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query3 is a generic query iterator for three components.

Create it with NewFilter3 and Filter3.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter3[A, B, C]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b, c := query.Get()
}

func (*Query3[A, B, C]) Get 

func (q *Query3[A, B, C]) Get() (*A, *B, *C)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query3[A, B, C]) Relation added in v0.8.0 

func (q *Query3[A, B, C]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter3 was not prepared for relations using Filter3.WithRelation.

type Query4 

type Query4[A any, B any, C any, D any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query4 is a generic query iterator for four components.

Create it with NewFilter4 and Filter4.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter4[A, B, C, D]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b, c, d := query.Get()
}

func (*Query4[A, B, C, D]) Get 

func (q *Query4[A, B, C, D]) Get() (*A, *B, *C, *D)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query4[A, B, C, D]) Relation added in v0.8.0 

func (q *Query4[A, B, C, D]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter4 was not prepared for relations using Filter4.WithRelation.

type Query5 

type Query5[A any, B any, C any, D any, E any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query5 is a generic query iterator for five components.

Create it with NewFilter5 and Filter5.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter5[A, B, C, D, E]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b, c, d, e := query.Get()
}

func (*Query5[A, B, C, D, E]) Get 

func (q *Query5[A, B, C, D, E]) Get() (*A, *B, *C, *D, *E)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query5[A, B, C, D, E]) Relation added in v0.8.0 

func (q *Query5[A, B, C, D, E]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter5 was not prepared for relations using Filter5.WithRelation.

type Query6 

type Query6[A any, B any, C any, D any, E any, F any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query6 is a generic query iterator for six components.

Create it with NewFilter6 and Filter6.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter6[A, B, C, D, E, F]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b, c, d, e, f := query.Get()
}

func (*Query6[A, B, C, D, E, F]) Get 

func (q *Query6[A, B, C, D, E, F]) Get() (*A, *B, *C, *D, *E, *F)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query6[A, B, C, D, E, F]) Relation added in v0.8.0 

func (q *Query6[A, B, C, D, E, F]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter6 was not prepared for relations using Filter6.WithRelation.

type Query7 

type Query7[A any, B any, C any, D any, E any, F any, G any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query7 is a generic query iterator for seven components.

Create it with NewFilter7 and Filter7.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter7[A, B, C, D, E, F, G]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b, c, d, e, f, g := query.Get()
}

func (*Query7[A, B, C, D, E, F, G]) Get 

func (q *Query7[A, B, C, D, E, F, G]) Get() (*A, *B, *C, *D, *E, *F, *G)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query7[A, B, C, D, E, F, G]) Relation added in v0.8.0 

func (q *Query7[A, B, C, D, E, F, G]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter7 was not prepared for relations using Filter7.WithRelation.

type Query8 

type Query8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
	ecs.Query
	// contains filtered or unexported fields
}

Query8 is a generic query iterator for eight components.

Create it with NewFilter8 and Filter8.Query.

Also has all methods of ecs.Query.

Example 

world := ecs.NewWorld()

filter := NewFilter8[A, B, C, D, E, F, G, H]()
query := filter.Query(&world)
for query.Next() {
	entity = query.Entity()
	a, b, c, d, e, f, g, h := query.Get()
}

func (*Query8[A, B, C, D, E, F, G, H]) Get 

func (q *Query8[A, B, C, D, E, F, G, H]) Get() (*A, *B, *C, *D, *E, *F, *G, *H)

Get returns all queried components for the current query iterator position.

Use ecs.Query.Entity to get the current Entity.

func (*Query8[A, B, C, D, E, F, G, H]) Relation added in v0.8.0 

func (q *Query8[A, B, C, D, E, F, G, H]) Relation() ecs.Entity

Relation returns the target entity for the query's relation.

Panics if the entity does not have the given component, or if the component is not an ecs.Relation. Panics if the underlying Filter8 was not prepared for relations using Filter8.WithRelation.

type Resource added in v0.5.0 

type Resource[T any] struct {
	// contains filtered or unexported fields
}

Resource provides a type-safe way to access world resources.

Create one with NewResource.

Example 
world := ecs.NewWorld()
myRes := Position{}

resAccess := NewResource[Position](&world)
resAccess.Add(&myRes)
res := resAccess.Get()
res.X, res.Y = 10, 5

Output:

func NewResource added in v0.5.0 

func NewResource[T any](w *ecs.World) Resource[T]

NewResource creates a new Resource mapper for a resource type. This does not add a resource to the world, but only creates a mapper for resource access!

Resource provides a type-safe way to access a world resources.

See also ecs.World.Resources.

func (*Resource[T]) Add added in v0.5.0 

func (g *Resource[T]) Add(res *T)

Add adds a resource to the world.

Panics if there is already a resource of the given type.

See also ecs.Resources.Add.

func (*Resource[T]) Get added in v0.5.0 

func (g *Resource[T]) Get() *T

Get gets the resource of the given type.

Returns nil if there is no such resource.

See also ecs.Resources.Get.

func (*Resource[T]) Has added in v0.5.0 

func (g *Resource[T]) Has() bool

Has returns whether the world has the resource type.

See also ecs.Resources.Has.

func (*Resource[T]) ID added in v0.5.0 

func (g *Resource[T]) ID() ecs.ResID

ID returns the resource ecs.ResID for this Resource mapper.

func (*Resource[T]) Remove added in v0.5.0 

func (g *Resource[T]) Remove()

Remove removes a resource from the world.

Panics if there is no resource of the given type.

See also ecs.Resources.Remove.

Source Files

View all Source files

Directories

Path Synopsis
Package generate is for generating the boilerplate code required for the generic API.
 Package generate is for generating the boilerplate code required for the generic API.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.