Context/Error in Intialize

[delaneyj]

I understand the runtime panic as designed for misuse
https://mlange-42.github.io/arche/background/design/index.html

However, there should be ways to indicate invalid system addition. Seem like
Initialize(w *ecs.World)
maybe should be
Initialize(ctx context.Context, w *ecs.World) error

[mlange-42]

Not really sure what you mean here. Can you give an example or explain more in detail? Is this a general issue, or particularly related to system addition?

[delaneyj]

Sure, so I have a GLTF and depending on the data an Automation System may not be able to initialize. I don't think think should be able to cause a panic.

[mlange-42]

Sorry, but I do still not really get it. What I understand is that you don't want panics.

Everything in Arche, and most things around it (I may be missing something in arche-model) that could cause a panic can be checked somehow beforehand if necessary. Could you give an example where you experience panics?

As you write very briefly, I can only guess that you might want to be able to handle failing checks.

Generally, for "communication" between/across systems (where it is not conveyed through entities), there are Resources. A system can store a potential error in a resource and you can access it from outside, or from another system.

[delaneyj]

There are times when you need to check a database or the contents of files during init to get into a valid state. If Initialize returns nothing then you have to panic, this is not ideal when the ECS is part of a larger system (for example http.Server on another Go routine).

[mlange-42]

How about adding the context as a resource?

[delaneyj]

Context as a resource works

import (
	"context"

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

type Context struct {
	Ctx context.Context
}

type ContextSystem struct {
	Ctx    context.Context
	ctxRes generic.Resource[Context]
	sysRes generic.Resource[model.Systems]
}

func (sys *ContextSystem) Initialize(w *ecs.World) {
	if sys.Ctx == nil {
		panic("ContextSystem: Context is nil")
	}
	sys.ctxRes = generic.NewResource[Context](w)
	sys.ctxRes.Add(&Context{
		Ctx: sys.Ctx,
	})
	sys.sysRes = generic.NewResource[model.Systems](w)
}

func (sys *ContextSystem) Update(w *ecs.World) {
	select {
	case <-sys.Ctx.Done():
		res := generic.NewResource[resource.Termination](w)
		res.Get().Terminate = true
	default:
	}
}

func (sys *ContextSystem) Finalize(w *ecs.World) {
}

Though it brings up a point about wanting different systems on different update intervals. Physic may want a 1ms update but checking for context could be 5s interval