generic

Feb 19, 2024

Changes in this version

type Filter0

+ func (f *Filter0) Exclusive() *Filter0

type Filter1

+ func (f *Filter1[A]) Exclusive() *Filter1[A]

type Filter10

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Exclusive() *Filter10[A, B, C, D, E, F, G, H, I, J]

type Filter11

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Exclusive() *Filter11[A, B, C, D, E, F, G, H, I, J, K]

type Filter12

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Exclusive() *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]

type Filter2

+ func (f *Filter2[A, B]) Exclusive() *Filter2[A, B]

type Filter3

+ func (f *Filter3[A, B, C]) Exclusive() *Filter3[A, B, C]

type Filter4

+ func (f *Filter4[A, B, C, D]) Exclusive() *Filter4[A, B, C, D]

type Filter5

+ func (f *Filter5[A, B, C, D, E]) Exclusive() *Filter5[A, B, C, D, E]

type Filter6

+ func (f *Filter6[A, B, C, D, E, F]) Exclusive() *Filter6[A, B, C, D, E, F]

type Filter7

+ func (f *Filter7[A, B, C, D, E, F, G]) Exclusive() *Filter7[A, B, C, D, E, F, G]

type Filter8

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

type Filter9

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Exclusive() *Filter9[A, B, C, D, E, F, G, H, I]

Jan 21, 2024

Changes in this version

type Comp

+ func T10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any]() []Comp

+ func T11[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any, K any]() []Comp

+ func T12[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any, K any, ...]() []Comp

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

type Exchange

+ func (m *Exchange) ExchangeBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Exchange) WithRelation(comp Comp) *Exchange

+ type Filter10 filter

+ func NewFilter10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any]() *Filter10[A, B, C, D, E, F, G, H, I, J]

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Filter(w *ecs.World, target ...ecs.Entity) ecs.Filter

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Optional(mask ...Comp) *Filter10[A, B, C, D, E, F, G, H, I, J]

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Query(w *ecs.World, target ...ecs.Entity) Query10[A, B, C, D, E, F, G, H, I, J]

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Register(w *ecs.World)

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Unregister(w *ecs.World)

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) With(mask ...Comp) *Filter10[A, B, C, D, E, F, G, H, I, J]

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) WithRelation(comp Comp, target ...ecs.Entity) *Filter10[A, B, C, D, E, F, G, H, I, J]

+ func (f *Filter10[A, B, C, D, E, F, G, H, I, J]) Without(mask ...Comp) *Filter10[A, B, C, D, E, F, G, H, I, J]

+ type Filter11 filter

+ func NewFilter11[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any, K any]() *Filter11[A, B, C, D, E, F, G, H, I, J, K]

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Filter(w *ecs.World, target ...ecs.Entity) ecs.Filter

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Optional(mask ...Comp) *Filter11[A, B, C, D, E, F, G, H, I, J, K]

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Query(w *ecs.World, target ...ecs.Entity) Query11[A, B, C, D, E, F, G, H, I, J, K]

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Register(w *ecs.World)

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Unregister(w *ecs.World)

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) With(mask ...Comp) *Filter11[A, B, C, D, E, F, G, H, I, J, K]

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) WithRelation(comp Comp, target ...ecs.Entity) *Filter11[A, B, C, D, E, F, G, H, I, J, K]

+ func (f *Filter11[A, B, C, D, E, F, G, H, I, J, K]) Without(mask ...Comp) *Filter11[A, B, C, D, E, F, G, H, I, J, K]

+ type Filter12 filter

+ func NewFilter12[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any, K any, ...]() *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Filter(w *ecs.World, target ...ecs.Entity) ecs.Filter

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Optional(mask ...Comp) *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Query(w *ecs.World, target ...ecs.Entity) Query12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Register(w *ecs.World)

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Unregister(w *ecs.World)

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) With(mask ...Comp) *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) WithRelation(comp Comp, target ...ecs.Entity) *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (f *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]) Without(mask ...Comp) *Filter12[A, B, C, D, E, F, G, H, I, J, K, L]

