Cant seem to get filters working correctly with my entities.

[c-robinson]

I'm new to Arche and am interested to see how it works, but I think I must be missing a step when working with filters.

I get a new entity with entity := world.NewEntity()

Then I generate the components I need, populate them, and assign them with:

world.Assign(
	entity,
	ecs.Component{ID: gctx.ECSComponents[components.ArticulatedBodyID], Comp: body},
	ecs.Component{ID: gctx.ECSComponents[components.SpriteMeshID], Comp: mesh},
	ecs.Component{ID: gctx.ECSComponents[components.TransformID], Comp: transform},

)

So far so good, and in fact if I query for everything, via:

filter := ecs.All()
query := world.Query(filter)
for query.Next() {
	s.l.Debug("ENTITY %+v", query.Entity())
	ptr := query.Get(compid[components.TransformID])
	trs := (*components.Transform)(ptr)
	s.l.Debug("TRS %+v", trs)
	ptr = query.Get(compid[components.ArticulatedBodyID])
	art := (*components.ArticulatedBody)(ptr)
	s.l.Debug("ART %+v", art)
	ptr = query.Get(compid[components.SpriteMeshID])
	spm := (*components.SpriteMesh)(ptr)
	s.l.Debug("SPM %+v", spm)
}

I can see all the components, exactly as I expect them. However when I try to query based on a filter that I pre-created and registered via:

filter := generic.NewFilter3[components.Transform, components.ArticulatedBody, components.SpriteMesh]()
filter.Register(world)

I get 0 entities in:

query := filter.Query(world)
for query.Next() {
	transform, body, mesh := query.Get()
	s.l.Debug("got transform: %+v", transform)
        ...
}

Am I missing a step? Am I just totally misunderstanding how this works?

[mlange-42]

Hi @c-robinson,

at first glance, all looks fine. But for the generic part that does not work for you, the code it too incomplete to actually judge.

I can just guess that something is wrong with your ID lookup compid[...]/gctx.ECSComponents[...]. Which you should generally avoid inside query iteration, as it is very slow (in case you use a map), compared to the query itself.

Regarding generic filters, registering them is not necessary and is only an optimization for cases where you have a very high number of archetypes (i.e. unique component combinations). Could you try your example without registering the filter? If that works, it is probably a bug in the filter cache.

Could you please post a more complete reproducing example of what does not work for you? Thanks!

[c-robinson]

Certainly, and thanks for the assistance!

Which you should generally avoid inside query iteration, as it is very slow (in case you use a map), compared to the query itself.

Removed, am fetching via ecs.ComponentID now. It didn't correct the issue but having removed all my calls to the map I can see that it was unnecessary 😆

I have interfaces for the system types, for example:

type DrawSystem interface {
	Do(world *ecs.World, screen *ebiten.Image, viewable image.Rectangle)
	OnClose()
}

Here's part of the implementation for the system that isn't working:

type (
	DrawArticulatedBodyFilter = *generic.Filter3[components.Transform, components.ArticulatedBody, components.SpriteMesh]
)

type DrawArticulatedSystem struct {
	filter DrawArticulatedBodyFilter
}

func NewDrawArticulatedSystem(gctx *global.Context) DrawSystem {
	filter := generic.NewFilter3[components.Transform, components.ArticulatedBody, components.SpriteMesh]()
	filter.Register(gctx.ECSWorld)
	return &DrawArticulatedSystem{
		filter: filter,
	}
}

func (s *DrawArticulatedSystem) Do(world *ecs.World, screen *ebiten.Image, viewable image.Rectangle) {
	query := s.filter.Query(world)
	for query.Next() {
		transform, abody, mesh := query.Get()
                [... game logic ...]
        }
}

func (s *DrawArticulatedSystem) OnClose() {}

In my game scene initializer, I create an array of DrawSystems:

        drawSystems := []systems.DrawSystem{
		systems.NewDrawArticulatedSystem(gctx),
	}

And then I call them in my draw loop:

        for _, system := range s.drawSystems {
		system.Do(s.gctx.ECSWorld, buffer, viewArea)
	}

And that part all seems fine, i also have "UpdateSystems" that are created the exact same way, and my update loop is functioning correctly. Also it's weird that inside the Draw loop I can see all 3 target components fine, and that they are registered with the entity.

The component that is failing seems to be ArticulatedBody, which looks like:

type ArticulatedBody struct {
	Parts []BodyPart
}

type BodyPart struct {
	Type     string
	Rotation helpers.Angle
	Pivot    image.Point
	Parent   int

	BaseMaxRotation   float64
	BaseRotationSpeed float64

	CurrentMaxRotation   float64
	CurrentRotationSpeed float64
}

[mlange-42]

See my reply to your other comment for the issue.

Removed, am fetching via ecs.ComponentID now

But you should still not use that inside query iteration code! Get the IDs before the loop, or ideally get them during system initialization and store them. Or even better, use the generic API throughout and don't deal with IDs at all.

[c-robinson]

