rename flags to global_flags (differentiate from player_flags)

6 files changed, 47 insertions, 47 deletions

diff --git a/internal/world/grid_test.go b/internal/world/grid_test.go
index 04d749c..9c2c7c6 100644
--- a/internal/world/grid_test.go
+++ b/internal/world/grid_test.go
@@ -117,11 +117,11 @@ func TestBuildGridConflictsHypotheticalInsert(t *testing.T) {
 			copy.Exits = make(map[ExitDir]ExitDef, len(r.Exits))
 			for k, v := range r.Exits {
 				if id == 1 && k == East {
-					copy.Exits[k] = ExitDef{Room: 5, Condition: v.Condition, BlockedMessage: v.BlockedMessage, SetFlags: v.SetFlags, SetPlayerFlags: v.SetPlayerFlags, Hidden: v.Hidden, AlwaysBlocked: v.AlwaysBlocked}
+					copy.Exits[k] = ExitDef{Room: 5, Condition: v.Condition, BlockedMessage: v.BlockedMessage, SetGlobalFlags: v.SetGlobalFlags, SetPlayerFlags: v.SetPlayerFlags, Hidden: v.Hidden, AlwaysBlocked: v.AlwaysBlocked}
 					continue
 				}
 				if id == 2 && k == West {
-					copy.Exits[k] = ExitDef{Room: 5, Condition: v.Condition, BlockedMessage: v.BlockedMessage, SetFlags: v.SetFlags, SetPlayerFlags: v.SetPlayerFlags, Hidden: v.Hidden, AlwaysBlocked: v.AlwaysBlocked}
+					copy.Exits[k] = ExitDef{Room: 5, Condition: v.Condition, BlockedMessage: v.BlockedMessage, SetGlobalFlags: v.SetGlobalFlags, SetPlayerFlags: v.SetPlayerFlags, Hidden: v.Hidden, AlwaysBlocked: v.AlwaysBlocked}
 					continue
 				}
 				copy.Exits[k] = v
diff --git a/internal/world/insert_remove.go b/internal/world/insert_remove.go
index 0811587..c55427c 100644
--- a/internal/world/insert_remove.go
+++ b/internal/world/insert_remove.go
@@ -20,7 +20,7 @@ func RewirePreserving(src ExitDef, newTarget int) ExitDef {
 		Room:           newTarget,
 		Condition:      src.Condition,
 		BlockedMessage: src.BlockedMessage,
-		SetFlags:       src.SetFlags,
+		SetGlobalFlags: src.SetGlobalFlags,
 		SetPlayerFlags: src.SetPlayerFlags,
 		Hidden:         src.Hidden,
 		AlwaysBlocked:  src.AlwaysBlocked,
diff --git a/internal/world/room.go b/internal/world/room.go
index 29cce0b..2da40fb 100644
--- a/internal/world/room.go
+++ b/internal/world/room.go
@@ -78,7 +78,7 @@ type ExitDef struct {
 	Room           int                 `yaml:"room"`
 	Condition      *behavior.Condition `yaml:"condition,omitempty"`
 	BlockedMessage string              `yaml:"blocked_message,omitempty"`
-	SetFlags       map[string]any      `yaml:"set_flags,omitempty"`
+	SetGlobalFlags map[string]any      `yaml:"set_global_flags,omitempty"`
 	SetPlayerFlags map[string]any      `yaml:"set_player_flags,omitempty"`
 	Hidden         bool                `yaml:"hidden,omitempty"`
 	AlwaysBlocked  bool                `yaml:"always_blocked,omitempty"`
@@ -135,7 +135,7 @@ type EnterStep struct {
 	Message         string              `yaml:"message"`
 	Condition       *behavior.Condition `yaml:"condition"`
 	Delay           int                 `yaml:"delay"`
-	SetFlags        map[string]any      `yaml:"set_flags"`
+	SetGlobalFlags  map[string]any      `yaml:"set_global_flags"`
 	SetPlayerFlags  map[string]any      `yaml:"set_player_flags"`
 	Broadcast       string              `yaml:"broadcast"`
 	BroadcastGlobal string              `yaml:"broadcast_global"`
@@ -151,7 +151,7 @@ type EnterStep struct {
 // non-zero field means it needs per-tick scheduling rather than synchronous
 // printing).
 func (e EnterStep) IsTimed() bool {
-	return e.Delay > 0 || len(e.SetFlags) > 0 || len(e.SetPlayerFlags) > 0 ||
+	return e.Delay > 0 || len(e.SetGlobalFlags) > 0 || len(e.SetPlayerFlags) > 0 ||
 		e.Message != "" || e.Broadcast != "" || e.BroadcastGlobal != "" ||
 		e.SpawnMob != nil || e.DespawnMob != "" || e.GiveItem != "" ||
 		e.TakeItem != "" || e.Teleport != 0 || e.Heal != 0
diff --git a/internal/world/room_migrate_test.go b/internal/world/room_migrate_test.go
index b035172..5696a36 100644
--- a/internal/world/room_migrate_test.go
+++ b/internal/world/room_migrate_test.go
@@ -5,7 +5,7 @@ import "testing"
 func TestRoomRewriteRoomIDs(t *testing.T) {
 	r := &Room{
 		Exits: map[ExitDir]ExitDef{
-			North: {Room: 10, SetFlags: map[string]any{"last": 10}},
+			North: {Room: 10, SetGlobalFlags: map[string]any{"last": 10}},
 			South: {Room: 99},
 		},
 		Triggers: []TriggerDef{
@@ -43,8 +43,8 @@ func TestRoomRewriteRoomIDs(t *testing.T) {
 
 	// Author set_flags values are NOT structural room references and must not
 	// be remapped (the old swapid regex wrongly rewrote these).
-	if v := r.Exits[North].SetFlags["last"]; v != 10 {
-		t.Errorf("set_flags value remapped: got %v, want 10", v)
+	if v := r.Exits[North].SetGlobalFlags["last"]; v != 10 {
+		t.Errorf("set_global_flags value remapped: got %v, want 10", v)
 	}
 
 	if r.Triggers[0].Room != 31 {
diff --git a/internal/world/trigger.go b/internal/world/trigger.go
index 8e74ff7..e31a5f9 100644
--- a/internal/world/trigger.go
+++ b/internal/world/trigger.go
@@ -7,7 +7,7 @@ import (
 type TriggerDef struct {
 	ID           string        `yaml:"id"`
 	OnPlayerFlag string        `yaml:"on_player_flag"`
-	OnFlag       string        `yaml:"on_flag"`
+	OnGlobalFlag string        `yaml:"on_global_flag"`
 	Value        any           `yaml:"value"`
 	Room         int           `yaml:"room"`
 	Steps        []TriggerStep `yaml:"steps"`
@@ -15,14 +15,14 @@ type TriggerDef struct {
 
 func (t *TriggerDef) IsPlayerFlagTrigger() bool { return t.OnPlayerFlag != "" }
 
-func (t *TriggerDef) IsWorldFlagTrigger() bool { return t.OnFlag != "" }
+func (t *TriggerDef) IsGlobalFlagTrigger() bool { return t.OnGlobalFlag != "" }
 
 type TriggerStep struct {
 	Delay           int             `yaml:"delay"`
 	Message         string          `yaml:"message"`
 	Broadcast       string          `yaml:"broadcast"`
 	BroadcastGlobal string          `yaml:"broadcast_global"`
-	SetFlags        map[string]any  `yaml:"set_flags"`
+	SetGlobalFlags  map[string]any  `yaml:"set_global_flags"`
 	SetPlayerFlags  map[string]any  `yaml:"set_player_flags"`
 	SpawnMob        *SpawnMobConfig `yaml:"spawn_mob"`
 	GiveItem        string          `yaml:"give_item"`
@@ -54,7 +54,7 @@ func (s *SpawnMobConfig) UnmarshalYAML(value *yaml.Node) error {
 }
 
 func (t TriggerStep) IsTimed() bool {
-	return t.Delay > 0 || len(t.SetFlags) > 0 || len(t.SetPlayerFlags) > 0 ||
+	return t.Delay > 0 || len(t.SetGlobalFlags) > 0 || len(t.SetPlayerFlags) > 0 ||
 		t.Message != "" || t.Broadcast != "" || t.BroadcastGlobal != "" ||
 		t.SpawnMob != nil || t.GiveItem != "" || t.TakeItem != "" ||
 		t.Teleport != 0 || t.Heal != 0 || t.DespawnMob != ""
diff --git a/internal/world/trigger_store.go b/internal/world/trigger_store.go
index b5fac5b..e18ae80 100644
--- a/internal/world/trigger_store.go
+++ b/internal/world/trigger_store.go
@@ -14,12 +14,12 @@ type TriggerStore struct {
 	mu sync.Mutex
 
 	globalByPlayerFlag map[string][]*TriggerDef
-	globalByWorldFlag  map[string][]*TriggerDef
+	globalByGlobalFlag map[string][]*TriggerDef
 	roomByPlayerFlag   map[int]map[string][]*TriggerDef
-	roomByWorldFlag    map[int]map[string][]*TriggerDef
+	roomByGlobalFlag   map[int]map[string][]*TriggerDef
 
 	playerSeqs map[string]*PlayerTriggerSeq
-	worldSeqs  map[string]*WorldTriggerSeq
+	globalSeqs map[string]*GlobalTriggerSeq
 }
 
 type PlayerTriggerSeq struct {
@@ -32,7 +32,7 @@ type PlayerTriggerSeq struct {
 	FlagValue  any
 }
 
-type WorldTriggerSeq struct {
+type GlobalTriggerSeq struct {
 	TriggerID string
 	RoomID    int
 	Steps     []TriggerStep
@@ -43,11 +43,11 @@ type WorldTriggerSeq struct {
 func NewTriggerStore() *TriggerStore {
 	return &TriggerStore{
 		globalByPlayerFlag: make(map[string][]*TriggerDef),
-		globalByWorldFlag:  make(map[string][]*TriggerDef),
+		globalByGlobalFlag: make(map[string][]*TriggerDef),
 		roomByPlayerFlag:   make(map[int]map[string][]*TriggerDef),
-		roomByWorldFlag:    make(map[int]map[string][]*TriggerDef),
+		roomByGlobalFlag:   make(map[int]map[string][]*TriggerDef),
 		playerSeqs:         make(map[string]*PlayerTriggerSeq),
-		worldSeqs:          make(map[string]*WorldTriggerSeq),
+		globalSeqs:         make(map[string]*GlobalTriggerSeq),
 	}
 }
 
@@ -55,9 +55,9 @@ func (ts *TriggerStore) ClearTriggers() {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
 	ts.globalByPlayerFlag = make(map[string][]*TriggerDef)
-	ts.globalByWorldFlag = make(map[string][]*TriggerDef)
+	ts.globalByGlobalFlag = make(map[string][]*TriggerDef)
 	ts.roomByPlayerFlag = make(map[int]map[string][]*TriggerDef)
-	ts.roomByWorldFlag = make(map[int]map[string][]*TriggerDef)
+	ts.roomByGlobalFlag = make(map[int]map[string][]*TriggerDef)
 }
 
 func (ts *TriggerStore) LoadGlobal(dataDir string) error {
@@ -110,13 +110,13 @@ func (ts *TriggerStore) SeedRoomTriggers(roomID int, triggers []TriggerDef) {
 			ts.roomByPlayerFlag[roomID][t.OnPlayerFlag] = append(
 				ts.roomByPlayerFlag[roomID][t.OnPlayerFlag], t)
 		}
-		if t.IsWorldFlagTrigger() {
-			if ts.roomByWorldFlag[roomID] == nil {
-				ts.roomByWorldFlag[roomID] = make(map[string][]*TriggerDef)
+		if t.IsGlobalFlagTrigger() {
+			if ts.roomByGlobalFlag[roomID] == nil {
+				ts.roomByGlobalFlag[roomID] = make(map[string][]*TriggerDef)
 			}
 			t.Room = roomID
-			ts.roomByWorldFlag[roomID][t.OnFlag] = append(
-				ts.roomByWorldFlag[roomID][t.OnFlag], t)
+			ts.roomByGlobalFlag[roomID][t.OnGlobalFlag] = append(
+				ts.roomByGlobalFlag[roomID][t.OnGlobalFlag], t)
 		}
 	}
 }
@@ -128,9 +128,9 @@ func (ts *TriggerStore) addGlobal(t *TriggerDef) {
 		ts.globalByPlayerFlag[t.OnPlayerFlag] = append(
 			ts.globalByPlayerFlag[t.OnPlayerFlag], t)
 	}
-	if t.IsWorldFlagTrigger() {
-		ts.globalByWorldFlag[t.OnFlag] = append(
-			ts.globalByWorldFlag[t.OnFlag], t)
+	if t.IsGlobalFlagTrigger() {
+		ts.globalByGlobalFlag[t.OnGlobalFlag] = append(
+			ts.globalByGlobalFlag[t.OnGlobalFlag], t)
 	}
 }
 
@@ -184,23 +184,23 @@ func (ts *TriggerStore) FirePlayerInRoom(playerName string, roomID int, flagName
 	return started
 }
 
-func (ts *TriggerStore) FireWorld(flagName string, flagValue any) []*WorldTriggerSeq {
+func (ts *TriggerStore) FireGlobal(flagName string, flagValue any) []*GlobalTriggerSeq {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
 
-	var started []*WorldTriggerSeq
+	var started []*GlobalTriggerSeq
 
-	for _, t := range ts.globalByWorldFlag[flagName] {
+	for _, t := range ts.globalByGlobalFlag[flagName] {
 		if !ts.valueMatches(t.Value, flagValue) {
 			continue
 		}
-		seq := ts.startWorldSeqLocked(t, flagValue)
+		seq := ts.startGlobalSeqLocked(t, flagValue)
 		if seq != nil {
 			started = append(started, seq)
 		}
 	}
 
-	for roomID, roomFlags := range ts.roomByWorldFlag {
+	for roomID, roomFlags := range ts.roomByGlobalFlag {
 		for _, t := range roomFlags[flagName] {
 			if !ts.valueMatches(t.Value, flagValue) {
 				continue
@@ -208,7 +208,7 @@ func (ts *TriggerStore) FireWorld(flagName string, flagValue any) []*WorldTrigge
 			if t.Room == 0 {
 				t.Room = roomID
 			}
-			seq := ts.startWorldSeqLocked(t, flagValue)
+			seq := ts.startGlobalSeqLocked(t, flagValue)
 			if seq != nil {
 				started = append(started, seq)
 			}
@@ -238,12 +238,12 @@ func (ts *TriggerStore) startPlayerSeqLocked(playerName string, t *TriggerDef, r
 	return seq
 }
 
-func (ts *TriggerStore) startWorldSeqLocked(t *TriggerDef, flagValue any) *WorldTriggerSeq {
+func (ts *TriggerStore) startGlobalSeqLocked(t *TriggerDef, flagValue any) *GlobalTriggerSeq {
 	key := t.ID
-	if _, exists := ts.worldSeqs[key]; exists {
+	if _, exists := ts.globalSeqs[key]; exists {
 		return nil
 	}
-	seq := &WorldTriggerSeq{
+	seq := &GlobalTriggerSeq{
 		TriggerID: t.ID,
 		RoomID:    t.Room,
 		Steps:     make([]TriggerStep, len(t.Steps)),
@@ -253,7 +253,7 @@ func (ts *TriggerStore) startWorldSeqLocked(t *TriggerDef, flagValue any) *World
 	if len(seq.Steps) > 0 {
 		seq.Wait = seq.Steps[0].Delay
 	}
-	ts.worldSeqs[key] = seq
+	ts.globalSeqs[key] = seq
 	return seq
 }
 
@@ -274,11 +274,11 @@ func (ts *TriggerStore) SnapshotPlayerSeqs() []*PlayerTriggerSeq {
 	return out
 }
 
-func (ts *TriggerStore) SnapshotWorldSeqs() []*WorldTriggerSeq {
+func (ts *TriggerStore) SnapshotGlobalSeqs() []*GlobalTriggerSeq {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
-	out := make([]*WorldTriggerSeq, 0, len(ts.worldSeqs))
-	for _, s := range ts.worldSeqs {
+	out := make([]*GlobalTriggerSeq, 0, len(ts.globalSeqs))
+	for _, s := range ts.globalSeqs {
 		out = append(out, s)
 	}
 	return out
@@ -291,10 +291,10 @@ func (ts *TriggerStore) RemovePlayerSeq(playerName, triggerID string) {
 	delete(ts.playerSeqs, key)
 }
 
-func (ts *TriggerStore) RemoveWorldSeq(triggerID string) {
+func (ts *TriggerStore) RemoveGlobalSeq(triggerID string) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
-	delete(ts.worldSeqs, triggerID)
+	delete(ts.globalSeqs, triggerID)
 }
 
 func (ts *TriggerStore) AllGlobalTriggers() []*TriggerDef {
@@ -304,7 +304,7 @@ func (ts *TriggerStore) AllGlobalTriggers() []*TriggerDef {
 	for _, triggers := range ts.globalByPlayerFlag {
 		out = append(out, triggers...)
 	}
-	for _, triggers := range ts.globalByWorldFlag {
+	for _, triggers := range ts.globalByGlobalFlag {
 		out = append(out, triggers...)
 	}
 	return out
@@ -340,7 +340,7 @@ func (ts *TriggerStore) AllRoomTriggers() map[int][]*TriggerDef {
 			out[roomID] = append(out[roomID], triggers...)
 		}
 	}
-	for roomID, byFlag := range ts.roomByWorldFlag {
+	for roomID, byFlag := range ts.roomByGlobalFlag {
 		for _, triggers := range byFlag {
 			out[roomID] = append(out[roomID], triggers...)
 		}