remove demo game

core.manager.go

@@ -0,0 +1,95 @@
+package pncdsl
+
+import "sort"
+
+// Named is implemented by every entity that can be registered into a Manager.
+type Named interface {
+	GetName() string
+}
+
+// Manager is the single registry shape used by every entity type. Each entity
+// kind gets a named alias (ItemManager = Manager[Item], etc.). Insertion
+// order is preserved — Names() returns it. SortedNames() returns alphabetical.
+type Manager[T Named] struct {
+	items map[string]T
+	order []string
+}
+
+func NewManager[T Named]() *Manager[T] {
+	return &Manager[T]{items: make(map[string]T)}
+}
+
+// Register adds v to the registry. Panics on empty or duplicate name —
+// these are construction-time bugs, not runtime conditions.
+func (m *Manager[T]) Register(v T) {
+	name := v.GetName()
+	if name == "" {
+		panic("pncdsl: Register: empty Name on " + typeName(v))
+	}
+	if _, dup := m.items[name]; dup {
+		panic("pncdsl: Register: duplicate " + typeName(v) + " name: " + name)
+	}
+	m.items[name] = v
+	m.order = append(m.order, name)
+}
+
+func (m *Manager[T]) Get(name string) (T, bool) {
+	v, ok := m.items[name]
+	return v, ok
+}
+
+func (m *Manager[T]) MustGet(name string) T {
+	v, ok := m.items[name]
+	if !ok {
+		panic("pncdsl: MustGet: unknown name: " + name)
+	}
+	return v
+}
+
+func (m *Manager[T]) Has(name string) bool {
+	_, ok := m.items[name]
+	return ok
+}
+
+func (m *Manager[T]) Len() int { return len(m.items) }
+
+// Names returns the registered names in insertion order. Use SortedNames
+// when iteration order needs to be stable across runs.
+func (m *Manager[T]) Names() []string {
+	return append([]string(nil), m.order...)
+}
+
+func (m *Manager[T]) SortedNames() []string {
+	names := append([]string(nil), m.order...)
+	sort.Strings(names)
+	return names
+}
+
+func (m *Manager[T]) Each(fn func(T)) {
+	for _, n := range m.order {
+		fn(m.items[n])
+	}
+}
+
+// Remove drops a registered entry. Used by hot-reload / dynamic UI changes.
+// Silently no-ops on unknown names.
+func (m *Manager[T]) Remove(name string) {
+	if _, ok := m.items[name]; !ok {
+		return
+	}
+	delete(m.items, name)
+	for i, n := range m.order {
+		if n == name {
+			m.order = append(m.order[:i], m.order[i+1:]...)
+			return
+		}
+	}
+}
+
+func typeName(v any) string {
+	type namer interface{ TypeLabel() string }
+	if n, ok := v.(namer); ok {
+		return n.TypeLabel()
+	}
+	return "entity"
+}