+ type Filter9 filter

+ func NewFilter9[A any, B any, C any, D any, E any, F any, G any, H any, I any]() *Filter9[A, B, C, D, E, F, G, H, I]

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Filter(w *ecs.World, target ...ecs.Entity) ecs.Filter

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Optional(mask ...Comp) *Filter9[A, B, C, D, E, F, G, H, I]

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Query(w *ecs.World, target ...ecs.Entity) Query9[A, B, C, D, E, F, G, H, I]

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Register(w *ecs.World)

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Unregister(w *ecs.World)

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) With(mask ...Comp) *Filter9[A, B, C, D, E, F, G, H, I]

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) WithRelation(comp Comp, target ...ecs.Entity) *Filter9[A, B, C, D, E, F, G, H, I]

+ func (f *Filter9[A, B, C, D, E, F, G, H, I]) Without(mask ...Comp) *Filter9[A, B, C, D, E, F, G, H, I]

type Map

+ func (m *Map[T]) SetRelationBatch(filter ecs.Filter, target ecs.Entity) int

+ func (m *Map[T]) SetRelationBatchQ(filter ecs.Filter, target ecs.Entity) Query1[T]

type Map1

+ func (m *Map1[A]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map1[A]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query1[A]

+ func (m *Map1[A]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map1[A]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

+ type Map10 struct

+ func NewMap10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](w *ecs.World, relation ...Comp) Map10[A, B, C, D, E, F, G, H, I, J]

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) Add(entity ecs.Entity, target ...ecs.Entity)

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query10[A, B, C, D, E, F, G, H, I, J]

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

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

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

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

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

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) NewBatchQ(count int, target ...ecs.Entity) Query10[A, B, C, D, E, F, G, H, I, J]

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) NewWith(a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H, i *I, j *J, ...) ecs.Entity

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) Remove(entity ecs.Entity, target ...ecs.Entity)

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map10[A, B, C, D, E, F, G, H, I, J]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

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

+ type Map11 struct

+ func NewMap11[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any, K any](w *ecs.World, relation ...Comp) Map11[A, B, C, D, E, F, G, H, I, J, K]

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) Add(entity ecs.Entity, target ...ecs.Entity)

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query11[A, B, C, D, E, F, G, H, I, J, K]

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H, i *I, j *J, ...)

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) Get(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J, *K)

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J, *K)

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) New(target ...ecs.Entity) ecs.Entity

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) NewBatch(count int, target ...ecs.Entity)

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) NewBatchQ(count int, target ...ecs.Entity) Query11[A, B, C, D, E, F, G, H, I, J, K]

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) NewWith(a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H, i *I, j *J, k *K, ...) ecs.Entity

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) Remove(entity ecs.Entity, target ...ecs.Entity)

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

+ func (m *Map11[A, B, C, D, E, F, G, H, I, J, K]) RemoveEntities(exclusive bool) int

+ type Map12 struct

+ func NewMap12[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any, K any, ...](w *ecs.World, relation ...Comp) Map12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) Add(entity ecs.Entity, target ...ecs.Entity)

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) Assign(entity ecs.Entity, a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H, i *I, j *J, ...)

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) Get(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J, *K, *L)

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) GetUnchecked(entity ecs.Entity) (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J, *K, *L)

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) New(target ...ecs.Entity) ecs.Entity

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) NewBatch(count int, target ...ecs.Entity)

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) NewBatchQ(count int, target ...ecs.Entity) Query12[A, B, C, D, E, F, G, H, I, J, K, L]

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) NewWith(a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H, i *I, j *J, k *K, l *L, ...) ecs.Entity

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) Remove(entity ecs.Entity, target ...ecs.Entity)

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

