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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
package world
import (
"fmt"
"os"
"path/filepath"
"sync"
"gopkg.in/yaml.v3"
)
type LootEntry struct {
ItemID string `yaml:"item_id"`
Weight int `yaml:"weight"`
Quantity int `yaml:"quantity"`
}
type DropTable struct {
Remains string `yaml:"remains"`
Loot []LootEntry `yaml:"loot"`
}
type MobDef struct {
ID string `yaml:"id"`
Name string `yaml:"name"`
Attack int `yaml:"attack"`
Strength int `yaml:"strength"`
Defense int `yaml:"defense"`
HP int `yaml:"hp"`
Speed int `yaml:"speed"`
Aggressive bool `yaml:"aggressive"`
RespawnTicks int `yaml:"respawn_ticks"`
Drops DropTable `yaml:"drops"`
}
type MobInstance struct {
InstanceID string
DefID string
Name string
HP int
MaxHP int
Attack int
Strength int
Defense int
Speed int
Aggressive bool
RespawnTicks int
RoomID int
Drops DropTable
}
type MobStore struct {
dataDir string
mu sync.Mutex
defs map[string]*MobDef
instances map[string]*MobInstance
}
func NewMobStore(dataDir string) *MobStore {
return &MobStore{
dataDir: dataDir,
defs: make(map[string]*MobDef),
instances: make(map[string]*MobInstance),
}
}
func (s *MobStore) LoadDef(id string) (*MobDef, error) {
s.mu.Lock()
if def, ok := s.defs[id]; ok {
s.mu.Unlock()
return def, nil
}
s.mu.Unlock()
path := filepath.Join(s.dataDir, "mobs", id+".yaml")
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("read mob %s: %w", id, err)
}
var def MobDef
if err := yaml.Unmarshal(data, &def); err != nil {
return nil, fmt.Errorf("parse mob %s: %w", id, err)
}
s.mu.Lock()
s.defs[id] = &def
s.mu.Unlock()
return &def, nil
}
func (s *MobStore) SpawnMob(defID string, roomID int, instanceID string) (*MobInstance, error) {
def, err := s.LoadDef(defID)
if err != nil {
return nil, err
}
s.mu.Lock()
defer s.mu.Unlock()
inst := &MobInstance{
InstanceID: instanceID,
DefID: defID,
Name: def.Name,
HP: def.HP,
MaxHP: def.HP,
Attack: def.Attack,
Strength: def.Strength,
Defense: def.Defense,
Speed: def.Speed,
Aggressive: def.Aggressive,
RespawnTicks: def.RespawnTicks,
RoomID: roomID,
Drops: def.Drops,
}
s.instances[instanceID] = inst
return inst, nil
}
func (s *MobStore) GetInstance(id string) *MobInstance {
s.mu.Lock()
defer s.mu.Unlock()
return s.instances[id]
}
func (s *MobStore) RemoveInstance(id string) {
s.mu.Lock()
defer s.mu.Unlock()
delete(s.instances, id)
}
func (s *MobStore) MobsInRoom(roomID int) []*MobInstance {
s.mu.Lock()
defer s.mu.Unlock()
var out []*MobInstance
for _, inst := range s.instances {
if inst.RoomID == roomID && inst.HP > 0 {
out = append(out, inst)
}
}
return out
}
func (s *MobStore) SeedMobs(roomID int, mobIDs []string) {
type defWrapper struct {
def *MobDef
err error
}
defs := make([]defWrapper, len(mobIDs))
for i, defID := range mobIDs {
d, err := s.LoadDef(defID)
defs[i] = defWrapper{d, err}
}
s.mu.Lock()
defer s.mu.Unlock()
for i, dw := range defs {
if dw.err != nil {
continue
}
defID := mobIDs[i]
instID := fmt.Sprintf("%s_%d_%d", defID, roomID, i)
if inst, exists := s.instances[instID]; exists {
// Already exists — skip (respawn is handled by timers)
_ = inst
continue
}
s.instances[instID] = &MobInstance{
InstanceID: instID,
DefID: defID,
Name: dw.def.Name,
HP: dw.def.HP,
MaxHP: dw.def.HP,
Attack: dw.def.Attack,
Strength: dw.def.Strength,
Defense: dw.def.Defense,
Speed: dw.def.Speed,
Aggressive: dw.def.Aggressive,
RespawnTicks: dw.def.RespawnTicks,
RoomID: roomID,
Drops: dw.def.Drops,
}
}
}
|
