feat: old standalone trigger systems completely unified into trigger->condition->action system

1 files changed, 0 insertions, 330 deletions

diff --git a/internal/world/trigger_store.go b/internal/world/trigger_store.go
deleted file mode 100644
index e50ae81..0000000
--- a/internal/world/trigger_store.go
+++ /dev/null
@@ -1,330 +0,0 @@
-package world
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"gopkg.in/yaml.v3"
-	"thehouseoficarus/internal/behavior"
-	"thehouseoficarus/internal/engine"
-)
-
-type TriggerStore struct {
-	mu sync.Mutex
-
-	globalByPlayerFlag map[string][]*TriggerDef
-	globalByGlobalFlag map[string][]*TriggerDef
-	roomByPlayerFlag   map[int]map[string][]*TriggerDef
-	roomByGlobalFlag   map[int]map[string][]*TriggerDef
-
-	playerSeqs map[string]*PlayerTriggerSeq
-	globalSeqs map[string]*GlobalTriggerSeq
-}
-
-type PlayerTriggerSeq struct {
-	PlayerName string
-	TriggerID  string
-	RoomID     int
-	Steps      []behavior.StepAction
-	Wait       int
-	Started    bool
-	FlagValue  any
-}
-
-type GlobalTriggerSeq struct {
-	TriggerID string
-	RoomID    int
-	Steps     []behavior.StepAction
-	Wait      int
-	FlagValue any
-}
-
-func NewTriggerStore() *TriggerStore {
-	return &TriggerStore{
-		globalByPlayerFlag: make(map[string][]*TriggerDef),
-		globalByGlobalFlag: make(map[string][]*TriggerDef),
-		roomByPlayerFlag:   make(map[int]map[string][]*TriggerDef),
-		roomByGlobalFlag:   make(map[int]map[string][]*TriggerDef),
-		playerSeqs:         make(map[string]*PlayerTriggerSeq),
-		globalSeqs:         make(map[string]*GlobalTriggerSeq),
-	}
-}
-
-func (ts *TriggerStore) ClearTriggers() {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	ts.globalByPlayerFlag = make(map[string][]*TriggerDef)
-	ts.globalByGlobalFlag = make(map[string][]*TriggerDef)
-	ts.roomByPlayerFlag = make(map[int]map[string][]*TriggerDef)
-	ts.roomByGlobalFlag = make(map[int]map[string][]*TriggerDef)
-}
-
-func (ts *TriggerStore) LoadGlobal(dataDir string) error {
-	dir := filepath.Join(dataDir, "triggers")
-	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		return nil
-	}
-
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		if entry.IsDir() {
-			continue
-		}
-		path := filepath.Join(dir, entry.Name())
-		ext := strings.ToLower(filepath.Ext(path))
-		if ext != ".yaml" && ext != ".yml" {
-			continue
-		}
-		id := strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name()))
-		data, err := os.ReadFile(path)
-		if err != nil {
-			continue
-		}
-		var trigger TriggerDef
-		if err := yaml.Unmarshal(data, &trigger); err != nil {
-			return fmt.Errorf("trigger %q: %w", path, err)
-		}
-		trigger.ID = id
-		ts.addGlobal(&trigger)
-	}
-	return nil
-}
-
-func (ts *TriggerStore) SeedRoomTriggers(roomID int, triggers []TriggerDef) {
-	if len(triggers) == 0 {
-		return
-	}
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	for i := range triggers {
-		t := &triggers[i]
-		if t.IsPlayerFlagTrigger() {
-			if ts.roomByPlayerFlag[roomID] == nil {
-				ts.roomByPlayerFlag[roomID] = make(map[string][]*TriggerDef)
-			}
-			ts.roomByPlayerFlag[roomID][t.OnPlayerFlag] = append(
-				ts.roomByPlayerFlag[roomID][t.OnPlayerFlag], t)
-		}
-		if t.IsGlobalFlagTrigger() {
-			if ts.roomByGlobalFlag[roomID] == nil {
-				ts.roomByGlobalFlag[roomID] = make(map[string][]*TriggerDef)
-			}
-			t.Room = roomID
-			ts.roomByGlobalFlag[roomID][t.OnGlobalFlag] = append(
-				ts.roomByGlobalFlag[roomID][t.OnGlobalFlag], t)
-		}
-	}
-}
-
-func (ts *TriggerStore) addGlobal(t *TriggerDef) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	if t.IsPlayerFlagTrigger() {
-		ts.globalByPlayerFlag[t.OnPlayerFlag] = append(
-			ts.globalByPlayerFlag[t.OnPlayerFlag], t)
-	}
-	if t.IsGlobalFlagTrigger() {
-		ts.globalByGlobalFlag[t.OnGlobalFlag] = append(
-			ts.globalByGlobalFlag[t.OnGlobalFlag], t)
-	}
-}
-
-func (ts *TriggerStore) FirePlayer(playerName string, flagName string, flagValue any) []*PlayerTriggerSeq {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-
-	var started []*PlayerTriggerSeq
-
-	for _, t := range ts.globalByPlayerFlag[flagName] {
-		if !ts.valueMatches(t.Value, flagValue) {
-			continue
-		}
-		seq := ts.startPlayerSeqLocked(playerName, t, 0, flagValue)
-		if seq != nil {
-			started = append(started, seq)
-		}
-	}
-
-	return started
-}
-
-func (ts *TriggerStore) FirePlayerInRoom(playerName string, roomID int, flagName string, flagValue any) []*PlayerTriggerSeq {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-
-	var started []*PlayerTriggerSeq
-
-	for _, t := range ts.globalByPlayerFlag[flagName] {
-		if !ts.valueMatches(t.Value, flagValue) {
-			continue
-		}
-		seq := ts.startPlayerSeqLocked(playerName, t, roomID, flagValue)
-		if seq != nil {
-			started = append(started, seq)
-		}
-	}
-
-	if roomFlags, ok := ts.roomByPlayerFlag[roomID]; ok {
-		for _, t := range roomFlags[flagName] {
-			if !ts.valueMatches(t.Value, flagValue) {
-				continue
-			}
-			seq := ts.startPlayerSeqLocked(playerName, t, roomID, flagValue)
-			if seq != nil {
-				started = append(started, seq)
-			}
-		}
-	}
-
-	return started
-}
-
-func (ts *TriggerStore) FireGlobal(flagName string, flagValue any) []*GlobalTriggerSeq {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-
-	var started []*GlobalTriggerSeq
-
-	for _, t := range ts.globalByGlobalFlag[flagName] {
-		if !ts.valueMatches(t.Value, flagValue) {
-			continue
-		}
-		seq := ts.startGlobalSeqLocked(t, flagValue)
-		if seq != nil {
-			started = append(started, seq)
-		}
-	}
-
-	for roomID, roomFlags := range ts.roomByGlobalFlag {
-		for _, t := range roomFlags[flagName] {
-			if !ts.valueMatches(t.Value, flagValue) {
-				continue
-			}
-			if t.Room == 0 {
-				t.Room = roomID
-			}
-			seq := ts.startGlobalSeqLocked(t, flagValue)
-			if seq != nil {
-				started = append(started, seq)
-			}
-		}
-	}
-
-	return started
-}
-
-func (ts *TriggerStore) startPlayerSeqLocked(playerName string, t *TriggerDef, roomID int, flagValue any) *PlayerTriggerSeq {
-	key := playerName + ":" + t.ID
-	if _, exists := ts.playerSeqs[key]; exists {
-		return nil
-	}
-	seq := &PlayerTriggerSeq{
-		PlayerName: playerName,
-		TriggerID:  t.ID,
-		RoomID:     roomID,
-		Steps:      make([]behavior.StepAction, len(t.Steps)),
-		FlagValue:  flagValue,
-	}
-	copy(seq.Steps, t.Steps)
-	if len(seq.Steps) > 0 {
-		seq.Wait = seq.Steps[0].Delay
-	}
-	ts.playerSeqs[key] = seq
-	return seq
-}
-
-func (ts *TriggerStore) startGlobalSeqLocked(t *TriggerDef, flagValue any) *GlobalTriggerSeq {
-	key := t.ID
-	if _, exists := ts.globalSeqs[key]; exists {
-		return nil
-	}
-	seq := &GlobalTriggerSeq{
-		TriggerID: t.ID,
-		RoomID:    t.Room,
-		Steps:     make([]behavior.StepAction, len(t.Steps)),
-		FlagValue: flagValue,
-	}
-	copy(seq.Steps, t.Steps)
-	if len(seq.Steps) > 0 {
-		seq.Wait = seq.Steps[0].Delay
-	}
-	ts.globalSeqs[key] = seq
-	return seq
-}
-
-func (ts *TriggerStore) valueMatches(want, got any) bool {
-	if want == nil {
-		return true
-	}
-	return engine.ValuesEqual(want, got)
-}
-
-func (ts *TriggerStore) SnapshotPlayerSeqs() []*PlayerTriggerSeq {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	out := make([]*PlayerTriggerSeq, 0, len(ts.playerSeqs))
-	for _, s := range ts.playerSeqs {
-		out = append(out, s)
-	}
-	return out
-}
-
-func (ts *TriggerStore) SnapshotGlobalSeqs() []*GlobalTriggerSeq {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	out := make([]*GlobalTriggerSeq, 0, len(ts.globalSeqs))
-	for _, s := range ts.globalSeqs {
-		out = append(out, s)
-	}
-	return out
-}
-
-func (ts *TriggerStore) RemovePlayerSeq(playerName, triggerID string) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	key := playerName + ":" + triggerID
-	delete(ts.playerSeqs, key)
-}
-
-func (ts *TriggerStore) RemoveGlobalSeq(triggerID string) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	delete(ts.globalSeqs, triggerID)
-}
-
-func (ts *TriggerStore) AllGlobalTriggers() []*TriggerDef {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	var out []*TriggerDef
-	for _, triggers := range ts.globalByPlayerFlag {
-		out = append(out, triggers...)
-	}
-	for _, triggers := range ts.globalByGlobalFlag {
-		out = append(out, triggers...)
-	}
-	return out
-}
-
-func (ts *TriggerStore) AllRoomTriggers() map[int][]*TriggerDef {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	out := make(map[int][]*TriggerDef)
-	for roomID, byFlag := range ts.roomByPlayerFlag {
-		for _, triggers := range byFlag {
-			out[roomID] = append(out[roomID], triggers...)
-		}
-	}
-	for roomID, byFlag := range ts.roomByGlobalFlag {
-		for _, triggers := range byFlag {
-			out[roomID] = append(out[roomID], triggers...)
-		}
-	}
-	return out
-}