I think I found it. Looks like Arche does not like slices? if I switch ArticulatedBody to:

type ArticulatedBody struct {
	Parts [4]BodyPart
}

It works. Trying to use []*BodyPart was also a no-go. Is this a result of how Arche manages memory? Is the problem that BodyPart is not registered with Arche?

[mlange-42]

Thank you for providing these details! However, I would not be aware why slices should be a problem. They were a problem regarding garbage collection in the beginning, but that is fixed and covered by the unit tests.

I will try to reproduce the issue with the types you showed.

Could you also show your entity creation code? Do you use the generic API there (i.e MapX)?

EDIT: No, registering BodyPart (as a component) is not necessary.

[mlange-42]

Here is a minimal example that uses all the types as you do, and a slice of body parts. It just works fine for me.

package main

import (
	"fmt"
	"image"

	"github.com/mlange-42/arche/ecs"
	"github.com/mlange-42/arche/generic"
)

type (
	DrawArticulatedBodyFilter = *generic.Filter3[Transform, ArticulatedBody, SpriteMesh]
)

type Transform struct{}

type SpriteMesh struct{}

type ArticulatedBody struct {
	Parts []BodyPart
}

type BodyPart struct {
	Type  string
	Pivot image.Point
}

type DrawSystem interface {
	Do(world *ecs.World)
	OnClose()
}

type DrawArticulatedSystem struct {
	filter DrawArticulatedBodyFilter
}

func NewDrawArticulatedSystem(world *ecs.World) DrawSystem {
	filter := generic.NewFilter3[Transform, ArticulatedBody, SpriteMesh]()
	filter.Register(world)
	return &DrawArticulatedSystem{
		filter: filter,
	}
}

func (s *DrawArticulatedSystem) Do(world *ecs.World) {
	query := s.filter.Query(world)
	for query.Next() {
		_, abody, _ := query.Get()
		fmt.Println(abody)
	}
}

func (s *DrawArticulatedSystem) OnClose() {}

func main() {
	world := ecs.NewWorld()

	var sys DrawSystem = NewDrawArticulatedSystem(&world)

	mapper := generic.NewMap3[Transform, ArticulatedBody, SpriteMesh](&world)
	mapper.NewWith(
		&Transform{},
		&ArticulatedBody{
			Parts: []BodyPart{
				{Type: "head"},
				{Type: "torso"},
			},
		},
		&SpriteMesh{},
	)
	mapper.NewWith(
		&Transform{},
		&ArticulatedBody{
			Parts: []BodyPart{
				{Type: "arm"},
				{Type: "leg"},
			},
		},
		&SpriteMesh{},
	)

	sys.Do(&world)
}

[c-robinson]

Could you also show your entity creation code? Do you use the generic API there (i.e MapX)?

Here you go. It's just test code as I figure out how everything works:

func NewHuman(gctx *global.Context, spritesheet *ebiten.Image, x, y float64, facing helpers.Angle) ecs.Entity {
	world := gctx.ECSWorld
	entity := world.NewEntity()

	transform := &components.Transform{
		Orientation: facing,
		Position:    helpers.Vector{X: x, Y: y},
	}

	// Define normal human rotation capabilities
	const (
		normalHeadMaxRotation  = math.Pi / 3  // 60 degrees
		normalHeadTurnSpeed    = math.Pi / 32 // adjust as needed
		normalTorsoMaxRotation = math.Pi / 2  // 90 degrees
		normalTorsoTurnSpeed   = math.Pi / 48 // adjust as needed
	)

	body := &components.ArticulatedBody{
		Parts: [2]components.BodyPart{
			{
				Type:     "torso",
				Parent:   -1,
				Pivot:    image.Point{0, 0},
				Rotation: helpers.NewAngle(0),
				// Torso rotation capabilities
				BaseMaxRotation:      normalTorsoMaxRotation,
				BaseRotationSpeed:    normalTorsoTurnSpeed,
				CurrentMaxRotation:   normalTorsoMaxRotation,
				CurrentRotationSpeed: normalTorsoTurnSpeed,
			},
			{
				Type:     "head",
				Parent:   0,
				Pivot:    image.Point{0, -20},
				Rotation: helpers.NewAngle(0),
				// Head rotation capabilities
				BaseMaxRotation:      normalHeadMaxRotation,
				BaseRotationSpeed:    normalHeadTurnSpeed,
				CurrentMaxRotation:   normalHeadMaxRotation,
				CurrentRotationSpeed: normalHeadTurnSpeed,
			},
		},
	}

	character := &components.Character{
		Goal:     "",
		Traits:   nil,
		AvgSpeed: 1.0,
	}

	focus := &components.Focus{
		Target: image.Point{
			X: int(x + math.Cos(facing.Radians())*100),
			Y: int(y + math.Sin(facing.Radians())*100),
		},
	}

	torso := entities.Sprite{
		Frame:       image.Rect(0, 0, 31, 31),
		Center:      image.Point{},
		Orientation: helpers.Angle{},
	}

	head := entities.Sprite{
		Frame:       image.Rect(0, 32, 15, 47),
		Center:      image.Point{},
		Orientation: helpers.Angle{},
	}

	mesh := &components.SpriteMesh{
		Sprites: []entities.Sprite{torso, head},
		Center:  image.Point{},
		Sheet:   spritesheet,
	}

	bodyId := ecs.ComponentID[components.ArticulatedBody](world)
	characterId := ecs.ComponentID[components.Character](world)
	focusId := ecs.ComponentID[components.Focus](world)
	meshId := ecs.ComponentID[components.SpriteMesh](world)
	transformId := ecs.ComponentID[components.Transform](world)

	world.Assign(
		entity,
		ecs.Component{ID: bodyId, Comp: body},
		ecs.Component{ID: characterId, Comp: character},
		ecs.Component{ID: focusId, Comp: focus},
		ecs.Component{ID: meshId, Comp: mesh},
		ecs.Component{ID: transformId, Comp: transform},
	)

	return entity
}

