1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
// Package validate runs startup integrity checks across all data files:
// duplicate IDs, referential integrity (rooms, mobs, objects, items, drops,
// courses, techs), and world wiring (orphan rooms). It depends only on the
// data packages (world, object, item, behavior), never on the game
// orchestrator, so it can be reused and tested in isolation.
package validate
import (
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"thehouseoficarus/internal/behavior"
"thehouseoficarus/internal/item"
"thehouseoficarus/internal/object"
"thehouseoficarus/internal/world"
)
// Issue is a single validation finding.
type Issue struct {
Level string // "ERROR" or "WARN"
Type string // "duplicate", "reference", "integrity"
Message string
}
// CourseView is the subset of a course definition needed for validation.
type CourseView struct {
ID string
StartRoom int
ObstacleRooms []int
}
// TechView is the subset of a tech definition needed for validation.
type TechView struct {
ID string
Name string
DrainRate float64
}
// Source bundles everything the validator reads. The game package builds this
// from its stores and passes it to Run.
type Source struct {
DataDir string
Items *item.ItemStore
Objects *object.ObjectStore
Mobs *world.MobStore
World *world.World
Courses []CourseView
Techs []TechView
TechIDs map[string]bool
RootRooms []int
IgnoreUnreachable []int
}
// Run executes all checks and returns the collected issues.
func Run(s Source) []Issue {
var issues []Issue
for _, dir := range []struct{ sub, label string }{
{"items", "item"}, {"rooms", "room"}, {"mobs", "mob"},
{"objects", "object"}, {"drops", "drop table"}, {"courses", "course"},
{"modules", "module"}, {"techs", "tech"}, {"help", "help topic"},
{"triggers", "trigger"},
} {
issues = append(issues, validateIDs(s.DataDir, dir.sub, dir.label)...)
}
issues = append(issues, validateRooms(s)...)
issues = append(issues, validateMobs(s)...)
issues = append(issues, validateHazards(s)...)
issues = append(issues, validateObjects(s)...)
issues = append(issues, validateItems(s)...)
issues = append(issues, validateCraftBlocks(s)...)
issues = append(issues, validateDropTables(s)...)
issues = append(issues, validateCourses(s)...)
issues = append(issues, validateRoomTriggers(s)...)
issues = append(issues, validateTechs(s)...)
issues = append(issues, validateRoomWiring(s)...)
issues = append(issues, validateRoomGrid(s)...)
issues = append(issues, validateExitReciprocity(s)...)
return issues
}
func validateIDs(dataDir, subDir, label string) []Issue {
dir := filepath.Join(dataDir, subDir)
dups := behavior.CheckDuplicateIDs(dir)
var issues []Issue
for _, d := range dups {
short := make([]string, len(d.Paths))
for i, p := range d.Paths {
short[i] = strings.TrimPrefix(p, dir+"/")
}
issues = append(issues, Issue{
Level: "ERROR",
Type: "duplicate",
Message: fmt.Sprintf("Duplicate %s ID %q found in: %s",
label, d.ID, strings.Join(short, ", ")),
})
}
return issues
}
func dropTableIDSet(dataDir string) map[string]bool {
dir := filepath.Join(dataDir, "drops")
ids := make(map[string]bool)
behavior.WalkYAMLDir(dir, func(path, id string, data []byte) error {
ids[id] = true
return nil
})
return ids
}
// LogIssues prints validation results to stderr, sorted with errors first.
func LogIssues(issues []Issue) {
if len(issues) == 0 {
fmt.Fprintf(os.Stderr, "Startup validation: OK\n")
return
}
errors := 0
warns := 0
for _, issue := range issues {
if issue.Level == "ERROR" {
errors++
} else {
warns++
}
}
fmt.Fprintf(os.Stderr, "\n=== Startup Validation: %d error(s), %d warning(s) ===\n\n", errors, warns)
sort.Slice(issues, func(i, j int) bool {
if issues[i].Level != issues[j].Level {
return issues[i].Level == "ERROR"
}
return issues[i].Message < issues[j].Message
})
for _, issue := range issues {
tag := fmt.Sprintf("[%s]", issue.Level)
fmt.Fprintf(os.Stderr, " %-7s %s\n", tag, issue.Message)
}
fmt.Fprintln(os.Stderr)
if errors > 0 {
fmt.Fprintf(os.Stderr, "*** %d startup errors detected. The server may behave unexpectedly. ***\n", errors)
}
}
// reservedTechIDs are tech IDs whose semantics are coupled to code logic and
// must exist in YAML (damage protection mapping + death retribution).
var reservedTechIDs = map[string]bool{
"protect_melee": true,
"protect_ranged": true,
"protect_science": true,
"retribution": true,
}
|