+ func (m *Map12[A, B, C, D, E, F, G, H, I, J, K, L]) RemoveEntities(exclusive bool) int

type Map2

+ func (m *Map2[A, B]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map2[A, B]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query2[A, B]

+ func (m *Map2[A, B]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map2[A, B]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

type Map3

+ func (m *Map3[A, B, C]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map3[A, B, C]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query3[A, B, C]

+ func (m *Map3[A, B, C]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map3[A, B, C]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

type Map4

+ func (m *Map4[A, B, C, D]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map4[A, B, C, D]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query4[A, B, C, D]

+ func (m *Map4[A, B, C, D]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map4[A, B, C, D]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

type Map5

+ func (m *Map5[A, B, C, D, E]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map5[A, B, C, D, E]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query5[A, B, C, D, E]

+ func (m *Map5[A, B, C, D, E]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map5[A, B, C, D, E]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

type Map6

+ func (m *Map6[A, B, C, D, E, F]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map6[A, B, C, D, E, F]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query6[A, B, C, D, E, F]

+ func (m *Map6[A, B, C, D, E, F]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map6[A, B, C, D, E, F]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

type Map7

+ func (m *Map7[A, B, C, D, E, F, G]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map7[A, B, C, D, E, F, G]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query7[A, B, C, D, E, F, G]

+ func (m *Map7[A, B, C, D, E, F, G]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map7[A, B, C, D, E, F, G]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

type Map8

+ func (m *Map8[A, B, C, D, E, F, G, H]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map8[A, B, C, D, E, F, G, H]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query8[A, B, C, D, E, F, G, H]

+ func (m *Map8[A, B, C, D, E, F, G, H]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map8[A, B, C, D, E, F, G, H]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

+ type Map9 struct

+ func NewMap9[A any, B any, C any, D any, E any, F any, G any, H any, I any](w *ecs.World, relation ...Comp) Map9[A, B, C, D, E, F, G, H, I]

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

+ func (m *Map9[A, B, C, D, E, F, G, H, I]) AddBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map9[A, B, C, D, E, F, G, H, I]) AddBatchQ(filter ecs.Filter, target ...ecs.Entity) Query9[A, B, C, D, E, F, G, H, I]

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

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

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

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

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

+ func (m *Map9[A, B, C, D, E, F, G, H, I]) NewBatchQ(count int, target ...ecs.Entity) Query9[A, B, C, D, E, F, G, H, I]

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

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

+ func (m *Map9[A, B, C, D, E, F, G, H, I]) RemoveBatch(filter ecs.Filter, target ...ecs.Entity) int

+ func (m *Map9[A, B, C, D, E, F, G, H, I]) RemoveBatchQ(filter ecs.Filter, target ...ecs.Entity) Query0

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

+ type Query10 struct

+ func (q *Query10[A, B, C, D, E, F, G, H, I, J]) Get() (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J)

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

+ type Query11 struct

+ func (q *Query11[A, B, C, D, E, F, G, H, I, J, K]) Get() (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J, *K)

+ func (q *Query11[A, B, C, D, E, F, G, H, I, J, K]) Relation() ecs.Entity

+ type Query12 struct

+ func (q *Query12[A, B, C, D, E, F, G, H, I, J, K, L]) Get() (*A, *B, *C, *D, *E, *F, *G, *H, *I, *J, *K, *L)

+ func (q *Query12[A, B, C, D, E, F, G, H, I, J, K, L]) Relation() ecs.Entity

+ type Query9 struct

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

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

May 29, 2023

Changes in this version

type Filter0

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

type Filter1

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

type Filter2

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

type Filter3

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

type Filter4

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

type Filter5

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

type Filter6

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

type Filter7

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

type Filter8

+ 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]

type Map

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

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

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

type Map1

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

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

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

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

type Map2

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

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

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

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

type Map3

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

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

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

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

type Map4

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

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

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

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

type Map5

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

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

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

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

type Map6

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

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

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

+ 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

type Map7

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

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

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

+ 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

type Map8

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

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

+ 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]

+ 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

type Query0

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

type Query1

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

type Query2

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

type Query3

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

type Query4

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

type Query5

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

type Query6

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

type Query7

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

type Query8

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

Apr 15, 2023

Changes in this version

type Map

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

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

type Map1

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

type Map2

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

type Map3

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

type Map4

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

type Map5

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

type Map6

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

type Map7

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

type Map8

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

Mar 31, 2023

Changes in this version

type Filter0

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

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

type Filter1

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

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

type Filter2

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

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

type Filter3

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

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

type Filter4

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

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

type Filter5

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

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

type Filter6

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

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

type Filter7

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

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

type Filter8

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

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

type Map1

+ func (m *Map1[A]) NewEntities(count int)

+ func (m *Map1[A]) NewEntitiesQuery(count int) Query1[A]

+ func (m *Map1[A]) NewEntitiesWith(count int, a *A)

+ func (m *Map1[A]) NewEntitiesWithQuery(count int, a *A) Query1[A]

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

type Map2

+ func (m *Map2[A, B]) NewEntities(count int)

+ func (m *Map2[A, B]) NewEntitiesQuery(count int) Query2[A, B]

+ func (m *Map2[A, B]) NewEntitiesWith(count int, a *A, b *B)

+ func (m *Map2[A, B]) NewEntitiesWithQuery(count int, a *A, b *B) Query2[A, B]

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

type Map3

+ func (m *Map3[A, B, C]) NewEntities(count int)

+ func (m *Map3[A, B, C]) NewEntitiesQuery(count int) Query3[A, B, C]

+ func (m *Map3[A, B, C]) NewEntitiesWith(count int, a *A, b *B, c *C)

+ func (m *Map3[A, B, C]) NewEntitiesWithQuery(count int, a *A, b *B, c *C) Query3[A, B, C]

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

type Map4

+ func (m *Map4[A, B, C, D]) NewEntities(count int)

+ func (m *Map4[A, B, C, D]) NewEntitiesQuery(count int) Query4[A, B, C, D]

+ func (m *Map4[A, B, C, D]) NewEntitiesWith(count int, a *A, b *B, c *C, d *D)

+ func (m *Map4[A, B, C, D]) NewEntitiesWithQuery(count int, a *A, b *B, c *C, d *D) Query4[A, B, C, D]

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

type Map5

+ func (m *Map5[A, B, C, D, E]) NewEntities(count int)

+ func (m *Map5[A, B, C, D, E]) NewEntitiesQuery(count int) Query5[A, B, C, D, E]

+ func (m *Map5[A, B, C, D, E]) NewEntitiesWith(count int, a *A, b *B, c *C, d *D, e *E)

+ func (m *Map5[A, B, C, D, E]) NewEntitiesWithQuery(count int, a *A, b *B, c *C, d *D, e *E) Query5[A, B, C, D, E]

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

type Map6

+ func (m *Map6[A, B, C, D, E, F]) NewEntities(count int)

+ func (m *Map6[A, B, C, D, E, F]) NewEntitiesQuery(count int) Query6[A, B, C, D, E, F]

+ func (m *Map6[A, B, C, D, E, F]) NewEntitiesWith(count int, a *A, b *B, c *C, d *D, e *E, f *F)

+ func (m *Map6[A, B, C, D, E, F]) NewEntitiesWithQuery(count int, a *A, b *B, c *C, d *D, e *E, f *F) Query6[A, B, C, D, E, F]

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

type Map7

+ func (m *Map7[A, B, C, D, E, F, G]) NewEntities(count int)

+ func (m *Map7[A, B, C, D, E, F, G]) NewEntitiesQuery(count int) Query7[A, B, C, D, E, F, G]

+ func (m *Map7[A, B, C, D, E, F, G]) NewEntitiesWith(count int, a *A, b *B, c *C, d *D, e *E, f *F, g *G)

+ func (m *Map7[A, B, C, D, E, F, G]) NewEntitiesWithQuery(count int, a *A, b *B, c *C, d *D, e *E, f *F, g *G) Query7[A, B, C, D, E, F, G]

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

type Map8

+ func (m *Map8[A, B, C, D, E, F, G, H]) NewEntities(count int)

+ func (m *Map8[A, B, C, D, E, F, G, H]) NewEntitiesQuery(count int) Query8[A, B, C, D, E, F, G, H]

+ func (m *Map8[A, B, C, D, E, F, G, H]) NewEntitiesWith(count int, a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H)

+ func (m *Map8[A, B, C, D, E, F, G, H]) NewEntitiesWithQuery(count int, a *A, b *B, c *C, d *D, e *E, f *F, g *G, h *H) Query8[A, B, C, D, E, F, G, H]

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

Mar 20, 2023

Changes in this version

+ type Resource struct

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

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

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

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

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

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

Feb 20, 2023

Changes in this version

+ type Comp reflect.Type

+ func T() Comp

+ func T1() []Comp

+ func T2() []Comp

+ func T3() []Comp

+ func T4() []Comp

+ func T5() []Comp

+ func T6() []Comp

+ func T7() []Comp

+ func T8() []Comp

+ type Exchange struct

+ func NewExchange(w *ecs.World) *Exchange

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

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

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

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

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

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

+ type Filter0 filter

+ func NewFilter0() *Filter0

+ func (q *Filter0) Filter(w *ecs.World) ecs.MaskFilter

+ func (q *Filter0) Query(w *ecs.World) Query0

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

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

+ type Filter1 filter

+ func NewFilter1() *Filter1[A]

+ func (q *Filter1[A]) Filter(w *ecs.World) ecs.MaskFilter

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

+ func (q *Filter1[A]) Query(w *ecs.World) Query1[A]

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

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

+ type Filter2 filter

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

+ func (q *Filter2[A, B]) Filter(w *ecs.World) ecs.MaskFilter

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

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

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

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

+ type Filter3 filter

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

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

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

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

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

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

+ type Filter4 filter

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

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

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

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

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

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

+ type Filter5 filter

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

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

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

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

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

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

+ type Filter6 filter

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

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

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

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

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

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

+ type Filter7 filter

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

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

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

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

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

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

+ type Filter8 filter

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

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

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

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

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

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

+ type Map struct

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

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

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

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

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

+ type Map1 mapper

+ func NewMap1(w *ecs.World) Map1[A]

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

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

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

+ func (m *Map1[A]) NewEntity() (ecs.Entity, *A)

+ func (m *Map1[A]) NewEntityWith(a *A) (ecs.Entity, *A)

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

+ type Map2 mapper

+ func NewMap2(w *ecs.World) Map2[A, B]

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

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

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

+ func (m *Map2[A, B]) NewEntity() (ecs.Entity, *A, *B)

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

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

+ type Map3 mapper

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

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

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

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

+ func (m *Map3[A, B, C]) NewEntity() (ecs.Entity, *A, *B, *C)

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

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

+ type Map4 mapper

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

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

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

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

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

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

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

+ type Map5 mapper

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

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

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

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

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

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

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

+ type Map6 mapper

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

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

+ 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) (*A, *B, *C, *D, *E, *F)

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

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

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

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

+ type Map7 mapper

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

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

+ 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) (*A, *B, *C, *D, *E, *F, *G)

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

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

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

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

+ type Map8 mapper

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

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

+ 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) (*A, *B, *C, *D, *E, *F, *G, *H)

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

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

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

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

+ type Query0 query

+ type Query1 query

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

+ type Query2 query

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

+ type Query3 query

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

+ type Query4 query

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

+ type Query5 query

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

+ type Query6 query

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

+ type Query7 query

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

+ type Query8 query

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