The player inherits from this, and that code looks like:

func NewPlayer(gctx *global.Context, spritesheet *ebiten.Image) *Player {
	world := gctx.ECSWorld
	// Create base human Entity
	entity := humans.NewHuman(gctx, spritesheet, 34, 34, helpers.NewAngle(0))

	// Get references to components we created via NewHuman
	bodyId := ecs.ComponentID[components.ArticulatedBody](world)
	characterId := ecs.ComponentID[components.Character](world)
	focusId := ecs.ComponentID[components.Focus](world)
	transformId := ecs.ComponentID[components.Transform](world)
	char := (*components.Character)(world.Get(entity, characterId))
	body := (*components.ArticulatedBody)(world.Get(entity, bodyId))
	focus := (*components.Focus)(world.Get(entity, focusId))
	trs := (*components.Transform)(world.Get(entity, transformId))

	return &Player{
		gctx:            gctx,
		Entity:          entity,
		ArticulatedBody: body,
		Char:            char,
		Focus:           focus,
		Transform:       trs,
	}
}

[mlange-42]

Have no access to my computer for a few days, so I can't do any tests at the moment.

However, your Player implementation is problematic. Component pointers should never be stored anywhere persistently, as those are not persistent themselves. You should always retrieve them when needed, through a query or via World.Get. In ECS, the only thing you should ever store persistently are entities (via copy, never via pointers).

The thing is that entities (and thus components) may change their index inside archetypes when (other) entities are removed or moved to another archetype. Pointers may then be dangling, or just point to a different component instance.

EDIT: It is generally recommended to use the generic API instead of the ID-based one, unless you have a good reason.

[mlange-42]

@c-robinson Thanks again for the entity initialization code you provided. I could now test it, and there is indeed an issue regarding slices.

Looks like the problem is that, when creating components with already populated slices, the original slice gets garbage collected. This is a bit weird, as it seems to happen only in certain cases. As an example, when I print body in NewHuman, it works fine. But maybe GC'ing is just delayed then.

For some reason, it also works when creating and populating the entity with generic.Map3.NewWith.

As a temporary workaround for the ID-based API, you can create your ArticulatedBody with an empty/nil Parts slice, and add body parts after the world.Assign:

body := &ArticulatedBody{}
// ...
world.Assign(entity,
    //...
)

body = (*ArticulatedBody)(world.Get(entity, bodyId))
body.Parts = append(body.Parts,
    BodyPart{
	Type:  "torso",
	Pivot: image.Point{0, 0},
    },
)
body.Parts = append(body.Parts,
    BodyPart{
	Type:  "head",
	Pivot: image.Point{0, -20},
    },
)

[c-robinson]

This is excellent, thank you! BTW: the issue I am having and the reason for using the ID-based API is because the inputs for Player are different then they will be for any NPC, I was intending to use the generic API for every other case. That's also why I was keeping a copy of some of the objects, so that Player could be updated separately but still interact with the rest of the world properly. I appreciate the guidance and will figure out a different way to do this that doesn't involve holding onto objects that Arche controls.

[mlange-42]

Thanks again for reporting! I opened issue #437 for this and am about to investigate whether this can be fixed. In case not, I may have to remove the affected methods. Or add a big caution to the docs, which I would really dislike.

I'd suggest to just store the player's entity, and to obtain the components when needed, via World.Get or (even better) one of the generic Map(X) types. The overhead over direct access (as it is now) is less than 2ns (see the benchmark tables), so this is absolutely negligible for this single player entity.

[mlange-42]

@c-robinson I think I fixed the issue. Could you give it a try with branch fix-assign main (see PR #438)?

[c-robinson]

That got it, works perfectly for me!

To test:

• backed out my explicit array for the original slice and ran the game. It consistently crashed or hung for me within 3-5 seconds and the instance of ArticulatedBody owned by Player did not render.
• grabbed the latest version of arche and ran the game. It consistently works, no crashes. I've had an instance running for the last 15 minutes. Also, Player is rendering fine.