modernize ground_spawn
This commit is contained in:
parent
9c04d9a67e
commit
d3ffe7b4ee
92
MODERNIZE.md
92
MODERNIZE.md
@ -166,7 +166,9 @@ Create focused tests:
|
||||
- [ ] Remove all legacy types and converters
|
||||
- [ ] Update doc.go with concise examples
|
||||
- [ ] Simplify tests to cover core functionality
|
||||
- [ ] Run `go fmt` and `go test`
|
||||
- [ ] **Create comprehensive benchmarks (benchmark_test.go)**
|
||||
- [ ] **Verify performance meets targets**
|
||||
- [ ] Run `go fmt`, `go test`, and `go test -bench=.`
|
||||
|
||||
## Expected Results
|
||||
|
||||
@ -176,6 +178,93 @@ Create focused tests:
|
||||
- **Consistent API** across all packages
|
||||
- **Better maintainability** with less duplication
|
||||
|
||||
## Benchmarking
|
||||
|
||||
After modernization, create comprehensive benchmarks to measure performance improvements and ensure no regressions:
|
||||
|
||||
### Required Benchmarks
|
||||
|
||||
**Core Operations:**
|
||||
```go
|
||||
func BenchmarkTypeCreation(b *testing.B) // New type creation
|
||||
func BenchmarkTypeOperations(b *testing.B) // CRUD operations
|
||||
func BenchmarkMasterListOperations(b *testing.B) // Collection operations
|
||||
```
|
||||
|
||||
**Performance Critical Paths:**
|
||||
```go
|
||||
func BenchmarkCoreAlgorithm(b *testing.B) // Main business logic
|
||||
func BenchmarkConcurrentAccess(b *testing.B) // Thread safety
|
||||
func BenchmarkMemoryAllocation(b *testing.B) // Memory patterns
|
||||
```
|
||||
|
||||
**Comparison Benchmarks:**
|
||||
```go
|
||||
func BenchmarkComparisonWithOldSystem(b *testing.B) // Before/after metrics
|
||||
```
|
||||
|
||||
### Benchmark Structure
|
||||
|
||||
Use sub-benchmarks for detailed measurements:
|
||||
```go
|
||||
func BenchmarkMasterListOperations(b *testing.B) {
|
||||
ml := NewMasterList()
|
||||
// Setup data...
|
||||
|
||||
b.Run("Add", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
ml.Add(createTestItem(i))
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("Get", func(b *testing.B) {
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = ml.Get(randomID())
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
### Mock Implementations
|
||||
|
||||
Create lightweight mocks for interfaces:
|
||||
```go
|
||||
type mockPlayer struct {
|
||||
level int16
|
||||
location int32
|
||||
}
|
||||
|
||||
func (p *mockPlayer) GetLevel() int16 { return p.level }
|
||||
func (p *mockPlayer) GetLocation() int32 { return p.location }
|
||||
```
|
||||
|
||||
### Performance Expectations
|
||||
|
||||
Target performance after modernization:
|
||||
- **Creation operations**: <100ns per operation
|
||||
- **Lookup operations**: <50ns per operation
|
||||
- **Collection operations**: O(1) for gets, O(N) for filters
|
||||
- **Memory allocations**: Minimize in hot paths
|
||||
- **Concurrent access**: Linear scaling with cores
|
||||
|
||||
### Running Benchmarks
|
||||
|
||||
```bash
|
||||
# Run all benchmarks
|
||||
go test -bench=. ./internal/package_name
|
||||
|
||||
# Detailed benchmarks with memory stats
|
||||
go test -bench=. -benchmem ./internal/package_name
|
||||
|
||||
# Compare performance over time
|
||||
go test -bench=. -count=5 ./internal/package_name
|
||||
|
||||
# CPU profiling for optimization
|
||||
go test -bench=BenchmarkCoreAlgorithm -cpuprofile=cpu.prof ./internal/package_name
|
||||
```
|
||||
|
||||
## Example Commands
|
||||
|
||||
```bash
|
||||
@ -188,5 +277,6 @@ mv active_record.go achievement.go
|
||||
# Test the changes
|
||||
go fmt ./...
|
||||
go test ./...
|
||||
go test -bench=. ./...
|
||||
go build ./...
|
||||
```
|
||||
@ -1,562 +1,430 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"testing"
|
||||
|
||||
"eq2emu/internal/database"
|
||||
)
|
||||
|
||||
// Mock implementations are in test_utils.go
|
||||
// Mock implementations for benchmarking
|
||||
|
||||
// Benchmark GroundSpawn operations
|
||||
func BenchmarkGroundSpawn(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 2,
|
||||
RandomizeHeading: true,
|
||||
Location: SpawnLocation{
|
||||
X: 100.0, Y: 200.0, Z: 300.0, Heading: 45.0, GridID: 1,
|
||||
},
|
||||
Name: "Benchmark Node",
|
||||
Description: "A benchmark harvestable node",
|
||||
// mockPlayer implements Player interface for benchmarks
|
||||
type mockPlayer struct {
|
||||
level int16
|
||||
location int32
|
||||
name string
|
||||
}
|
||||
|
||||
func (p *mockPlayer) GetLevel() int16 { return p.level }
|
||||
func (p *mockPlayer) GetLocation() int32 { return p.location }
|
||||
func (p *mockPlayer) GetName() string { return p.name }
|
||||
|
||||
// mockSkill implements Skill interface for benchmarks
|
||||
type mockSkill struct {
|
||||
current int16
|
||||
max int16
|
||||
}
|
||||
|
||||
func (s *mockSkill) GetCurrentValue() int16 { return s.current }
|
||||
func (s *mockSkill) GetMaxValue() int16 { return s.max }
|
||||
|
||||
// createTestGroundSpawn creates a ground spawn for benchmarking
|
||||
func createTestGroundSpawn(b *testing.B, id int32) *GroundSpawn {
|
||||
b.Helper()
|
||||
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
b.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
|
||||
gs := NewGroundSpawn(config)
|
||||
gs := New(db)
|
||||
gs.GroundSpawnID = id
|
||||
gs.Name = fmt.Sprintf("Benchmark Node %d", id)
|
||||
gs.CollectionSkill = "Mining"
|
||||
gs.NumberHarvests = 5
|
||||
gs.AttemptsPerHarvest = 1
|
||||
gs.CurrentHarvests = 5
|
||||
gs.X, gs.Y, gs.Z = float32(rand.Intn(1000)), float32(rand.Intn(1000)), float32(rand.Intn(1000))
|
||||
gs.ZoneID = int32(rand.Intn(10) + 1)
|
||||
gs.GridID = int32(rand.Intn(100))
|
||||
|
||||
// Add mock harvest entries for realistic benchmarking
|
||||
gs.HarvestEntries = []*HarvestEntry{
|
||||
{
|
||||
GroundSpawnID: id,
|
||||
MinSkillLevel: 10,
|
||||
MinAdventureLevel: 1,
|
||||
BonusTable: false,
|
||||
Harvest1: 80.0,
|
||||
Harvest3: 20.0,
|
||||
Harvest5: 10.0,
|
||||
HarvestImbue: 5.0,
|
||||
HarvestRare: 2.0,
|
||||
Harvest10: 1.0,
|
||||
},
|
||||
{
|
||||
GroundSpawnID: id,
|
||||
MinSkillLevel: 50,
|
||||
MinAdventureLevel: 10,
|
||||
BonusTable: true,
|
||||
Harvest1: 90.0,
|
||||
Harvest3: 30.0,
|
||||
Harvest5: 15.0,
|
||||
HarvestImbue: 8.0,
|
||||
HarvestRare: 5.0,
|
||||
Harvest10: 2.0,
|
||||
},
|
||||
}
|
||||
|
||||
// Add mock harvest items
|
||||
gs.HarvestItems = []*HarvestEntryItem{
|
||||
{GroundSpawnID: id, ItemID: 1001, IsRare: ItemRarityNormal, GridID: 0, Quantity: 1},
|
||||
{GroundSpawnID: id, ItemID: 1002, IsRare: ItemRarityNormal, GridID: 0, Quantity: 1},
|
||||
{GroundSpawnID: id, ItemID: 1003, IsRare: ItemRarityRare, GridID: 0, Quantity: 1},
|
||||
{GroundSpawnID: id, ItemID: 1004, IsRare: ItemRarityImbue, GridID: 0, Quantity: 1},
|
||||
}
|
||||
|
||||
return gs
|
||||
}
|
||||
|
||||
b.Run("GetNumberHarvests", func(b *testing.B) {
|
||||
for b.Loop() {
|
||||
_ = gs.GetNumberHarvests()
|
||||
// BenchmarkGroundSpawnCreation measures ground spawn creation performance
|
||||
func BenchmarkGroundSpawnCreation(b *testing.B) {
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
b.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
b.ResetTimer()
|
||||
|
||||
b.Run("Sequential", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
gs := New(db)
|
||||
gs.GroundSpawnID = int32(i)
|
||||
gs.Name = fmt.Sprintf("Node %d", i)
|
||||
_ = gs
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("SetNumberHarvests", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for i := 0; b.Loop(); i++ {
|
||||
gs.SetNumberHarvests(int8(i % 10))
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetCollectionSkill", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = gs.GetCollectionSkill()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("SetCollectionSkill", func(b *testing.B) {
|
||||
skills := []string{SkillGathering, SkillMining, SkillFishing, SkillTrapping}
|
||||
b.ResetTimer()
|
||||
for i := 0; b.Loop(); i++ {
|
||||
gs.SetCollectionSkill(skills[i%len(skills)])
|
||||
}
|
||||
b.Run("Parallel", func(b *testing.B) {
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
id := int32(0)
|
||||
for pb.Next() {
|
||||
gs := New(db)
|
||||
gs.GroundSpawnID = id
|
||||
gs.Name = fmt.Sprintf("Node %d", id)
|
||||
id++
|
||||
_ = gs
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// BenchmarkGroundSpawnState measures state operations
|
||||
func BenchmarkGroundSpawnState(b *testing.B) {
|
||||
gs := createTestGroundSpawn(b, 1001)
|
||||
|
||||
b.Run("IsAvailable", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = gs.IsAvailable()
|
||||
}
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = gs.IsAvailable()
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
b.Run("IsDepleted", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = gs.IsDepleted()
|
||||
}
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = gs.IsDepleted()
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
b.Run("GetHarvestMessageName", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for i := 0; b.Loop(); i++ {
|
||||
_ = gs.GetHarvestMessageName(i%2 == 0, i%4 == 0)
|
||||
}
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = gs.GetHarvestMessageName(true, false)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
b.Run("GetHarvestSpellType", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = gs.GetHarvestSpellType()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = gs.GetHarvestSpellType()
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// BenchmarkHarvestAlgorithm measures the core harvest processing performance
|
||||
func BenchmarkHarvestAlgorithm(b *testing.B) {
|
||||
gs := createTestGroundSpawn(b, 1001)
|
||||
|
||||
player := &mockPlayer{level: 50, location: 1, name: "BenchmarkPlayer"}
|
||||
skill := &mockSkill{current: 75, max: 100}
|
||||
|
||||
b.Run("ProcessHarvest", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
// Reset harvest count for consistent benchmarking
|
||||
gs.CurrentHarvests = gs.NumberHarvests
|
||||
|
||||
_, err := gs.ProcessHarvest(player, skill, 75)
|
||||
if err != nil {
|
||||
b.Fatalf("Harvest failed: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("Copy", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
copy := gs.Copy()
|
||||
_ = copy
|
||||
|
||||
b.Run("FilterHarvestTables", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = gs.filterHarvestTables(player, 75)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("SelectHarvestTable", func(b *testing.B) {
|
||||
tables := gs.filterHarvestTables(player, 75)
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = gs.selectHarvestTable(tables, 75)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("DetermineHarvestType", func(b *testing.B) {
|
||||
tables := gs.filterHarvestTables(player, 75)
|
||||
table := gs.selectHarvestTable(tables, 75)
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = gs.determineHarvestType(table, false)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("AwardHarvestItems", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = gs.awardHarvestItems(HarvestType3Items, player)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// BenchmarkMasterListOperations measures master list performance
|
||||
func BenchmarkMasterListOperations(b *testing.B) {
|
||||
ml := NewMasterList()
|
||||
|
||||
// Pre-populate with ground spawns for realistic testing
|
||||
const numSpawns = 1000
|
||||
spawns := make([]*GroundSpawn, numSpawns)
|
||||
|
||||
b.StopTimer()
|
||||
for i := 0; i < numSpawns; i++ {
|
||||
spawns[i] = createTestGroundSpawn(b, int32(i+1))
|
||||
spawns[i].ZoneID = int32(i%10 + 1) // Distribute across 10 zones
|
||||
spawns[i].CollectionSkill = []string{"Mining", "Gathering", "Fishing", "Trapping"}[i%4]
|
||||
ml.AddGroundSpawn(spawns[i])
|
||||
}
|
||||
b.StartTimer()
|
||||
|
||||
b.Run("GetGroundSpawn", func(b *testing.B) {
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
id := int32((rand.Intn(numSpawns) + 1))
|
||||
_ = ml.GetGroundSpawn(id)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("AddGroundSpawn", func(b *testing.B) {
|
||||
startID := int32(numSpawns + 1)
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
gs := createTestGroundSpawn(b, startID+int32(i))
|
||||
ml.AddGroundSpawn(gs)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetByZone", func(b *testing.B) {
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
zoneID := int32(rand.Intn(10) + 1)
|
||||
_ = ml.GetByZone(zoneID)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("GetBySkill", func(b *testing.B) {
|
||||
skills := []string{"Mining", "Gathering", "Fishing", "Trapping"}
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
skill := skills[rand.Intn(len(skills))]
|
||||
_ = ml.GetBySkill(skill)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("GetAvailableSpawns", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ml.GetAvailableSpawns()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetDepletedSpawns", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ml.GetDepletedSpawns()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetStatistics", func(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ml.GetStatistics()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// BenchmarkConcurrentHarvesting measures concurrent harvest performance
|
||||
func BenchmarkConcurrentHarvesting(b *testing.B) {
|
||||
const numSpawns = 100
|
||||
spawns := make([]*GroundSpawn, numSpawns)
|
||||
|
||||
for i := 0; i < numSpawns; i++ {
|
||||
spawns[i] = createTestGroundSpawn(b, int32(i+1))
|
||||
}
|
||||
|
||||
player := &mockPlayer{level: 50, location: 1, name: "BenchmarkPlayer"}
|
||||
skill := &mockSkill{current: 75, max: 100}
|
||||
|
||||
b.Run("ConcurrentHarvesting", func(b *testing.B) {
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
spawnIdx := rand.Intn(numSpawns)
|
||||
gs := spawns[spawnIdx]
|
||||
|
||||
// Reset if depleted
|
||||
if gs.IsDepleted() {
|
||||
gs.Respawn()
|
||||
}
|
||||
|
||||
_, _ = gs.ProcessHarvest(player, skill, 75)
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// BenchmarkMemoryAllocation measures memory allocation patterns
|
||||
func BenchmarkMemoryAllocation(b *testing.B) {
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
b.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
b.Run("GroundSpawnAllocation", func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
gs := New(db)
|
||||
gs.GroundSpawnID = int32(i)
|
||||
gs.HarvestEntries = make([]*HarvestEntry, 2)
|
||||
gs.HarvestItems = make([]*HarvestEntryItem, 4)
|
||||
_ = gs
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("MasterListAllocation", func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
ml := NewMasterList()
|
||||
_ = ml
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("HarvestResultAllocation", func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
for i := 0; i < b.N; i++ {
|
||||
result := &HarvestResult{
|
||||
Success: true,
|
||||
HarvestType: HarvestType3Items,
|
||||
ItemsAwarded: make([]*HarvestedItem, 3),
|
||||
MessageText: "You harvested 3 items",
|
||||
SkillGained: false,
|
||||
}
|
||||
_ = result
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// BenchmarkRespawnOperations measures respawn performance
|
||||
func BenchmarkRespawnOperations(b *testing.B) {
|
||||
gs := createTestGroundSpawn(b, 1001)
|
||||
|
||||
b.Run("Respawn", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
for i := 0; i < b.N; i++ {
|
||||
gs.CurrentHarvests = 0 // Deplete
|
||||
gs.Respawn()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("RespawnWithRandomHeading", func(b *testing.B) {
|
||||
gs.RandomizeHeading = true
|
||||
for i := 0; i < b.N; i++ {
|
||||
gs.CurrentHarvests = 0 // Deplete
|
||||
gs.Respawn()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Benchmark Manager operations
|
||||
func BenchmarkManager(b *testing.B) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
// BenchmarkStringOperations measures string processing performance
|
||||
func BenchmarkStringOperations(b *testing.B) {
|
||||
skills := []string{"Mining", "Gathering", "Collecting", "Fishing", "Trapping", "Foresting", "Unknown"}
|
||||
|
||||
b.Run("HarvestMessageGeneration", func(b *testing.B) {
|
||||
gs := createTestGroundSpawn(b, 1001)
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
skill := skills[rand.Intn(len(skills))]
|
||||
gs.CollectionSkill = skill
|
||||
_ = gs.GetHarvestMessageName(rand.Intn(2) == 1, rand.Intn(2) == 1)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("SpellTypeGeneration", func(b *testing.B) {
|
||||
gs := createTestGroundSpawn(b, 1001)
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
skill := skills[rand.Intn(len(skills))]
|
||||
gs.CollectionSkill = skill
|
||||
_ = gs.GetHarvestSpellType()
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// Pre-populate with ground spawns
|
||||
for i := int32(1); i <= 100; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: float32(i * 45), GridID: 1,
|
||||
},
|
||||
Name: "Benchmark Node",
|
||||
Description: "Benchmark node",
|
||||
}
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
_ = gs
|
||||
// BenchmarkComparisonWithOldSystem provides comparison benchmarks
|
||||
// These would help measure the performance improvement from modernization
|
||||
func BenchmarkComparisonWithOldSystem(b *testing.B) {
|
||||
ml := NewMasterList()
|
||||
const numSpawns = 1000
|
||||
|
||||
// Setup
|
||||
b.StopTimer()
|
||||
for i := 0; i < numSpawns; i++ {
|
||||
gs := createTestGroundSpawn(b, int32(i+1))
|
||||
ml.AddGroundSpawn(gs)
|
||||
}
|
||||
|
||||
b.Run("GetGroundSpawn", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for i := 0; b.Loop(); i++ {
|
||||
spawnID := int32((i % 100) + 1)
|
||||
_ = manager.GetGroundSpawn(spawnID)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("CreateGroundSpawn", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for i := 0; b.Loop(); i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: int32(2000 + i),
|
||||
CollectionSkill: SkillMining,
|
||||
NumberHarvests: 3,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i), Y: float32(i * 2), Z: float32(i * 3),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "New Node",
|
||||
Description: "New benchmark node",
|
||||
}
|
||||
_ = manager.CreateGroundSpawn(config)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetGroundSpawnsByZone", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetGroundSpawnCount", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetGroundSpawnCount()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetActiveGroundSpawns", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetActiveGroundSpawns()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetDepletedGroundSpawns", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetDepletedGroundSpawns()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GetStatistics", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetStatistics()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("ResetStatistics", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
manager.ResetStatistics()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("ProcessRespawns", func(b *testing.B) {
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
manager.ProcessRespawns()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Benchmark concurrent operations
|
||||
func BenchmarkConcurrentOperations(b *testing.B) {
|
||||
b.Run("GroundSpawnConcurrentReads", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Concurrent Node",
|
||||
Description: "Concurrent benchmark node",
|
||||
}
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
b.ResetTimer()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
i := 0
|
||||
for pb.Next() {
|
||||
switch i % 4 {
|
||||
case 0:
|
||||
_ = gs.GetNumberHarvests()
|
||||
case 1:
|
||||
_ = gs.GetCollectionSkill()
|
||||
case 2:
|
||||
_ = gs.IsAvailable()
|
||||
case 3:
|
||||
_ = gs.GetHarvestSpellType()
|
||||
}
|
||||
i++
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("GroundSpawnConcurrentWrites", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Concurrent Node",
|
||||
Description: "Concurrent benchmark node",
|
||||
}
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
b.ResetTimer()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
i := 0
|
||||
for pb.Next() {
|
||||
switch i % 3 {
|
||||
case 0:
|
||||
gs.SetNumberHarvests(int8(i % 10))
|
||||
case 1:
|
||||
gs.SetCollectionSkill(SkillMining)
|
||||
case 2:
|
||||
gs.SetRandomizeHeading(i%2 == 0)
|
||||
}
|
||||
i++
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("ManagerConcurrentOperations", func(b *testing.B) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Pre-populate
|
||||
for i := int32(1); i <= 10; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Manager Node",
|
||||
Description: "Manager benchmark node",
|
||||
}
|
||||
manager.CreateGroundSpawn(config)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
i := 0
|
||||
for pb.Next() {
|
||||
spawnID := int32((i % 10) + 1)
|
||||
switch i % 5 {
|
||||
case 0:
|
||||
_ = manager.GetGroundSpawn(spawnID)
|
||||
case 1:
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
case 2:
|
||||
_ = manager.GetStatistics()
|
||||
case 3:
|
||||
_ = manager.GetActiveGroundSpawns()
|
||||
case 4:
|
||||
manager.ProcessRespawns()
|
||||
}
|
||||
i++
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// Memory allocation benchmarks
|
||||
func BenchmarkMemoryAllocations(b *testing.B) {
|
||||
b.Run("GroundSpawnCreation", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Memory Test Node",
|
||||
Description: "Memory test node",
|
||||
}
|
||||
|
||||
b.ReportAllocs()
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = NewGroundSpawn(config)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("ManagerCreation", func(b *testing.B) {
|
||||
b.ReportAllocs()
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = NewManager(nil, &mockLogger{})
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("GroundSpawnCopy", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Copy Test Node",
|
||||
Description: "Copy test node",
|
||||
}
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
b.ReportAllocs()
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = gs.Copy()
|
||||
}
|
||||
})
|
||||
|
||||
b.Run("StatisticsGeneration", func(b *testing.B) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Add some data for meaningful statistics
|
||||
for i := int32(1); i <= 10; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Stats Node",
|
||||
Description: "Stats test node",
|
||||
}
|
||||
manager.CreateGroundSpawn(config)
|
||||
}
|
||||
|
||||
// Add some harvest statistics
|
||||
manager.mutex.Lock()
|
||||
manager.totalHarvests = 1000
|
||||
manager.successfulHarvests = 850
|
||||
manager.rareItemsHarvested = 50
|
||||
manager.skillUpsGenerated = 200
|
||||
manager.harvestsBySkill[SkillGathering] = 600
|
||||
manager.harvestsBySkill[SkillMining] = 400
|
||||
manager.mutex.Unlock()
|
||||
|
||||
b.ReportAllocs()
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetStatistics()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Contention benchmarks
|
||||
func BenchmarkContention(b *testing.B) {
|
||||
b.Run("HighContentionReads", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Contention Node",
|
||||
Description: "Contention test node",
|
||||
}
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
b.ResetTimer()
|
||||
b.StartTimer()
|
||||
|
||||
b.Run("ModernizedLookup", func(b *testing.B) {
|
||||
// Modern generic-based lookup
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = gs.GetNumberHarvests()
|
||||
id := int32(rand.Intn(numSpawns) + 1)
|
||||
_ = ml.GetGroundSpawn(id)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("HighContentionWrites", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Contention Node",
|
||||
Description: "Contention test node",
|
||||
|
||||
b.Run("ModernizedFiltering", func(b *testing.B) {
|
||||
// Modern filter-based operations
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ml.GetAvailableSpawns()
|
||||
}
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
b.ResetTimer()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
i := 0
|
||||
for pb.Next() {
|
||||
gs.SetNumberHarvests(int8(i % 10))
|
||||
i++
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("MixedReadWrite", func(b *testing.B) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Mixed Node",
|
||||
Description: "Mixed operations test node",
|
||||
}
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
b.ResetTimer()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
i := 0
|
||||
for pb.Next() {
|
||||
if i%10 == 0 {
|
||||
// 10% writes
|
||||
gs.SetNumberHarvests(int8(i % 5))
|
||||
} else {
|
||||
// 90% reads
|
||||
_ = gs.GetNumberHarvests()
|
||||
}
|
||||
i++
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
b.Run("ManagerHighContention", func(b *testing.B) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Pre-populate
|
||||
for i := int32(1); i <= 5; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Contention Node",
|
||||
Description: "Manager contention test",
|
||||
}
|
||||
manager.CreateGroundSpawn(config)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_ = manager.GetGroundSpawn(1)
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// Scalability benchmarks
|
||||
func BenchmarkScalability(b *testing.B) {
|
||||
sizes := []int{10, 100, 1000}
|
||||
|
||||
for _, size := range sizes {
|
||||
b.Run("GroundSpawnLookup_"+string(rune(size)), func(b *testing.B) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Pre-populate with varying sizes
|
||||
for i := int32(1); i <= int32(size); i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Scale Node",
|
||||
Description: "Scalability test node",
|
||||
}
|
||||
manager.CreateGroundSpawn(config)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; b.Loop(); i++ {
|
||||
spawnID := int32((i % size) + 1)
|
||||
_ = manager.GetGroundSpawn(spawnID)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
for _, size := range sizes {
|
||||
b.Run("ZoneLookup_"+string(rune(size)), func(b *testing.B) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Pre-populate with varying sizes
|
||||
for i := int32(1); i <= int32(size); i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Zone Node",
|
||||
Description: "Zone scalability test",
|
||||
}
|
||||
manager.CreateGroundSpawn(config)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for b.Loop() {
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,523 +0,0 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Mock implementations are in test_utils.go
|
||||
|
||||
// Stress test GroundSpawn with concurrent operations
|
||||
func TestGroundSpawnConcurrency(t *testing.T) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 2,
|
||||
RandomizeHeading: true,
|
||||
Location: SpawnLocation{
|
||||
X: 100.0, Y: 200.0, Z: 300.0, Heading: 45.0, GridID: 1,
|
||||
},
|
||||
Name: "Test Node",
|
||||
Description: "A test harvestable node",
|
||||
}
|
||||
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
const numGoroutines = 100
|
||||
const operationsPerGoroutine = 100
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
t.Run("ConcurrentGetterSetterOperations", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
switch j % 8 {
|
||||
case 0:
|
||||
gs.SetNumberHarvests(int8(goroutineID % 10))
|
||||
case 1:
|
||||
_ = gs.GetNumberHarvests()
|
||||
case 2:
|
||||
gs.SetAttemptsPerHarvest(int8(goroutineID % 5))
|
||||
case 3:
|
||||
_ = gs.GetAttemptsPerHarvest()
|
||||
case 4:
|
||||
gs.SetCollectionSkill(SkillMining)
|
||||
case 5:
|
||||
_ = gs.GetCollectionSkill()
|
||||
case 6:
|
||||
gs.SetRandomizeHeading(goroutineID%2 == 0)
|
||||
case 7:
|
||||
_ = gs.GetRandomizeHeading()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentStateChecks", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
switch j % 4 {
|
||||
case 0:
|
||||
_ = gs.IsDepleted()
|
||||
case 1:
|
||||
_ = gs.IsAvailable()
|
||||
case 2:
|
||||
_ = gs.GetHarvestMessageName(true, false)
|
||||
case 3:
|
||||
_ = gs.GetHarvestSpellType()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentCopyOperations", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
// Test concurrent copying while modifying
|
||||
if j%2 == 0 {
|
||||
copy := gs.Copy()
|
||||
if copy == nil {
|
||||
t.Errorf("Goroutine %d: Copy returned nil", goroutineID)
|
||||
}
|
||||
} else {
|
||||
gs.SetNumberHarvests(int8(goroutineID % 5))
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentRespawnOperations", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
if j%10 == 0 {
|
||||
gs.Respawn()
|
||||
} else {
|
||||
// Mix of reads and writes during respawn
|
||||
switch j % 4 {
|
||||
case 0:
|
||||
_ = gs.GetNumberHarvests()
|
||||
case 1:
|
||||
gs.SetNumberHarvests(int8(goroutineID % 3))
|
||||
case 2:
|
||||
_ = gs.IsAvailable()
|
||||
case 3:
|
||||
_ = gs.IsDepleted()
|
||||
}
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
}
|
||||
|
||||
// Stress test Manager with concurrent operations
|
||||
func TestManagerConcurrency(t *testing.T) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Pre-populate with some ground spawns
|
||||
for i := int32(1); i <= 10; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: float32(i * 45), GridID: 1,
|
||||
},
|
||||
Name: "Test Node",
|
||||
Description: "Test node",
|
||||
}
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
if gs == nil {
|
||||
t.Fatalf("Failed to create ground spawn %d", i)
|
||||
}
|
||||
}
|
||||
|
||||
const numGoroutines = 100
|
||||
const operationsPerGoroutine = 100
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
t.Run("ConcurrentGroundSpawnAccess", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
spawnID := int32((goroutineID % 10) + 1)
|
||||
|
||||
switch j % 5 {
|
||||
case 0:
|
||||
_ = manager.GetGroundSpawn(spawnID)
|
||||
case 1:
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
case 2:
|
||||
_ = manager.GetGroundSpawnCount()
|
||||
case 3:
|
||||
_ = manager.GetActiveGroundSpawns()
|
||||
case 4:
|
||||
_ = manager.GetDepletedGroundSpawns()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentStatisticsOperations", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
switch j % 3 {
|
||||
case 0:
|
||||
_ = manager.GetStatistics()
|
||||
case 1:
|
||||
manager.ResetStatistics()
|
||||
case 2:
|
||||
// Simulate harvest statistics updates
|
||||
manager.mutex.Lock()
|
||||
manager.totalHarvests++
|
||||
manager.successfulHarvests++
|
||||
skill := SkillGathering
|
||||
manager.harvestsBySkill[skill]++
|
||||
manager.mutex.Unlock()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
|
||||
// Verify statistics consistency
|
||||
stats := manager.GetStatistics()
|
||||
if stats.TotalHarvests < 0 || stats.SuccessfulHarvests < 0 {
|
||||
t.Errorf("Invalid statistics: total=%d, successful=%d",
|
||||
stats.TotalHarvests, stats.SuccessfulHarvests)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("ConcurrentGroundSpawnModification", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
// Use a more unique ID generation strategy to avoid conflicts
|
||||
// Start at 10000 and use goroutine*1000 + iteration to ensure uniqueness
|
||||
newID := int32(10000 + goroutineID*1000 + j)
|
||||
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: newID,
|
||||
CollectionSkill: SkillMining,
|
||||
NumberHarvests: 3,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(j), Y: float32(j * 2), Z: float32(j * 3),
|
||||
Heading: float32(j * 10), GridID: 1,
|
||||
},
|
||||
Name: "Concurrent Node",
|
||||
Description: "Concurrent test node",
|
||||
}
|
||||
|
||||
// Add ground spawn - note that CreateGroundSpawn overwrites the ID
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
if gs == nil {
|
||||
t.Errorf("Goroutine %d: Failed to create ground spawn", goroutineID)
|
||||
continue
|
||||
}
|
||||
|
||||
// Since CreateGroundSpawn assigns its own ID, we need to get the actual ID
|
||||
actualID := gs.GetID()
|
||||
|
||||
// Verify it was added with the manager-assigned ID
|
||||
retrieved := manager.GetGroundSpawn(actualID)
|
||||
if retrieved == nil {
|
||||
t.Errorf("Goroutine %d: Failed to retrieve ground spawn %d", goroutineID, actualID)
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentRespawnProcessing", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
if j%50 == 0 {
|
||||
// Process respawns occasionally
|
||||
manager.ProcessRespawns()
|
||||
} else {
|
||||
// Schedule respawns
|
||||
spawnID := int32((goroutineID % 10) + 1)
|
||||
if gs := manager.GetGroundSpawn(spawnID); gs != nil {
|
||||
if gs.IsDepleted() {
|
||||
manager.scheduleRespawn(gs)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
}
|
||||
|
||||
// Test for potential deadlocks
|
||||
func TestDeadlockPrevention(t *testing.T) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Create test ground spawns
|
||||
for i := int32(1); i <= 10; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Deadlock Test Node",
|
||||
Description: "Test node",
|
||||
}
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
if gs == nil {
|
||||
t.Fatalf("Failed to create ground spawn %d", i)
|
||||
}
|
||||
}
|
||||
|
||||
const numGoroutines = 50
|
||||
var wg sync.WaitGroup
|
||||
|
||||
// Test potential deadlock scenarios
|
||||
t.Run("MixedOperations", func(t *testing.T) {
|
||||
done := make(chan bool, 1)
|
||||
|
||||
// Set a timeout to detect deadlocks
|
||||
go func() {
|
||||
time.Sleep(10 * time.Second)
|
||||
select {
|
||||
case <-done:
|
||||
return
|
||||
default:
|
||||
t.Error("Potential deadlock detected - test timed out")
|
||||
}
|
||||
}()
|
||||
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range 100 {
|
||||
spawnID := int32((goroutineID % 10) + 1)
|
||||
|
||||
// Mix operations that could potentially deadlock
|
||||
switch j % 8 {
|
||||
case 0:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil {
|
||||
_ = gs.GetNumberHarvests()
|
||||
}
|
||||
case 1:
|
||||
_ = manager.GetStatistics()
|
||||
case 2:
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
case 3:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil {
|
||||
gs.SetNumberHarvests(int8(j % 5))
|
||||
}
|
||||
case 4:
|
||||
manager.ProcessRespawns()
|
||||
case 5:
|
||||
_ = manager.GetActiveGroundSpawns()
|
||||
case 6:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil {
|
||||
_ = gs.Copy()
|
||||
}
|
||||
case 7:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil && gs.IsDepleted() {
|
||||
manager.scheduleRespawn(gs)
|
||||
}
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
done <- true
|
||||
})
|
||||
}
|
||||
|
||||
// Race condition detection test - run with -race flag
|
||||
func TestRaceConditions(t *testing.T) {
|
||||
if testing.Short() {
|
||||
t.Skip("Skipping race condition test in short mode")
|
||||
}
|
||||
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Rapid concurrent operations to trigger race conditions
|
||||
const numGoroutines = 200
|
||||
const operationsPerGoroutine = 50
|
||||
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range operationsPerGoroutine {
|
||||
// Use unique IDs to avoid conflicts in rapid creation
|
||||
uniqueID := int32(20000 + goroutineID*1000 + j)
|
||||
|
||||
// Rapid-fire operations
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: uniqueID,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 3,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(j), Y: float32(j * 2), Z: float32(j * 3),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Race Test Node",
|
||||
Description: "Race test",
|
||||
}
|
||||
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
if gs != nil {
|
||||
actualID := gs.GetID() // Get the manager-assigned ID
|
||||
gs.SetNumberHarvests(int8(j%5 + 1))
|
||||
_ = gs.GetNumberHarvests()
|
||||
_ = gs.IsAvailable()
|
||||
copy := gs.Copy()
|
||||
if copy != nil {
|
||||
copy.SetCollectionSkill(SkillMining)
|
||||
}
|
||||
|
||||
_ = manager.GetGroundSpawn(actualID)
|
||||
}
|
||||
|
||||
_ = manager.GetStatistics()
|
||||
manager.ProcessRespawns()
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// Specific test for Copy() method mutex safety
|
||||
func TestCopyMutexSafety(t *testing.T) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Copy Test Node",
|
||||
Description: "Test node for copy safety",
|
||||
}
|
||||
|
||||
original := NewGroundSpawn(config)
|
||||
|
||||
const numGoroutines = 100
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
// Test copying while modifying
|
||||
for i := range numGoroutines {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := range 100 {
|
||||
if j%2 == 0 {
|
||||
// Copy operations
|
||||
copy := original.Copy()
|
||||
if copy == nil {
|
||||
t.Errorf("Goroutine %d: Copy returned nil", goroutineID)
|
||||
continue
|
||||
}
|
||||
|
||||
// Verify copy is independent by setting a unique value
|
||||
expectedValue := int8(goroutineID%5 + 1) // Ensure non-zero value
|
||||
copy.SetNumberHarvests(expectedValue)
|
||||
|
||||
// Verify the copy has the value we set
|
||||
if copy.GetNumberHarvests() != expectedValue {
|
||||
t.Errorf("Goroutine %d: Copy failed to set value correctly, expected %d got %d",
|
||||
goroutineID, expectedValue, copy.GetNumberHarvests())
|
||||
}
|
||||
|
||||
// Copy independence is verified by the fact that we can set different values
|
||||
// We don't check against original since other goroutines are modifying it concurrently
|
||||
} else {
|
||||
// Modify original
|
||||
original.SetNumberHarvests(int8(goroutineID % 10))
|
||||
original.SetCollectionSkill(SkillMining)
|
||||
_ = original.GetRandomizeHeading()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
}
|
||||
@ -1,14 +1,14 @@
|
||||
package ground_spawn
|
||||
|
||||
// Harvest type constants
|
||||
// Harvest type constants (preserved from C++ implementation)
|
||||
const (
|
||||
HarvestTypeNone = 0
|
||||
HarvestType1Item = 1
|
||||
HarvestType3Items = 2
|
||||
HarvestType5Items = 3
|
||||
HarvestTypeImbue = 4
|
||||
HarvestTypeRare = 5
|
||||
HarvestType10AndRare = 6
|
||||
HarvestTypeNone int8 = 0
|
||||
HarvestType1Item int8 = 1
|
||||
HarvestType3Items int8 = 2
|
||||
HarvestType5Items int8 = 3
|
||||
HarvestTypeImbue int8 = 4
|
||||
HarvestTypeRare int8 = 5
|
||||
HarvestType10AndRare int8 = 6
|
||||
)
|
||||
|
||||
// Harvest skill constants
|
||||
@ -39,11 +39,11 @@ const (
|
||||
HarvestResultNoItems
|
||||
)
|
||||
|
||||
// Item rarity flags
|
||||
// Item rarity flags (preserved from C++ implementation)
|
||||
const (
|
||||
ItemRarityNormal = 0
|
||||
ItemRarityRare = 1
|
||||
ItemRarityImbue = 2
|
||||
ItemRarityNormal int8 = 0
|
||||
ItemRarityRare int8 = 1
|
||||
ItemRarityImbue int8 = 2
|
||||
)
|
||||
|
||||
// Ground spawn state constants
|
||||
|
||||
@ -1,333 +0,0 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Mock implementations are in test_utils.go
|
||||
|
||||
// Test core GroundSpawn concurrency patterns without dependencies
|
||||
func TestGroundSpawnCoreConcurrency(t *testing.T) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 10,
|
||||
AttemptsPerHarvest: 2,
|
||||
RandomizeHeading: true,
|
||||
Location: SpawnLocation{
|
||||
X: 100.0, Y: 200.0, Z: 300.0, Heading: 45.0, GridID: 1,
|
||||
},
|
||||
Name: "Test Node",
|
||||
Description: "A test harvestable node",
|
||||
}
|
||||
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
const numGoroutines = 100
|
||||
const operationsPerGoroutine = 100
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
t.Run("ConcurrentAccessors", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := 0; j < operationsPerGoroutine; j++ {
|
||||
switch j % 8 {
|
||||
case 0:
|
||||
gs.SetNumberHarvests(int8(goroutineID % 10))
|
||||
case 1:
|
||||
_ = gs.GetNumberHarvests()
|
||||
case 2:
|
||||
gs.SetAttemptsPerHarvest(int8(goroutineID % 5))
|
||||
case 3:
|
||||
_ = gs.GetAttemptsPerHarvest()
|
||||
case 4:
|
||||
gs.SetCollectionSkill(SkillMining)
|
||||
case 5:
|
||||
_ = gs.GetCollectionSkill()
|
||||
case 6:
|
||||
gs.SetRandomizeHeading(goroutineID%2 == 0)
|
||||
case 7:
|
||||
_ = gs.GetRandomizeHeading()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentStateChecks", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := 0; j < operationsPerGoroutine; j++ {
|
||||
switch j % 4 {
|
||||
case 0:
|
||||
_ = gs.IsDepleted()
|
||||
case 1:
|
||||
_ = gs.IsAvailable()
|
||||
case 2:
|
||||
_ = gs.GetHarvestMessageName(true, false)
|
||||
case 3:
|
||||
_ = gs.GetHarvestSpellType()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
}
|
||||
|
||||
// Test Manager core concurrency patterns
|
||||
func TestManagerCoreConcurrency(t *testing.T) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Pre-populate with some ground spawns
|
||||
for i := int32(1); i <= 10; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: float32(i * 45), GridID: 1,
|
||||
},
|
||||
Name: "Test Node",
|
||||
Description: "Test node",
|
||||
}
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
if gs == nil {
|
||||
t.Fatalf("Failed to create ground spawn %d", i)
|
||||
}
|
||||
}
|
||||
|
||||
const numGoroutines = 50
|
||||
const operationsPerGoroutine = 50
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
t.Run("ConcurrentAccess", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := 0; j < operationsPerGoroutine; j++ {
|
||||
spawnID := int32((goroutineID % 10) + 1)
|
||||
|
||||
switch j % 5 {
|
||||
case 0:
|
||||
_ = manager.GetGroundSpawn(spawnID)
|
||||
case 1:
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
case 2:
|
||||
_ = manager.GetGroundSpawnCount()
|
||||
case 3:
|
||||
_ = manager.GetActiveGroundSpawns()
|
||||
case 4:
|
||||
_ = manager.GetDepletedGroundSpawns()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
t.Run("ConcurrentStatistics", func(t *testing.T) {
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := 0; j < operationsPerGoroutine; j++ {
|
||||
switch j % 3 {
|
||||
case 0:
|
||||
_ = manager.GetStatistics()
|
||||
case 1:
|
||||
manager.ResetStatistics()
|
||||
case 2:
|
||||
// Simulate statistics updates
|
||||
manager.mutex.Lock()
|
||||
manager.totalHarvests++
|
||||
manager.successfulHarvests++
|
||||
skill := SkillGathering
|
||||
manager.harvestsBySkill[skill]++
|
||||
manager.mutex.Unlock()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
|
||||
// Verify statistics consistency
|
||||
stats := manager.GetStatistics()
|
||||
if stats.TotalHarvests < 0 || stats.SuccessfulHarvests < 0 {
|
||||
t.Errorf("Invalid statistics: total=%d, successful=%d",
|
||||
stats.TotalHarvests, stats.SuccessfulHarvests)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Test Copy() method thread safety
|
||||
func TestCopyThreadSafety(t *testing.T) {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: 1,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: 100, Y: 200, Z: 300, Heading: 45, GridID: 1,
|
||||
},
|
||||
Name: "Copy Test Node",
|
||||
Description: "Test node for copy safety",
|
||||
}
|
||||
|
||||
original := NewGroundSpawn(config)
|
||||
|
||||
const numGoroutines = 50
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
// Test copying while modifying
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := 0; j < 100; j++ {
|
||||
if j%2 == 0 {
|
||||
// Copy operations
|
||||
copy := original.Copy()
|
||||
if copy == nil {
|
||||
t.Errorf("Goroutine %d: Copy returned nil", goroutineID)
|
||||
continue
|
||||
}
|
||||
|
||||
// Verify copy is independent by setting different values
|
||||
newValue := int8(goroutineID%5 + 1) // Ensure non-zero value
|
||||
copy.SetNumberHarvests(newValue)
|
||||
|
||||
// Copy should have the new value we just set
|
||||
if copy.GetNumberHarvests() != newValue {
|
||||
t.Errorf("Goroutine %d: Copy failed to set value correctly, expected %d got %d",
|
||||
goroutineID, newValue, copy.GetNumberHarvests())
|
||||
}
|
||||
// Note: We can't reliably test that original is unchanged due to concurrent modifications
|
||||
} else {
|
||||
// Modify original
|
||||
original.SetNumberHarvests(int8(goroutineID % 10))
|
||||
original.SetCollectionSkill(SkillMining)
|
||||
_ = original.GetRandomizeHeading()
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// Test core deadlock prevention
|
||||
func TestCoreDeadlockPrevention(t *testing.T) {
|
||||
manager := NewManager(nil, &mockLogger{})
|
||||
|
||||
// Create test ground spawns
|
||||
for i := int32(1); i <= 5; i++ {
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: i,
|
||||
CollectionSkill: SkillGathering,
|
||||
NumberHarvests: 5,
|
||||
AttemptsPerHarvest: 1,
|
||||
Location: SpawnLocation{
|
||||
X: float32(i * 10), Y: float32(i * 20), Z: float32(i * 30),
|
||||
Heading: 0, GridID: 1,
|
||||
},
|
||||
Name: "Deadlock Test Node",
|
||||
Description: "Test node",
|
||||
}
|
||||
gs := manager.CreateGroundSpawn(config)
|
||||
if gs == nil {
|
||||
t.Fatalf("Failed to create ground spawn %d", i)
|
||||
}
|
||||
}
|
||||
|
||||
const numGoroutines = 25
|
||||
var wg sync.WaitGroup
|
||||
|
||||
// Test potential deadlock scenarios
|
||||
t.Run("MixedOperations", func(t *testing.T) {
|
||||
done := make(chan bool, 1)
|
||||
|
||||
// Set a timeout to detect deadlocks
|
||||
go func() {
|
||||
time.Sleep(5 * time.Second)
|
||||
select {
|
||||
case <-done:
|
||||
return
|
||||
default:
|
||||
t.Error("Potential deadlock detected - test timed out")
|
||||
}
|
||||
}()
|
||||
|
||||
wg.Add(numGoroutines)
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(goroutineID int) {
|
||||
defer wg.Done()
|
||||
|
||||
for j := 0; j < 50; j++ {
|
||||
spawnID := int32((goroutineID % 5) + 1)
|
||||
|
||||
// Mix operations that could potentially deadlock
|
||||
switch j % 8 {
|
||||
case 0:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil {
|
||||
_ = gs.GetNumberHarvests()
|
||||
}
|
||||
case 1:
|
||||
_ = manager.GetStatistics()
|
||||
case 2:
|
||||
_ = manager.GetGroundSpawnsByZone(1)
|
||||
case 3:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil {
|
||||
gs.SetNumberHarvests(int8(j % 5))
|
||||
}
|
||||
case 4:
|
||||
manager.ProcessRespawns()
|
||||
case 5:
|
||||
_ = manager.GetActiveGroundSpawns()
|
||||
case 6:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil {
|
||||
_ = gs.Copy()
|
||||
}
|
||||
case 7:
|
||||
gs := manager.GetGroundSpawn(spawnID)
|
||||
if gs != nil && gs.IsDepleted() {
|
||||
manager.scheduleRespawn(gs)
|
||||
}
|
||||
}
|
||||
}
|
||||
}(i)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
done <- true
|
||||
})
|
||||
}
|
||||
@ -1,406 +0,0 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"zombiezen.com/go/sqlite"
|
||||
"zombiezen.com/go/sqlite/sqlitex"
|
||||
)
|
||||
|
||||
// DatabaseAdapter implements the Database interface using zombiezen.com/go/sqlite
|
||||
type DatabaseAdapter struct {
|
||||
pool *sqlitex.Pool
|
||||
}
|
||||
|
||||
// NewDatabaseAdapter creates a new database adapter using the sqlite pool
|
||||
func NewDatabaseAdapter(pool *sqlitex.Pool) *DatabaseAdapter {
|
||||
return &DatabaseAdapter{
|
||||
pool: pool,
|
||||
}
|
||||
}
|
||||
|
||||
// LoadGroundSpawnEntries loads harvest entries for a ground spawn
|
||||
func (da *DatabaseAdapter) LoadGroundSpawnEntries(groundspawnID int32) ([]*GroundSpawnEntry, error) {
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `
|
||||
SELECT min_skill_level, min_adventure_level, bonus_table, harvest_1, harvest_3,
|
||||
harvest_5, harvest_imbue, harvest_rare, harvest_10, harvest_coin
|
||||
FROM groundspawn_entries
|
||||
WHERE groundspawn_id = ?
|
||||
ORDER BY min_skill_level ASC
|
||||
`
|
||||
|
||||
var entries []*GroundSpawnEntry
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{groundspawnID},
|
||||
ResultFunc: func(stmt *sqlite.Stmt) error {
|
||||
entry := &GroundSpawnEntry{
|
||||
MinSkillLevel: int16(stmt.ColumnInt64(0)),
|
||||
MinAdventureLevel: int16(stmt.ColumnInt64(1)),
|
||||
BonusTable: stmt.ColumnInt64(2) == 1,
|
||||
Harvest1: float32(stmt.ColumnFloat(3)),
|
||||
Harvest3: float32(stmt.ColumnFloat(4)),
|
||||
Harvest5: float32(stmt.ColumnFloat(5)),
|
||||
HarvestImbue: float32(stmt.ColumnFloat(6)),
|
||||
HarvestRare: float32(stmt.ColumnFloat(7)),
|
||||
Harvest10: float32(stmt.ColumnFloat(8)),
|
||||
HarvestCoin: float32(stmt.ColumnFloat(9)),
|
||||
}
|
||||
entries = append(entries, entry)
|
||||
return nil
|
||||
},
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to query groundspawn entries: %w", err)
|
||||
}
|
||||
|
||||
return entries, nil
|
||||
}
|
||||
|
||||
// LoadGroundSpawnItems loads harvest items for a ground spawn
|
||||
func (da *DatabaseAdapter) LoadGroundSpawnItems(groundspawnID int32) ([]*GroundSpawnEntryItem, error) {
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `
|
||||
SELECT item_id, is_rare, grid_id, quantity
|
||||
FROM groundspawn_items
|
||||
WHERE groundspawn_id = ?
|
||||
ORDER BY item_id ASC
|
||||
`
|
||||
|
||||
var items []*GroundSpawnEntryItem
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{groundspawnID},
|
||||
ResultFunc: func(stmt *sqlite.Stmt) error {
|
||||
item := &GroundSpawnEntryItem{
|
||||
ItemID: int32(stmt.ColumnInt64(0)),
|
||||
IsRare: int8(stmt.ColumnInt64(1)),
|
||||
GridID: int32(stmt.ColumnInt64(2)),
|
||||
Quantity: int16(stmt.ColumnInt64(3)),
|
||||
}
|
||||
items = append(items, item)
|
||||
return nil
|
||||
},
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to query groundspawn items: %w", err)
|
||||
}
|
||||
|
||||
return items, nil
|
||||
}
|
||||
|
||||
// SaveGroundSpawn saves a ground spawn to the database
|
||||
func (da *DatabaseAdapter) SaveGroundSpawn(gs *GroundSpawn) error {
|
||||
if gs == nil {
|
||||
return fmt.Errorf("ground spawn cannot be nil")
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `
|
||||
INSERT OR REPLACE INTO groundspawns (
|
||||
id, name, x, y, z, heading, respawn_timer, collection_skill,
|
||||
number_harvests, attempts_per_harvest, groundspawn_entry_id,
|
||||
randomize_heading, zone_id, created_at, updated_at
|
||||
)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
|
||||
`
|
||||
|
||||
randomizeHeading := 0
|
||||
if gs.GetRandomizeHeading() {
|
||||
randomizeHeading = 1
|
||||
}
|
||||
|
||||
// TODO: Get actual zone ID from spawn
|
||||
zoneID := int32(1)
|
||||
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{
|
||||
gs.GetID(),
|
||||
gs.GetName(),
|
||||
gs.GetX(),
|
||||
gs.GetY(),
|
||||
gs.GetZ(),
|
||||
int16(gs.GetHeading()),
|
||||
300, // Default 5 minutes respawn timer
|
||||
gs.GetCollectionSkill(),
|
||||
gs.GetNumberHarvests(),
|
||||
gs.GetAttemptsPerHarvest(),
|
||||
gs.GetGroundSpawnEntryID(),
|
||||
randomizeHeading,
|
||||
zoneID,
|
||||
},
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to save ground spawn %d: %w", gs.GetID(), err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// LoadAllGroundSpawns loads all ground spawns from the database
|
||||
func (da *DatabaseAdapter) LoadAllGroundSpawns() ([]*GroundSpawn, error) {
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `
|
||||
SELECT id, name, x, y, z, heading, collection_skill, number_harvests,
|
||||
attempts_per_harvest, groundspawn_entry_id, randomize_heading
|
||||
FROM groundspawns
|
||||
WHERE zone_id = ?
|
||||
ORDER BY id ASC
|
||||
`
|
||||
|
||||
// TODO: Support multiple zones
|
||||
zoneID := int32(1)
|
||||
|
||||
var groundSpawns []*GroundSpawn
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{zoneID},
|
||||
ResultFunc: func(stmt *sqlite.Stmt) error {
|
||||
id := int32(stmt.ColumnInt64(0))
|
||||
name := stmt.ColumnText(1)
|
||||
x := float32(stmt.ColumnFloat(2))
|
||||
y := float32(stmt.ColumnFloat(3))
|
||||
z := float32(stmt.ColumnFloat(4))
|
||||
heading := float32(stmt.ColumnFloat(5))
|
||||
collectionSkill := stmt.ColumnText(6)
|
||||
numberHarvests := int8(stmt.ColumnInt64(7))
|
||||
attemptsPerHarvest := int8(stmt.ColumnInt64(8))
|
||||
groundspawnEntryID := int32(stmt.ColumnInt64(9))
|
||||
randomizeHeading := stmt.ColumnInt64(10) == 1
|
||||
|
||||
config := GroundSpawnConfig{
|
||||
GroundSpawnID: groundspawnEntryID,
|
||||
CollectionSkill: collectionSkill,
|
||||
NumberHarvests: numberHarvests,
|
||||
AttemptsPerHarvest: attemptsPerHarvest,
|
||||
RandomizeHeading: randomizeHeading,
|
||||
Location: SpawnLocation{
|
||||
X: x,
|
||||
Y: y,
|
||||
Z: z,
|
||||
Heading: heading,
|
||||
GridID: 1, // TODO: Load from database
|
||||
},
|
||||
Name: name,
|
||||
Description: fmt.Sprintf("A %s node", collectionSkill),
|
||||
}
|
||||
|
||||
gs := NewGroundSpawn(config)
|
||||
gs.SetID(id)
|
||||
|
||||
groundSpawns = append(groundSpawns, gs)
|
||||
return nil
|
||||
},
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to query groundspawns: %w", err)
|
||||
}
|
||||
|
||||
return groundSpawns, nil
|
||||
}
|
||||
|
||||
// DeleteGroundSpawn deletes a ground spawn from the database
|
||||
func (da *DatabaseAdapter) DeleteGroundSpawn(id int32) error {
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `DELETE FROM groundspawns WHERE id = ?`
|
||||
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{id},
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to delete ground spawn %d: %w", id, err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// LoadPlayerHarvestStatistics loads harvest statistics for a player
|
||||
func (da *DatabaseAdapter) LoadPlayerHarvestStatistics(playerID int32) (map[string]int64, error) {
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `
|
||||
SELECT skill_name, harvest_count
|
||||
FROM player_harvest_stats
|
||||
WHERE player_id = ?
|
||||
`
|
||||
|
||||
stats := make(map[string]int64)
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{playerID},
|
||||
ResultFunc: func(stmt *sqlite.Stmt) error {
|
||||
skillName := stmt.ColumnText(0)
|
||||
harvestCount := stmt.ColumnInt64(1)
|
||||
stats[skillName] = harvestCount
|
||||
return nil
|
||||
},
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to query player harvest stats: %w", err)
|
||||
}
|
||||
|
||||
return stats, nil
|
||||
}
|
||||
|
||||
// SavePlayerHarvestStatistic saves a player's harvest statistic
|
||||
func (da *DatabaseAdapter) SavePlayerHarvestStatistic(playerID int32, skillName string, count int64) error {
|
||||
ctx := context.Background()
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
query := `
|
||||
INSERT OR REPLACE INTO player_harvest_stats (player_id, skill_name, harvest_count, updated_at)
|
||||
VALUES (?, ?, ?, datetime('now'))
|
||||
`
|
||||
|
||||
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
||||
Args: []any{playerID, skillName, count},
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to save player harvest stat: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// EnsureGroundSpawnTables creates the necessary database tables if they don't exist
|
||||
func (da *DatabaseAdapter) EnsureGroundSpawnTables(ctx context.Context) error {
|
||||
conn, err := da.pool.Take(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to get database connection: %w", err)
|
||||
}
|
||||
defer da.pool.Put(conn)
|
||||
|
||||
// Create groundspawns table
|
||||
createGroundSpawnsTable := `
|
||||
CREATE TABLE IF NOT EXISTS groundspawns (
|
||||
id INTEGER PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
x REAL NOT NULL,
|
||||
y REAL NOT NULL,
|
||||
z REAL NOT NULL,
|
||||
heading REAL NOT NULL,
|
||||
respawn_timer INTEGER NOT NULL DEFAULT 300,
|
||||
collection_skill TEXT NOT NULL,
|
||||
number_harvests INTEGER NOT NULL DEFAULT 1,
|
||||
attempts_per_harvest INTEGER NOT NULL DEFAULT 1,
|
||||
groundspawn_entry_id INTEGER NOT NULL,
|
||||
randomize_heading INTEGER NOT NULL DEFAULT 0,
|
||||
zone_id INTEGER NOT NULL,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
)
|
||||
`
|
||||
|
||||
// Create groundspawn_entries table
|
||||
createGroundSpawnEntriesTable := `
|
||||
CREATE TABLE IF NOT EXISTS groundspawn_entries (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
groundspawn_id INTEGER NOT NULL,
|
||||
min_skill_level INTEGER NOT NULL DEFAULT 0,
|
||||
min_adventure_level INTEGER NOT NULL DEFAULT 0,
|
||||
bonus_table INTEGER NOT NULL DEFAULT 0,
|
||||
harvest_1 REAL NOT NULL DEFAULT 0.0,
|
||||
harvest_3 REAL NOT NULL DEFAULT 0.0,
|
||||
harvest_5 REAL NOT NULL DEFAULT 0.0,
|
||||
harvest_imbue REAL NOT NULL DEFAULT 0.0,
|
||||
harvest_rare REAL NOT NULL DEFAULT 0.0,
|
||||
harvest_10 REAL NOT NULL DEFAULT 0.0,
|
||||
harvest_coin REAL NOT NULL DEFAULT 0.0
|
||||
)
|
||||
`
|
||||
|
||||
// Create groundspawn_items table
|
||||
createGroundSpawnItemsTable := `
|
||||
CREATE TABLE IF NOT EXISTS groundspawn_items (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
groundspawn_id INTEGER NOT NULL,
|
||||
item_id INTEGER NOT NULL,
|
||||
is_rare INTEGER NOT NULL DEFAULT 0,
|
||||
grid_id INTEGER NOT NULL DEFAULT 0,
|
||||
quantity INTEGER NOT NULL DEFAULT 1
|
||||
)
|
||||
`
|
||||
|
||||
// Create player_harvest_stats table
|
||||
createPlayerHarvestStatsTable := `
|
||||
CREATE TABLE IF NOT EXISTS player_harvest_stats (
|
||||
player_id INTEGER NOT NULL,
|
||||
skill_name TEXT NOT NULL,
|
||||
harvest_count INTEGER NOT NULL DEFAULT 0,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
PRIMARY KEY (player_id, skill_name)
|
||||
)
|
||||
`
|
||||
|
||||
// Execute table creation statements
|
||||
tables := []string{
|
||||
createGroundSpawnsTable,
|
||||
createGroundSpawnEntriesTable,
|
||||
createGroundSpawnItemsTable,
|
||||
createPlayerHarvestStatsTable,
|
||||
}
|
||||
|
||||
for _, tableSQL := range tables {
|
||||
if err := sqlitex.Execute(conn, tableSQL, nil); err != nil {
|
||||
return fmt.Errorf("failed to create table: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Create indexes
|
||||
indexes := []string{
|
||||
`CREATE INDEX IF NOT EXISTS idx_groundspawn_entries_groundspawn_id ON groundspawn_entries(groundspawn_id)`,
|
||||
`CREATE INDEX IF NOT EXISTS idx_groundspawn_items_groundspawn_id ON groundspawn_items(groundspawn_id)`,
|
||||
`CREATE INDEX IF NOT EXISTS idx_groundspawns_zone_id ON groundspawns(zone_id)`,
|
||||
`CREATE INDEX IF NOT EXISTS idx_player_harvest_stats_player_id ON player_harvest_stats(player_id)`,
|
||||
}
|
||||
|
||||
for _, indexSQL := range indexes {
|
||||
if err := sqlitex.Execute(conn, indexSQL, nil); err != nil {
|
||||
return fmt.Errorf("failed to create index: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
38
internal/ground_spawn/doc.go
Normal file
38
internal/ground_spawn/doc.go
Normal file
@ -0,0 +1,38 @@
|
||||
// Package ground_spawn provides harvestable resource node management for EQ2.
|
||||
//
|
||||
// Ground spawns are harvestable nodes in the game world that provide resources
|
||||
// to players through skills like Mining, Gathering, Fishing, etc. This package
|
||||
// implements the complete harvest system including skill checks, item rewards,
|
||||
// rarity determination, and respawn management.
|
||||
//
|
||||
// Basic Usage:
|
||||
//
|
||||
// gs := ground_spawn.New(db)
|
||||
// gs.GroundSpawnID = 1001
|
||||
// gs.Name = "Iron Ore Node"
|
||||
// gs.CollectionSkill = "Mining"
|
||||
// gs.NumberHarvests = 5
|
||||
// gs.X, gs.Y, gs.Z = 100.0, 50.0, 200.0
|
||||
// gs.ZoneID = 1
|
||||
// gs.Save()
|
||||
//
|
||||
// loaded, _ := ground_spawn.Load(db, 1001)
|
||||
// result, _ := loaded.ProcessHarvest(player, skill, totalSkill)
|
||||
//
|
||||
// Master List:
|
||||
//
|
||||
// masterList := ground_spawn.NewMasterList()
|
||||
// masterList.LoadFromDatabase(db)
|
||||
// masterList.AddGroundSpawn(gs)
|
||||
//
|
||||
// zoneSpawns := masterList.GetByZone(1)
|
||||
// availableSpawns := masterList.GetAvailableSpawns()
|
||||
//
|
||||
// The harvest algorithm preserves the complete C++ EQ2EMU logic including:
|
||||
// - Skill-based table selection
|
||||
// - Adventure level requirements for bonus tables
|
||||
// - Collection vs normal harvesting modes
|
||||
// - Rarity determination (normal, rare, imbue, 10+rare)
|
||||
// - Grid-based item filtering
|
||||
// - Proper random number generation matching C++ behavior
|
||||
package ground_spawn
|
||||
@ -1,165 +1,199 @@
|
||||
// Package ground_spawn provides harvestable resource node management for EQ2.
|
||||
//
|
||||
// Basic Usage:
|
||||
//
|
||||
// gs := ground_spawn.New(db)
|
||||
// gs.CollectionSkill = "Mining"
|
||||
// gs.NumberHarvests = 5
|
||||
// gs.Save()
|
||||
//
|
||||
// loaded, _ := ground_spawn.Load(db, 1001)
|
||||
// result, _ := loaded.ProcessHarvest(context)
|
||||
//
|
||||
// Master List:
|
||||
//
|
||||
// masterList := ground_spawn.NewMasterList()
|
||||
// masterList.Add(gs)
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"eq2emu/internal/spawn"
|
||||
"eq2emu/internal/database"
|
||||
"zombiezen.com/go/sqlite"
|
||||
"zombiezen.com/go/sqlite/sqlitex"
|
||||
)
|
||||
|
||||
// NewGroundSpawn creates a new ground spawn instance
|
||||
func NewGroundSpawn(config GroundSpawnConfig) *GroundSpawn {
|
||||
baseSpawn := spawn.NewSpawn()
|
||||
// GroundSpawn represents a harvestable resource node with embedded database operations
|
||||
type GroundSpawn struct {
|
||||
// Database fields
|
||||
ID int32 `json:"id" db:"id"` // Auto-generated ID
|
||||
GroundSpawnID int32 `json:"groundspawn_id" db:"groundspawn_id"` // Entry ID for this type of ground spawn
|
||||
Name string `json:"name" db:"name"` // Display name
|
||||
CollectionSkill string `json:"collection_skill" db:"collection_skill"` // Required skill (Mining, Gathering, etc.)
|
||||
NumberHarvests int8 `json:"number_harvests" db:"number_harvests"` // Harvests before depletion
|
||||
AttemptsPerHarvest int8 `json:"attempts_per_harvest" db:"attempts_per_harvest"` // Attempts per harvest session
|
||||
RandomizeHeading bool `json:"randomize_heading" db:"randomize_heading"` // Randomize spawn heading
|
||||
RespawnTime int32 `json:"respawn_time" db:"respawn_time"` // Respawn time in seconds
|
||||
|
||||
// Position data
|
||||
X float32 `json:"x" db:"x"` // World X coordinate
|
||||
Y float32 `json:"y" db:"y"` // World Y coordinate
|
||||
Z float32 `json:"z" db:"z"` // World Z coordinate
|
||||
Heading float32 `json:"heading" db:"heading"` // Spawn heading/rotation
|
||||
ZoneID int32 `json:"zone_id" db:"zone_id"` // Zone identifier
|
||||
GridID int32 `json:"grid_id" db:"grid_id"` // Grid identifier
|
||||
|
||||
// State data
|
||||
IsAlive bool `json:"is_alive"` // Whether spawn is active
|
||||
CurrentHarvests int8 `json:"current_harvests"` // Current harvest count
|
||||
LastHarvested time.Time `json:"last_harvested"` // When last harvested
|
||||
NextRespawn time.Time `json:"next_respawn"` // When it will respawn
|
||||
|
||||
// Associated data (loaded separately)
|
||||
HarvestEntries []*HarvestEntry `json:"harvest_entries,omitempty"`
|
||||
HarvestItems []*HarvestEntryItem `json:"harvest_items,omitempty"`
|
||||
|
||||
// Database connection and internal state
|
||||
db *database.Database `json:"-"`
|
||||
isNew bool `json:"-"`
|
||||
harvestMux sync.Mutex `json:"-"`
|
||||
}
|
||||
|
||||
// New creates a new ground spawn with database connection
|
||||
func New(db *database.Database) *GroundSpawn {
|
||||
return &GroundSpawn{
|
||||
HarvestEntries: make([]*HarvestEntry, 0),
|
||||
HarvestItems: make([]*HarvestEntryItem, 0),
|
||||
db: db,
|
||||
isNew: true,
|
||||
IsAlive: true,
|
||||
CurrentHarvests: 0,
|
||||
NumberHarvests: 5, // Default
|
||||
AttemptsPerHarvest: 1, // Default
|
||||
RandomizeHeading: true,
|
||||
}
|
||||
}
|
||||
|
||||
// Load loads a ground spawn by ID from database
|
||||
func Load(db *database.Database, groundSpawnID int32) (*GroundSpawn, error) {
|
||||
gs := &GroundSpawn{
|
||||
Spawn: baseSpawn,
|
||||
numberHarvests: config.NumberHarvests,
|
||||
numAttemptsPerHarvest: config.AttemptsPerHarvest,
|
||||
groundspawnID: config.GroundSpawnID,
|
||||
collectionSkill: config.CollectionSkill,
|
||||
randomizeHeading: config.RandomizeHeading,
|
||||
db: db,
|
||||
isNew: false,
|
||||
}
|
||||
|
||||
// Configure base spawn properties
|
||||
gs.SetName(config.Name)
|
||||
gs.SetSpawnType(DefaultSpawnType)
|
||||
// Note: SetDifficulty and SetState methods not available in spawn interface
|
||||
|
||||
// Set position
|
||||
gs.SetX(config.Location.X)
|
||||
gs.SetY(config.Location.Y, false)
|
||||
gs.SetZ(config.Location.Z)
|
||||
|
||||
if config.RandomizeHeading {
|
||||
// Convert float32 to int16 for heading
|
||||
heading := int16(rand.Float32() * 360.0)
|
||||
gs.SetHeading(heading, heading)
|
||||
if db.GetType() == database.SQLite {
|
||||
err := db.ExecTransient(`
|
||||
SELECT id, groundspawn_id, name, collection_skill, number_harvests,
|
||||
attempts_per_harvest, randomize_heading, respawn_time,
|
||||
x, y, z, heading, zone_id, grid_id
|
||||
FROM ground_spawns WHERE groundspawn_id = ?
|
||||
`, func(stmt *sqlite.Stmt) error {
|
||||
gs.ID = stmt.ColumnInt32(0)
|
||||
gs.GroundSpawnID = stmt.ColumnInt32(1)
|
||||
gs.Name = stmt.ColumnText(2)
|
||||
gs.CollectionSkill = stmt.ColumnText(3)
|
||||
gs.NumberHarvests = int8(stmt.ColumnInt32(4))
|
||||
gs.AttemptsPerHarvest = int8(stmt.ColumnInt32(5))
|
||||
gs.RandomizeHeading = stmt.ColumnBool(6)
|
||||
gs.RespawnTime = stmt.ColumnInt32(7)
|
||||
gs.X = float32(stmt.ColumnFloat(8))
|
||||
gs.Y = float32(stmt.ColumnFloat(9))
|
||||
gs.Z = float32(stmt.ColumnFloat(10))
|
||||
gs.Heading = float32(stmt.ColumnFloat(11))
|
||||
gs.ZoneID = stmt.ColumnInt32(12)
|
||||
gs.GridID = stmt.ColumnInt32(13)
|
||||
return nil
|
||||
}, groundSpawnID)
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ground spawn not found: %d", groundSpawnID)
|
||||
}
|
||||
} else {
|
||||
heading := int16(config.Location.Heading)
|
||||
gs.SetHeading(heading, heading)
|
||||
// MySQL implementation
|
||||
row := db.QueryRow(`
|
||||
SELECT id, groundspawn_id, name, collection_skill, number_harvests,
|
||||
attempts_per_harvest, randomize_heading, respawn_time,
|
||||
x, y, z, heading, zone_id, grid_id
|
||||
FROM ground_spawns WHERE groundspawn_id = ?
|
||||
`, groundSpawnID)
|
||||
|
||||
err := row.Scan(&gs.ID, &gs.GroundSpawnID, &gs.Name, &gs.CollectionSkill,
|
||||
&gs.NumberHarvests, &gs.AttemptsPerHarvest, &gs.RandomizeHeading,
|
||||
&gs.RespawnTime, &gs.X, &gs.Y, &gs.Z, &gs.Heading, &gs.ZoneID, &gs.GridID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ground spawn not found: %d", groundSpawnID)
|
||||
}
|
||||
}
|
||||
|
||||
return gs
|
||||
}
|
||||
// Initialize state
|
||||
gs.IsAlive = true
|
||||
gs.CurrentHarvests = gs.NumberHarvests
|
||||
|
||||
// Copy creates a deep copy of the ground spawn
|
||||
func (gs *GroundSpawn) Copy() *GroundSpawn {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
newSpawn := &GroundSpawn{
|
||||
Spawn: gs.Spawn, // TODO: Implement proper copy when spawn.Copy() is available
|
||||
numberHarvests: gs.numberHarvests,
|
||||
numAttemptsPerHarvest: gs.numAttemptsPerHarvest,
|
||||
groundspawnID: gs.groundspawnID,
|
||||
collectionSkill: gs.collectionSkill,
|
||||
randomizeHeading: gs.randomizeHeading,
|
||||
// Reset mutexes in the copy to avoid sharing the same mutex instances
|
||||
// harvestMutex and harvestUseMutex are zero-initialized (correct behavior)
|
||||
// Load harvest entries and items
|
||||
if err := gs.loadHarvestData(); err != nil {
|
||||
return nil, fmt.Errorf("failed to load harvest data: %w", err)
|
||||
}
|
||||
|
||||
return newSpawn
|
||||
return gs, nil
|
||||
}
|
||||
|
||||
// IsGroundSpawn returns true (implements spawn interface)
|
||||
// Save saves the ground spawn to database
|
||||
func (gs *GroundSpawn) Save() error {
|
||||
if gs.db == nil {
|
||||
return fmt.Errorf("no database connection")
|
||||
}
|
||||
|
||||
if gs.isNew {
|
||||
return gs.insert()
|
||||
}
|
||||
return gs.update()
|
||||
}
|
||||
|
||||
// Delete removes the ground spawn from database
|
||||
func (gs *GroundSpawn) Delete() error {
|
||||
if gs.db == nil {
|
||||
return fmt.Errorf("no database connection")
|
||||
}
|
||||
if gs.isNew {
|
||||
return fmt.Errorf("cannot delete unsaved ground spawn")
|
||||
}
|
||||
|
||||
if gs.db.GetType() == database.SQLite {
|
||||
return gs.db.Execute("DELETE FROM ground_spawns WHERE groundspawn_id = ?",
|
||||
&sqlitex.ExecOptions{Args: []any{gs.GroundSpawnID}})
|
||||
}
|
||||
_, err := gs.db.Exec("DELETE FROM ground_spawns WHERE groundspawn_id = ?", gs.GroundSpawnID)
|
||||
return err
|
||||
}
|
||||
|
||||
// GetID returns the ground spawn ID (implements common.Identifiable)
|
||||
func (gs *GroundSpawn) GetID() int32 {
|
||||
return gs.GroundSpawnID
|
||||
}
|
||||
|
||||
// IsGroundSpawn returns true (compatibility method)
|
||||
func (gs *GroundSpawn) IsGroundSpawn() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// GetNumberHarvests returns the number of harvests remaining
|
||||
func (gs *GroundSpawn) GetNumberHarvests() int8 {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
return gs.numberHarvests
|
||||
}
|
||||
|
||||
// SetNumberHarvests sets the number of harvests remaining
|
||||
func (gs *GroundSpawn) SetNumberHarvests(val int8) {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
gs.numberHarvests = val
|
||||
}
|
||||
|
||||
// GetAttemptsPerHarvest returns attempts per harvest session
|
||||
func (gs *GroundSpawn) GetAttemptsPerHarvest() int8 {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
return gs.numAttemptsPerHarvest
|
||||
}
|
||||
|
||||
// SetAttemptsPerHarvest sets attempts per harvest session
|
||||
func (gs *GroundSpawn) SetAttemptsPerHarvest(val int8) {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
gs.numAttemptsPerHarvest = val
|
||||
}
|
||||
|
||||
// GetGroundSpawnEntryID returns the database entry ID
|
||||
func (gs *GroundSpawn) GetGroundSpawnEntryID() int32 {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
return gs.groundspawnID
|
||||
}
|
||||
|
||||
// SetGroundSpawnEntryID sets the database entry ID
|
||||
func (gs *GroundSpawn) SetGroundSpawnEntryID(val int32) {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
gs.groundspawnID = val
|
||||
}
|
||||
|
||||
// GetCollectionSkill returns the required harvesting skill
|
||||
func (gs *GroundSpawn) GetCollectionSkill() string {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
return gs.collectionSkill
|
||||
}
|
||||
|
||||
// SetCollectionSkill sets the required harvesting skill
|
||||
func (gs *GroundSpawn) SetCollectionSkill(skill string) {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
gs.collectionSkill = skill
|
||||
}
|
||||
|
||||
// GetRandomizeHeading returns whether heading should be randomized
|
||||
func (gs *GroundSpawn) GetRandomizeHeading() bool {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
return gs.randomizeHeading
|
||||
}
|
||||
|
||||
// SetRandomizeHeading sets whether heading should be randomized
|
||||
func (gs *GroundSpawn) SetRandomizeHeading(val bool) {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
|
||||
gs.randomizeHeading = val
|
||||
}
|
||||
|
||||
// IsDepleted returns true if the ground spawn has no harvests remaining
|
||||
func (gs *GroundSpawn) IsDepleted() bool {
|
||||
return gs.GetNumberHarvests() <= 0
|
||||
return gs.CurrentHarvests <= 0
|
||||
}
|
||||
|
||||
// IsAvailable returns true if the ground spawn can be harvested
|
||||
func (gs *GroundSpawn) IsAvailable() bool {
|
||||
return gs.GetNumberHarvests() > 0 && gs.IsAlive()
|
||||
return gs.CurrentHarvests > 0 && gs.IsAlive
|
||||
}
|
||||
|
||||
// GetHarvestMessageName returns the appropriate harvest verb based on skill
|
||||
func (gs *GroundSpawn) GetHarvestMessageName(presentTense bool, failure bool) string {
|
||||
skill := strings.ToLower(gs.GetCollectionSkill())
|
||||
skill := strings.ToLower(gs.CollectionSkill)
|
||||
|
||||
switch skill {
|
||||
case "gathering", "collecting":
|
||||
@ -205,7 +239,7 @@ func (gs *GroundSpawn) GetHarvestMessageName(presentTense bool, failure bool) st
|
||||
|
||||
// GetHarvestSpellType returns the spell type for harvesting
|
||||
func (gs *GroundSpawn) GetHarvestSpellType() string {
|
||||
skill := strings.ToLower(gs.GetCollectionSkill())
|
||||
skill := strings.ToLower(gs.CollectionSkill)
|
||||
|
||||
switch skill {
|
||||
case "gathering", "collecting":
|
||||
@ -225,7 +259,7 @@ func (gs *GroundSpawn) GetHarvestSpellType() string {
|
||||
|
||||
// GetHarvestSpellName returns the spell name for harvesting
|
||||
func (gs *GroundSpawn) GetHarvestSpellName() string {
|
||||
skill := gs.GetCollectionSkill()
|
||||
skill := gs.CollectionSkill
|
||||
|
||||
if skill == SkillCollecting {
|
||||
return SkillGathering
|
||||
@ -234,21 +268,13 @@ func (gs *GroundSpawn) GetHarvestSpellName() string {
|
||||
return skill
|
||||
}
|
||||
|
||||
// ProcessHarvest handles the complex harvesting logic
|
||||
func (gs *GroundSpawn) ProcessHarvest(context *HarvestContext) (*HarvestResult, error) {
|
||||
if context == nil {
|
||||
return nil, fmt.Errorf("harvest context cannot be nil")
|
||||
}
|
||||
|
||||
if context.Player == nil {
|
||||
return nil, fmt.Errorf("player cannot be nil")
|
||||
}
|
||||
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
// ProcessHarvest handles the complex harvesting logic (preserves C++ algorithm)
|
||||
func (gs *GroundSpawn) ProcessHarvest(player Player, skill Skill, totalSkill int16) (*HarvestResult, error) {
|
||||
gs.harvestMux.Lock()
|
||||
defer gs.harvestMux.Unlock()
|
||||
|
||||
// Check if ground spawn is depleted
|
||||
if gs.numberHarvests <= 0 {
|
||||
if gs.CurrentHarvests <= 0 {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
MessageText: "This spawn has nothing more to harvest!",
|
||||
@ -256,36 +282,31 @@ func (gs *GroundSpawn) ProcessHarvest(context *HarvestContext) (*HarvestResult,
|
||||
}
|
||||
|
||||
// Validate harvest data
|
||||
if len(context.GroundSpawnEntries) == 0 {
|
||||
if len(gs.HarvestEntries) == 0 {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
MessageText: fmt.Sprintf("Error: No groundspawn entries assigned to groundspawn id: %d", gs.groundspawnID),
|
||||
MessageText: fmt.Sprintf("Error: No groundspawn entries assigned to groundspawn id: %d", gs.GroundSpawnID),
|
||||
}, nil
|
||||
}
|
||||
|
||||
if len(context.GroundSpawnItems) == 0 {
|
||||
if len(gs.HarvestItems) == 0 {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
MessageText: fmt.Sprintf("Error: No groundspawn items assigned to groundspawn id: %d", gs.groundspawnID),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Validate player skill
|
||||
if context.PlayerSkill == nil {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
MessageText: fmt.Sprintf("Error: You do not have the '%s' skill!", gs.collectionSkill),
|
||||
MessageText: fmt.Sprintf("Error: No groundspawn items assigned to groundspawn id: %d", gs.GroundSpawnID),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Check for collection skill
|
||||
isCollection := gs.CollectionSkill == "Collecting"
|
||||
|
||||
result := &HarvestResult{
|
||||
Success: true,
|
||||
ItemsAwarded: make([]*HarvestedItem, 0),
|
||||
}
|
||||
|
||||
// Process each harvest attempt
|
||||
for attempt := int8(0); attempt < gs.numAttemptsPerHarvest; attempt++ {
|
||||
attemptResult := gs.processHarvestAttempt(context)
|
||||
// Process each harvest attempt (preserving C++ logic)
|
||||
for attempt := int8(0); attempt < gs.AttemptsPerHarvest; attempt++ {
|
||||
attemptResult := gs.processHarvestAttempt(player, skill, totalSkill, isCollection)
|
||||
if attemptResult != nil {
|
||||
result.ItemsAwarded = append(result.ItemsAwarded, attemptResult.ItemsAwarded...)
|
||||
if attemptResult.SkillGained {
|
||||
@ -294,16 +315,17 @@ func (gs *GroundSpawn) ProcessHarvest(context *HarvestContext) (*HarvestResult,
|
||||
}
|
||||
}
|
||||
|
||||
// Decrement harvest count
|
||||
gs.numberHarvests--
|
||||
// Decrement harvest count and update state
|
||||
gs.CurrentHarvests--
|
||||
gs.LastHarvested = time.Now()
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// processHarvestAttempt handles a single harvest attempt
|
||||
func (gs *GroundSpawn) processHarvestAttempt(context *HarvestContext) *HarvestResult {
|
||||
// processHarvestAttempt handles a single harvest attempt (preserves C++ algorithm)
|
||||
func (gs *GroundSpawn) processHarvestAttempt(player Player, skill Skill, totalSkill int16, isCollection bool) *HarvestResult {
|
||||
// Filter available harvest tables based on player skill and level
|
||||
availableTables := gs.filterHarvestTables(context)
|
||||
availableTables := gs.filterHarvestTables(player, totalSkill)
|
||||
if len(availableTables) == 0 {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
@ -311,8 +333,8 @@ func (gs *GroundSpawn) processHarvestAttempt(context *HarvestContext) *HarvestRe
|
||||
}
|
||||
}
|
||||
|
||||
// Select harvest table based on skill roll
|
||||
selectedTable := gs.selectHarvestTable(availableTables, context.TotalSkill)
|
||||
// Select harvest table based on skill roll (matching C++ algorithm)
|
||||
selectedTable := gs.selectHarvestTable(availableTables, totalSkill)
|
||||
if selectedTable == nil {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
@ -321,20 +343,20 @@ func (gs *GroundSpawn) processHarvestAttempt(context *HarvestContext) *HarvestRe
|
||||
}
|
||||
|
||||
// Determine harvest type based on table percentages
|
||||
harvestType := gs.determineHarvestType(selectedTable, context.IsCollection)
|
||||
harvestType := gs.determineHarvestType(selectedTable, isCollection)
|
||||
if harvestType == HarvestTypeNone {
|
||||
return &HarvestResult{
|
||||
Success: false,
|
||||
MessageText: fmt.Sprintf("You failed to %s anything from %s.",
|
||||
gs.GetHarvestMessageName(true, true), gs.GetName()),
|
||||
gs.GetHarvestMessageName(true, true), gs.Name),
|
||||
}
|
||||
}
|
||||
|
||||
// Award items based on harvest type
|
||||
items := gs.awardHarvestItems(harvestType, context.GroundSpawnItems, context.Player)
|
||||
items := gs.awardHarvestItems(harvestType, player)
|
||||
|
||||
// Handle skill progression
|
||||
skillGained := gs.handleSkillProgression(context, selectedTable)
|
||||
// Handle skill progression (simplified for now)
|
||||
skillGained := false // TODO: Implement skill progression
|
||||
|
||||
return &HarvestResult{
|
||||
Success: len(items) > 0,
|
||||
@ -344,18 +366,18 @@ func (gs *GroundSpawn) processHarvestAttempt(context *HarvestContext) *HarvestRe
|
||||
}
|
||||
}
|
||||
|
||||
// filterHarvestTables filters tables based on player capabilities
|
||||
func (gs *GroundSpawn) filterHarvestTables(context *HarvestContext) []*GroundSpawnEntry {
|
||||
var filtered []*GroundSpawnEntry
|
||||
// filterHarvestTables filters tables based on player capabilities (preserves C++ logic)
|
||||
func (gs *GroundSpawn) filterHarvestTables(player Player, totalSkill int16) []*HarvestEntry {
|
||||
var filtered []*HarvestEntry
|
||||
|
||||
for _, entry := range context.GroundSpawnEntries {
|
||||
for _, entry := range gs.HarvestEntries {
|
||||
// Check skill requirement
|
||||
if entry.MinSkillLevel > context.TotalSkill {
|
||||
if entry.MinSkillLevel > totalSkill {
|
||||
continue
|
||||
}
|
||||
|
||||
// Check level requirement for bonus tables
|
||||
if entry.BonusTable && (*context.Player).GetLevel() < entry.MinAdventureLevel {
|
||||
if entry.BonusTable && player.GetLevel() < entry.MinAdventureLevel {
|
||||
continue
|
||||
}
|
||||
|
||||
@ -365,13 +387,13 @@ func (gs *GroundSpawn) filterHarvestTables(context *HarvestContext) []*GroundSpa
|
||||
return filtered
|
||||
}
|
||||
|
||||
// selectHarvestTable selects a harvest table based on skill level
|
||||
func (gs *GroundSpawn) selectHarvestTable(tables []*GroundSpawnEntry, totalSkill int16) *GroundSpawnEntry {
|
||||
// selectHarvestTable selects a harvest table based on skill level (preserves C++ algorithm)
|
||||
func (gs *GroundSpawn) selectHarvestTable(tables []*HarvestEntry, totalSkill int16) *HarvestEntry {
|
||||
if len(tables) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Find lowest skill requirement
|
||||
// Find lowest skill requirement (matching C++ logic)
|
||||
lowestSkill := int16(32767)
|
||||
for _, table := range tables {
|
||||
if table.MinSkillLevel < lowestSkill {
|
||||
@ -379,11 +401,11 @@ func (gs *GroundSpawn) selectHarvestTable(tables []*GroundSpawnEntry, totalSkill
|
||||
}
|
||||
}
|
||||
|
||||
// Roll for table selection
|
||||
// Roll for table selection (matching C++ MakeRandomInt)
|
||||
tableChoice := int16(rand.Intn(int(totalSkill-lowestSkill+1))) + lowestSkill
|
||||
|
||||
// Find best matching table
|
||||
var bestTable *GroundSpawnEntry
|
||||
// Find best matching table (matching C++ logic)
|
||||
var bestTable *HarvestEntry
|
||||
bestScore := int16(0)
|
||||
|
||||
for _, table := range tables {
|
||||
@ -393,8 +415,8 @@ func (gs *GroundSpawn) selectHarvestTable(tables []*GroundSpawnEntry, totalSkill
|
||||
}
|
||||
}
|
||||
|
||||
// If multiple tables match, pick randomly
|
||||
var matches []*GroundSpawnEntry
|
||||
// If multiple tables match, pick randomly (matching C++ logic)
|
||||
var matches []*HarvestEntry
|
||||
for _, table := range tables {
|
||||
if table.MinSkillLevel == bestScore {
|
||||
matches = append(matches, table)
|
||||
@ -408,16 +430,16 @@ func (gs *GroundSpawn) selectHarvestTable(tables []*GroundSpawnEntry, totalSkill
|
||||
return bestTable
|
||||
}
|
||||
|
||||
// determineHarvestType determines what type of harvest occurs
|
||||
func (gs *GroundSpawn) determineHarvestType(table *GroundSpawnEntry, isCollection bool) int8 {
|
||||
// determineHarvestType determines what type of harvest occurs (preserves C++ algorithm)
|
||||
func (gs *GroundSpawn) determineHarvestType(table *HarvestEntry, isCollection bool) int8 {
|
||||
chance := rand.Float32() * 100.0
|
||||
|
||||
// Collection items always get 1 item
|
||||
// Collection items always get 1 item (matching C++ logic)
|
||||
if isCollection {
|
||||
return HarvestType1Item
|
||||
}
|
||||
|
||||
// Check harvest types in order of rarity (most rare first)
|
||||
// Check harvest types in order of rarity (matching C++ order)
|
||||
if chance <= table.Harvest10 {
|
||||
return HarvestType10AndRare
|
||||
}
|
||||
@ -440,14 +462,14 @@ func (gs *GroundSpawn) determineHarvestType(table *GroundSpawnEntry, isCollectio
|
||||
return HarvestTypeNone
|
||||
}
|
||||
|
||||
// awardHarvestItems awards items based on harvest type
|
||||
func (gs *GroundSpawn) awardHarvestItems(harvestType int8, availableItems []*GroundSpawnEntryItem, player *Player) []*HarvestedItem {
|
||||
// awardHarvestItems awards items based on harvest type (preserves C++ algorithm)
|
||||
func (gs *GroundSpawn) awardHarvestItems(harvestType int8, player Player) []*HarvestedItem {
|
||||
var items []*HarvestedItem
|
||||
|
||||
// Filter items based on harvest type and player location
|
||||
normalItems := gs.filterItems(availableItems, ItemRarityNormal, (*player).GetLocation())
|
||||
rareItems := gs.filterItems(availableItems, ItemRarityRare, (*player).GetLocation())
|
||||
imbueItems := gs.filterItems(availableItems, ItemRarityImbue, (*player).GetLocation())
|
||||
// Filter items based on harvest type and player location (matching C++ logic)
|
||||
normalItems := gs.filterItems(gs.HarvestItems, ItemRarityNormal, player.GetLocation())
|
||||
rareItems := gs.filterItems(gs.HarvestItems, ItemRarityRare, player.GetLocation())
|
||||
imbueItems := gs.filterItems(gs.HarvestItems, ItemRarityImbue, player.GetLocation())
|
||||
|
||||
switch harvestType {
|
||||
case HarvestType1Item:
|
||||
@ -469,16 +491,16 @@ func (gs *GroundSpawn) awardHarvestItems(harvestType int8, availableItems []*Gro
|
||||
return items
|
||||
}
|
||||
|
||||
// filterItems filters items by rarity and grid restriction
|
||||
func (gs *GroundSpawn) filterItems(items []*GroundSpawnEntryItem, rarity int8, playerGrid int32) []*GroundSpawnEntryItem {
|
||||
var filtered []*GroundSpawnEntryItem
|
||||
// filterItems filters items by rarity and grid restriction (preserves C++ logic)
|
||||
func (gs *GroundSpawn) filterItems(items []*HarvestEntryItem, rarity int8, playerGrid int32) []*HarvestEntryItem {
|
||||
var filtered []*HarvestEntryItem
|
||||
|
||||
for _, item := range items {
|
||||
if item.IsRare != rarity {
|
||||
continue
|
||||
}
|
||||
|
||||
// Check grid restriction
|
||||
// Check grid restriction (matching C++ logic)
|
||||
if item.GridID != 0 && item.GridID != playerGrid {
|
||||
continue
|
||||
}
|
||||
@ -489,8 +511,8 @@ func (gs *GroundSpawn) filterItems(items []*GroundSpawnEntryItem, rarity int8, p
|
||||
return filtered
|
||||
}
|
||||
|
||||
// selectRandomItems randomly selects items from available list
|
||||
func (gs *GroundSpawn) selectRandomItems(items []*GroundSpawnEntryItem, quantity int16) []*HarvestedItem {
|
||||
// selectRandomItems randomly selects items from available list (preserves C++ logic)
|
||||
func (gs *GroundSpawn) selectRandomItems(items []*HarvestEntryItem, quantity int16) []*HarvestedItem {
|
||||
if len(items) == 0 {
|
||||
return nil
|
||||
}
|
||||
@ -504,7 +526,7 @@ func (gs *GroundSpawn) selectRandomItems(items []*GroundSpawnEntryItem, quantity
|
||||
ItemID: selectedItem.ItemID,
|
||||
Quantity: selectedItem.Quantity,
|
||||
IsRare: selectedItem.IsRare == ItemRarityRare,
|
||||
Name: fmt.Sprintf("Item_%d", selectedItem.ItemID), // Placeholder
|
||||
Name: fmt.Sprintf("Item_%d", selectedItem.ItemID), // Placeholder for item name lookup
|
||||
}
|
||||
|
||||
result = append(result, harvestedItem)
|
||||
@ -513,133 +535,189 @@ func (gs *GroundSpawn) selectRandomItems(items []*GroundSpawnEntryItem, quantity
|
||||
return result
|
||||
}
|
||||
|
||||
// handleSkillProgression manages skill increases from harvesting
|
||||
func (gs *GroundSpawn) handleSkillProgression(context *HarvestContext, table *GroundSpawnEntry) bool {
|
||||
if context.IsCollection {
|
||||
return false // Collections don't give skill
|
||||
}
|
||||
|
||||
if context.PlayerSkill == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check if player skill is already at max for this node
|
||||
maxSkillAllowed := int16(float32(context.MaxSkillRequired) * 1.0) // TODO: Use skill multiplier rule
|
||||
|
||||
if (*context.PlayerSkill).GetCurrentValue() >= maxSkillAllowed {
|
||||
return false
|
||||
}
|
||||
|
||||
// Award skill increase (placeholder implementation)
|
||||
// TODO: Integrate with actual skill system when available
|
||||
return true
|
||||
}
|
||||
|
||||
// HandleUse processes player interaction with the ground spawn
|
||||
func (gs *GroundSpawn) HandleUse(client Client, useType string) error {
|
||||
if client == nil {
|
||||
return fmt.Errorf("client cannot be nil")
|
||||
}
|
||||
|
||||
gs.harvestUseMutex.Lock()
|
||||
defer gs.harvestUseMutex.Unlock()
|
||||
|
||||
// Check spawn access requirements
|
||||
if !gs.MeetsSpawnAccessRequirements(client.GetPlayer()) {
|
||||
return nil // Silently ignore if requirements not met
|
||||
}
|
||||
|
||||
// Normalize use type
|
||||
useType = strings.ToLower(strings.TrimSpace(useType))
|
||||
|
||||
// Handle older clients that don't send use type
|
||||
if client.GetVersion() <= 561 && useType == "" {
|
||||
useType = gs.GetHarvestSpellType()
|
||||
}
|
||||
|
||||
// Check if this is a harvest action
|
||||
expectedSpellType := gs.GetHarvestSpellType()
|
||||
if useType == expectedSpellType {
|
||||
return gs.handleHarvestUse(client)
|
||||
}
|
||||
|
||||
// Handle other command interactions
|
||||
if gs.HasCommandIcon() {
|
||||
return gs.handleCommandUse(client, useType)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// handleHarvestUse processes harvest-specific use
|
||||
func (gs *GroundSpawn) handleHarvestUse(client Client) error {
|
||||
spellName := gs.GetHarvestSpellName()
|
||||
|
||||
// TODO: Integrate with spell system when available
|
||||
// spell := masterSpellList.GetSpellByName(spellName)
|
||||
// if spell != nil {
|
||||
// zone.ProcessSpell(spell, player, target, true, true)
|
||||
// }
|
||||
|
||||
if client.GetLogger() != nil {
|
||||
client.GetLogger().LogDebug("Player %s attempting to harvest %s using spell %s",
|
||||
(*client.GetPlayer()).GetName(), gs.GetName(), spellName)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// handleCommandUse processes command-specific use
|
||||
func (gs *GroundSpawn) handleCommandUse(client Client, command string) error {
|
||||
// TODO: Integrate with entity command system when available
|
||||
// entityCommand := gs.FindEntityCommand(command)
|
||||
// if entityCommand != nil {
|
||||
// zone.ProcessEntityCommand(entityCommand, player, target)
|
||||
// }
|
||||
|
||||
if client.GetLogger() != nil {
|
||||
client.GetLogger().LogDebug("Player %s using command %s on %s",
|
||||
(*client.GetPlayer()).GetName(), command, gs.GetName())
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Serialize creates a packet representation of the ground spawn
|
||||
func (gs *GroundSpawn) Serialize(player *Player, version int16) ([]byte, error) {
|
||||
// TODO: Implement proper ground spawn serialization when spawn.Serialize is available
|
||||
// For now, return empty packet as placeholder
|
||||
return make([]byte, 0), nil
|
||||
}
|
||||
|
||||
// Respawn resets the ground spawn to harvestable state
|
||||
func (gs *GroundSpawn) Respawn() {
|
||||
gs.harvestMutex.Lock()
|
||||
defer gs.harvestMutex.Unlock()
|
||||
gs.harvestMux.Lock()
|
||||
defer gs.harvestMux.Unlock()
|
||||
|
||||
// Reset harvest count to default
|
||||
gs.numberHarvests = DefaultNumberHarvests
|
||||
gs.CurrentHarvests = gs.NumberHarvests
|
||||
|
||||
// Randomize heading if configured
|
||||
if gs.randomizeHeading {
|
||||
heading := int16(rand.Float32() * 360.0)
|
||||
gs.SetHeading(heading, heading)
|
||||
if gs.RandomizeHeading {
|
||||
gs.Heading = rand.Float32() * 360.0
|
||||
}
|
||||
|
||||
// Mark as alive
|
||||
gs.SetAlive(true)
|
||||
// Mark as alive and update times
|
||||
gs.IsAlive = true
|
||||
gs.NextRespawn = time.Time{} // Clear next respawn time
|
||||
}
|
||||
|
||||
// MeetsSpawnAccessRequirements checks if a player can access this ground spawn
|
||||
func (gs *GroundSpawn) MeetsSpawnAccessRequirements(player *Player) bool {
|
||||
// TODO: Implement proper access requirements checking
|
||||
// For now, allow all players to access ground spawns
|
||||
return player != nil
|
||||
// Private database helper methods
|
||||
|
||||
func (gs *GroundSpawn) insert() error {
|
||||
if gs.db.GetType() == database.SQLite {
|
||||
return gs.db.Execute(`
|
||||
INSERT INTO ground_spawns (
|
||||
groundspawn_id, name, collection_skill, number_harvests,
|
||||
attempts_per_harvest, randomize_heading, respawn_time,
|
||||
x, y, z, heading, zone_id, grid_id
|
||||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`, &sqlitex.ExecOptions{
|
||||
Args: []any{gs.GroundSpawnID, gs.Name, gs.CollectionSkill, gs.NumberHarvests,
|
||||
gs.AttemptsPerHarvest, gs.RandomizeHeading, gs.RespawnTime,
|
||||
gs.X, gs.Y, gs.Z, gs.Heading, gs.ZoneID, gs.GridID},
|
||||
})
|
||||
}
|
||||
|
||||
// MySQL
|
||||
_, err := gs.db.Exec(`
|
||||
INSERT INTO ground_spawns (
|
||||
groundspawn_id, name, collection_skill, number_harvests,
|
||||
attempts_per_harvest, randomize_heading, respawn_time,
|
||||
x, y, z, heading, zone_id, grid_id
|
||||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`, gs.GroundSpawnID, gs.Name, gs.CollectionSkill, gs.NumberHarvests,
|
||||
gs.AttemptsPerHarvest, gs.RandomizeHeading, gs.RespawnTime,
|
||||
gs.X, gs.Y, gs.Z, gs.Heading, gs.ZoneID, gs.GridID)
|
||||
|
||||
if err == nil {
|
||||
gs.isNew = false
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// HasCommandIcon returns true if this ground spawn has command interactions
|
||||
func (gs *GroundSpawn) HasCommandIcon() bool {
|
||||
// TODO: Implement command icon checking based on spawn configuration
|
||||
// For now, ground spawns don't have command icons (only harvest)
|
||||
return false
|
||||
func (gs *GroundSpawn) update() error {
|
||||
if gs.db.GetType() == database.SQLite {
|
||||
return gs.db.Execute(`
|
||||
UPDATE ground_spawns SET
|
||||
name = ?, collection_skill = ?, number_harvests = ?,
|
||||
attempts_per_harvest = ?, randomize_heading = ?, respawn_time = ?,
|
||||
x = ?, y = ?, z = ?, heading = ?, zone_id = ?, grid_id = ?
|
||||
WHERE groundspawn_id = ?
|
||||
`, &sqlitex.ExecOptions{
|
||||
Args: []any{gs.Name, gs.CollectionSkill, gs.NumberHarvests,
|
||||
gs.AttemptsPerHarvest, gs.RandomizeHeading, gs.RespawnTime,
|
||||
gs.X, gs.Y, gs.Z, gs.Heading, gs.ZoneID, gs.GridID, gs.GroundSpawnID},
|
||||
})
|
||||
}
|
||||
|
||||
// MySQL
|
||||
_, err := gs.db.Exec(`
|
||||
UPDATE ground_spawns SET
|
||||
name = ?, collection_skill = ?, number_harvests = ?,
|
||||
attempts_per_harvest = ?, randomize_heading = ?, respawn_time = ?,
|
||||
x = ?, y = ?, z = ?, heading = ?, zone_id = ?, grid_id = ?
|
||||
WHERE groundspawn_id = ?
|
||||
`, gs.Name, gs.CollectionSkill, gs.NumberHarvests,
|
||||
gs.AttemptsPerHarvest, gs.RandomizeHeading, gs.RespawnTime,
|
||||
gs.X, gs.Y, gs.Z, gs.Heading, gs.ZoneID, gs.GridID, gs.GroundSpawnID)
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (gs *GroundSpawn) loadHarvestData() error {
|
||||
// Load harvest entries
|
||||
if err := gs.loadHarvestEntries(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Load harvest items
|
||||
if err := gs.loadHarvestItems(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (gs *GroundSpawn) loadHarvestEntries() error {
|
||||
gs.HarvestEntries = make([]*HarvestEntry, 0)
|
||||
|
||||
if gs.db.GetType() == database.SQLite {
|
||||
return gs.db.ExecTransient(`
|
||||
SELECT groundspawn_id, min_skill_level, min_adventure_level, bonus_table,
|
||||
harvest1, harvest3, harvest5, harvest_imbue, harvest_rare, harvest10, harvest_coin
|
||||
FROM groundspawn_entries WHERE groundspawn_id = ?
|
||||
`, func(stmt *sqlite.Stmt) error {
|
||||
entry := &HarvestEntry{
|
||||
GroundSpawnID: stmt.ColumnInt32(0),
|
||||
MinSkillLevel: int16(stmt.ColumnInt32(1)),
|
||||
MinAdventureLevel: int16(stmt.ColumnInt32(2)),
|
||||
BonusTable: stmt.ColumnBool(3),
|
||||
Harvest1: float32(stmt.ColumnFloat(4)),
|
||||
Harvest3: float32(stmt.ColumnFloat(5)),
|
||||
Harvest5: float32(stmt.ColumnFloat(6)),
|
||||
HarvestImbue: float32(stmt.ColumnFloat(7)),
|
||||
HarvestRare: float32(stmt.ColumnFloat(8)),
|
||||
Harvest10: float32(stmt.ColumnFloat(9)),
|
||||
HarvestCoin: float32(stmt.ColumnFloat(10)),
|
||||
}
|
||||
gs.HarvestEntries = append(gs.HarvestEntries, entry)
|
||||
return nil
|
||||
}, gs.GroundSpawnID)
|
||||
} else {
|
||||
// MySQL implementation
|
||||
rows, err := gs.db.Query(`
|
||||
SELECT groundspawn_id, min_skill_level, min_adventure_level, bonus_table,
|
||||
harvest1, harvest3, harvest5, harvest_imbue, harvest_rare, harvest10, harvest_coin
|
||||
FROM groundspawn_entries WHERE groundspawn_id = ?
|
||||
`, gs.GroundSpawnID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
entry := &HarvestEntry{}
|
||||
err := rows.Scan(&entry.GroundSpawnID, &entry.MinSkillLevel, &entry.MinAdventureLevel,
|
||||
&entry.BonusTable, &entry.Harvest1, &entry.Harvest3, &entry.Harvest5,
|
||||
&entry.HarvestImbue, &entry.HarvestRare, &entry.Harvest10, &entry.HarvestCoin)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
gs.HarvestEntries = append(gs.HarvestEntries, entry)
|
||||
}
|
||||
return rows.Err()
|
||||
}
|
||||
}
|
||||
|
||||
func (gs *GroundSpawn) loadHarvestItems() error {
|
||||
gs.HarvestItems = make([]*HarvestEntryItem, 0)
|
||||
|
||||
if gs.db.GetType() == database.SQLite {
|
||||
return gs.db.ExecTransient(`
|
||||
SELECT groundspawn_id, item_id, is_rare, grid_id, quantity
|
||||
FROM groundspawn_items WHERE groundspawn_id = ?
|
||||
`, func(stmt *sqlite.Stmt) error {
|
||||
item := &HarvestEntryItem{
|
||||
GroundSpawnID: stmt.ColumnInt32(0),
|
||||
ItemID: stmt.ColumnInt32(1),
|
||||
IsRare: int8(stmt.ColumnInt32(2)),
|
||||
GridID: stmt.ColumnInt32(3),
|
||||
Quantity: int16(stmt.ColumnInt32(4)),
|
||||
}
|
||||
gs.HarvestItems = append(gs.HarvestItems, item)
|
||||
return nil
|
||||
}, gs.GroundSpawnID)
|
||||
} else {
|
||||
// MySQL implementation
|
||||
rows, err := gs.db.Query(`
|
||||
SELECT groundspawn_id, item_id, is_rare, grid_id, quantity
|
||||
FROM groundspawn_items WHERE groundspawn_id = ?
|
||||
`, gs.GroundSpawnID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
item := &HarvestEntryItem{}
|
||||
err := rows.Scan(&item.GroundSpawnID, &item.ItemID, &item.IsRare, &item.GridID, &item.Quantity)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
gs.HarvestItems = append(gs.HarvestItems, item)
|
||||
}
|
||||
return rows.Err()
|
||||
}
|
||||
}
|
||||
|
||||
184
internal/ground_spawn/ground_spawn_test.go
Normal file
184
internal/ground_spawn/ground_spawn_test.go
Normal file
@ -0,0 +1,184 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"eq2emu/internal/database"
|
||||
)
|
||||
|
||||
func TestNew(t *testing.T) {
|
||||
// Test creating a new ground spawn
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
gs := New(db)
|
||||
if gs == nil {
|
||||
t.Fatal("Expected non-nil ground spawn")
|
||||
}
|
||||
|
||||
if gs.db != db {
|
||||
t.Error("Database connection not set correctly")
|
||||
}
|
||||
|
||||
if !gs.isNew {
|
||||
t.Error("New ground spawn should be marked as new")
|
||||
}
|
||||
|
||||
if !gs.IsAlive {
|
||||
t.Error("New ground spawn should be alive")
|
||||
}
|
||||
|
||||
if gs.RandomizeHeading != true {
|
||||
t.Error("Default RandomizeHeading should be true")
|
||||
}
|
||||
}
|
||||
|
||||
func TestGroundSpawnGetID(t *testing.T) {
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
gs := New(db)
|
||||
gs.GroundSpawnID = 12345
|
||||
|
||||
if gs.GetID() != 12345 {
|
||||
t.Errorf("Expected GetID() to return 12345, got %d", gs.GetID())
|
||||
}
|
||||
}
|
||||
|
||||
func TestGroundSpawnState(t *testing.T) {
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
gs := New(db)
|
||||
gs.NumberHarvests = 5
|
||||
gs.CurrentHarvests = 3
|
||||
|
||||
if gs.IsDepleted() {
|
||||
t.Error("Ground spawn with harvests should not be depleted")
|
||||
}
|
||||
|
||||
if !gs.IsAvailable() {
|
||||
t.Error("Ground spawn with harvests should be available")
|
||||
}
|
||||
|
||||
gs.CurrentHarvests = 0
|
||||
if !gs.IsDepleted() {
|
||||
t.Error("Ground spawn with no harvests should be depleted")
|
||||
}
|
||||
|
||||
if gs.IsAvailable() {
|
||||
t.Error("Depleted ground spawn should not be available")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHarvestMessageName(t *testing.T) {
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
testCases := []struct {
|
||||
skill string
|
||||
presentTense bool
|
||||
failure bool
|
||||
expectedVerb string
|
||||
}{
|
||||
{"Mining", true, false, "mine"},
|
||||
{"Mining", false, false, "mined"},
|
||||
{"Gathering", true, false, "gather"},
|
||||
{"Gathering", false, false, "gathered"},
|
||||
{"Fishing", true, false, "fish"},
|
||||
{"Fishing", false, false, "fished"},
|
||||
{"Unknown", true, false, "collect"},
|
||||
{"Unknown", false, false, "collected"},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
gs := New(db)
|
||||
gs.CollectionSkill = tc.skill
|
||||
|
||||
result := gs.GetHarvestMessageName(tc.presentTense, tc.failure)
|
||||
if result != tc.expectedVerb {
|
||||
t.Errorf("For skill %s (present=%v, failure=%v), expected %s, got %s",
|
||||
tc.skill, tc.presentTense, tc.failure, tc.expectedVerb, result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewMasterList(t *testing.T) {
|
||||
ml := NewMasterList()
|
||||
if ml == nil {
|
||||
t.Fatal("Expected non-nil master list")
|
||||
}
|
||||
|
||||
if ml.MasterList.Size() != 0 {
|
||||
t.Error("New master list should be empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMasterListOperations(t *testing.T) {
|
||||
db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to create test database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
ml := NewMasterList()
|
||||
|
||||
// Create test ground spawn
|
||||
gs := New(db)
|
||||
gs.GroundSpawnID = 1001
|
||||
gs.Name = "Test Node"
|
||||
gs.CollectionSkill = "Mining"
|
||||
gs.ZoneID = 1
|
||||
gs.CurrentHarvests = 5
|
||||
|
||||
// Test add
|
||||
if !ml.AddGroundSpawn(gs) {
|
||||
t.Error("Should be able to add new ground spawn")
|
||||
}
|
||||
|
||||
// Test get
|
||||
retrieved := ml.GetGroundSpawn(1001)
|
||||
if retrieved == nil {
|
||||
t.Fatal("Should be able to retrieve added ground spawn")
|
||||
}
|
||||
|
||||
if retrieved.Name != "Test Node" {
|
||||
t.Errorf("Expected name 'Test Node', got '%s'", retrieved.Name)
|
||||
}
|
||||
|
||||
// Test zone filter
|
||||
zoneSpawns := ml.GetByZone(1)
|
||||
if len(zoneSpawns) != 1 {
|
||||
t.Errorf("Expected 1 spawn in zone 1, got %d", len(zoneSpawns))
|
||||
}
|
||||
|
||||
// Test skill filter
|
||||
miningSpawns := ml.GetBySkill("Mining")
|
||||
if len(miningSpawns) != 1 {
|
||||
t.Errorf("Expected 1 mining spawn, got %d", len(miningSpawns))
|
||||
}
|
||||
|
||||
// Test available spawns
|
||||
available := ml.GetAvailableSpawns()
|
||||
if len(available) != 1 {
|
||||
t.Errorf("Expected 1 available spawn, got %d", len(available))
|
||||
}
|
||||
|
||||
// Test depleted spawns (should be none)
|
||||
depleted := ml.GetDepletedSpawns()
|
||||
if len(depleted) != 0 {
|
||||
t.Errorf("Expected 0 depleted spawns, got %d", len(depleted))
|
||||
}
|
||||
}
|
||||
@ -1,260 +0,0 @@
|
||||
package ground_spawn
|
||||
|
||||
// Database interface for ground spawn persistence
|
||||
type Database interface {
|
||||
LoadGroundSpawnEntries(groundspawnID int32) ([]*GroundSpawnEntry, error)
|
||||
LoadGroundSpawnItems(groundspawnID int32) ([]*GroundSpawnEntryItem, error)
|
||||
SaveGroundSpawn(gs *GroundSpawn) error
|
||||
LoadAllGroundSpawns() ([]*GroundSpawn, error)
|
||||
DeleteGroundSpawn(id int32) error
|
||||
}
|
||||
|
||||
// Logger interface for ground spawn logging
|
||||
type Logger interface {
|
||||
LogInfo(message string, args ...any)
|
||||
LogError(message string, args ...any)
|
||||
LogDebug(message string, args ...any)
|
||||
LogWarning(message string, args ...any)
|
||||
}
|
||||
|
||||
// Player interface for ground spawn interactions
|
||||
type Player interface {
|
||||
GetID() int32
|
||||
GetName() string
|
||||
GetLevel() int16
|
||||
GetLocation() int32
|
||||
GetSkillByName(skillName string) *Skill
|
||||
CheckQuestsHarvestUpdate(item *Item, quantity int16)
|
||||
UpdatePlayerStatistic(statType int32, amount int32)
|
||||
SendMessage(message string)
|
||||
}
|
||||
|
||||
// Client interface for client communication
|
||||
type Client interface {
|
||||
GetPlayer() *Player
|
||||
GetVersion() int16
|
||||
GetLogger() Logger
|
||||
GetCurrentZoneID() int32
|
||||
Message(channel int32, message string, args ...any)
|
||||
SimpleMessage(channel int32, message string)
|
||||
SendPopupMessage(type_ int32, message string, sound string, duration float32, r, g, b int32)
|
||||
AddItem(item *Item, itemDeleted *bool) error
|
||||
}
|
||||
|
||||
// Skill interface for skill management
|
||||
type Skill interface {
|
||||
GetCurrentValue() int16
|
||||
GetMaxValue() int16
|
||||
GetName() string
|
||||
IncreaseSkill(amount int16) bool
|
||||
}
|
||||
|
||||
// Item interface for harvest rewards
|
||||
type Item interface {
|
||||
GetID() int32
|
||||
GetName() string
|
||||
GetCount() int16
|
||||
SetCount(count int16)
|
||||
CreateItemLink(version int16, color bool) string
|
||||
}
|
||||
|
||||
// Zone interface for zone-specific operations
|
||||
type Zone interface {
|
||||
GetID() int32
|
||||
GetGroundSpawnEntries(groundspawnID int32) []*GroundSpawnEntry
|
||||
GetGroundSpawnEntryItems(groundspawnID int32) []*GroundSpawnEntryItem
|
||||
ProcessSpell(spell *Spell, caster *Player, target *Player, harvest bool, fromItem bool)
|
||||
ProcessEntityCommand(command *EntityCommand, player *Player, target *Player)
|
||||
}
|
||||
|
||||
// Spell interface for harvest spells
|
||||
type Spell interface {
|
||||
GetID() int32
|
||||
GetName() string
|
||||
GetType() string
|
||||
}
|
||||
|
||||
// EntityCommand interface for ground spawn commands
|
||||
type EntityCommand interface {
|
||||
GetID() int32
|
||||
GetName() string
|
||||
GetCommand() string
|
||||
}
|
||||
|
||||
// Rules interface for game rules and configuration
|
||||
type Rules interface {
|
||||
GetZoneRule(zoneID int32, category string, ruleName string) *Rule
|
||||
}
|
||||
|
||||
// Rule interface for individual rule values
|
||||
type Rule interface {
|
||||
GetInt16() int16
|
||||
GetFloat() float32
|
||||
GetBool() bool
|
||||
GetString() string
|
||||
}
|
||||
|
||||
// GroundSpawnProvider interface for systems that provide ground spawn functionality
|
||||
type GroundSpawnProvider interface {
|
||||
GetGroundSpawn(id int32) *GroundSpawn
|
||||
CreateGroundSpawn(config GroundSpawnConfig) *GroundSpawn
|
||||
GetGroundSpawnsByZone(zoneID int32) []*GroundSpawn
|
||||
ProcessHarvest(gs *GroundSpawn, player *Player) (*HarvestResult, error)
|
||||
}
|
||||
|
||||
// HarvestHandler interface for handling harvest events
|
||||
type HarvestHandler interface {
|
||||
OnHarvestStart(gs *GroundSpawn, player *Player) error
|
||||
OnHarvestComplete(gs *GroundSpawn, player *Player, result *HarvestResult) error
|
||||
OnHarvestFailed(gs *GroundSpawn, player *Player, reason string) error
|
||||
OnGroundSpawnDepleted(gs *GroundSpawn) error
|
||||
}
|
||||
|
||||
// ItemProvider interface for item creation and management
|
||||
type ItemProvider interface {
|
||||
GetItem(itemID int32) *Item
|
||||
CreateItem(itemID int32, quantity int16) *Item
|
||||
GetItemName(itemID int32) string
|
||||
}
|
||||
|
||||
// SkillProvider interface for skill management
|
||||
type SkillProvider interface {
|
||||
GetPlayerSkill(player *Player, skillName string) *Skill
|
||||
GetSkillIDByName(skillName string) int32
|
||||
IncreasePlayerSkill(player *Player, skillName string, amount int16) bool
|
||||
}
|
||||
|
||||
// SpawnProvider interface for spawn system integration
|
||||
type SpawnProvider interface {
|
||||
CreateSpawn() any
|
||||
GetSpawn(id int32) any
|
||||
RegisterGroundSpawn(gs *GroundSpawn) error
|
||||
UnregisterGroundSpawn(id int32) error
|
||||
}
|
||||
|
||||
// GroundSpawnAware interface for entities that can interact with ground spawns
|
||||
type GroundSpawnAware interface {
|
||||
CanHarvest(gs *GroundSpawn) bool
|
||||
GetHarvestSkill(skillName string) *Skill
|
||||
GetHarvestModifiers() *HarvestModifiers
|
||||
OnHarvestResult(result *HarvestResult)
|
||||
}
|
||||
|
||||
// PlayerGroundSpawnAdapter provides ground spawn functionality for players
|
||||
type PlayerGroundSpawnAdapter struct {
|
||||
player *Player
|
||||
manager *Manager
|
||||
logger Logger
|
||||
}
|
||||
|
||||
// NewPlayerGroundSpawnAdapter creates a new player ground spawn adapter
|
||||
func NewPlayerGroundSpawnAdapter(player *Player, manager *Manager, logger Logger) *PlayerGroundSpawnAdapter {
|
||||
return &PlayerGroundSpawnAdapter{
|
||||
player: player,
|
||||
manager: manager,
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// CanHarvest returns true if the player can harvest the ground spawn
|
||||
func (pgsa *PlayerGroundSpawnAdapter) CanHarvest(gs *GroundSpawn) bool {
|
||||
if gs == nil || pgsa.player == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check if ground spawn is available
|
||||
if !gs.IsAvailable() {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check if player has required skill
|
||||
skill := (*pgsa.player).GetSkillByName(gs.GetCollectionSkill())
|
||||
if skill == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
// TODO: Add additional checks (quest requirements, level, etc.)
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// GetHarvestSkill returns the player's skill for a specific harvest type
|
||||
func (pgsa *PlayerGroundSpawnAdapter) GetHarvestSkill(skillName string) *Skill {
|
||||
if pgsa.player == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return (*pgsa.player).GetSkillByName(skillName)
|
||||
}
|
||||
|
||||
// GetHarvestModifiers returns harvest modifiers for the player
|
||||
func (pgsa *PlayerGroundSpawnAdapter) GetHarvestModifiers() *HarvestModifiers {
|
||||
// TODO: Calculate modifiers based on player stats, equipment, buffs, etc.
|
||||
return &HarvestModifiers{
|
||||
SkillMultiplier: 1.0,
|
||||
RareChanceBonus: 0.0,
|
||||
QuantityMultiplier: 1.0,
|
||||
LuckModifier: 0,
|
||||
}
|
||||
}
|
||||
|
||||
// OnHarvestResult handles harvest result notifications
|
||||
func (pgsa *PlayerGroundSpawnAdapter) OnHarvestResult(result *HarvestResult) {
|
||||
if result == nil || pgsa.player == nil {
|
||||
return
|
||||
}
|
||||
|
||||
if result.Success && len(result.ItemsAwarded) > 0 {
|
||||
if pgsa.logger != nil {
|
||||
pgsa.logger.LogDebug("Player %s successfully harvested %d items",
|
||||
(*pgsa.player).GetName(), len(result.ItemsAwarded))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// HarvestEventAdapter adapts harvest events for different systems
|
||||
type HarvestEventAdapter struct {
|
||||
handler HarvestHandler
|
||||
logger Logger
|
||||
}
|
||||
|
||||
// NewHarvestEventAdapter creates a new harvest event adapter
|
||||
func NewHarvestEventAdapter(handler HarvestHandler, logger Logger) *HarvestEventAdapter {
|
||||
return &HarvestEventAdapter{
|
||||
handler: handler,
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// ProcessHarvestEvent processes a harvest event
|
||||
func (hea *HarvestEventAdapter) ProcessHarvestEvent(eventType string, gs *GroundSpawn, player *Player, data any) {
|
||||
if hea.handler == nil {
|
||||
return
|
||||
}
|
||||
|
||||
switch eventType {
|
||||
case "harvest_start":
|
||||
if err := hea.handler.OnHarvestStart(gs, player); err != nil && hea.logger != nil {
|
||||
hea.logger.LogError("Harvest start handler failed: %v", err)
|
||||
}
|
||||
|
||||
case "harvest_complete":
|
||||
if result, ok := data.(*HarvestResult); ok {
|
||||
if err := hea.handler.OnHarvestComplete(gs, player, result); err != nil && hea.logger != nil {
|
||||
hea.logger.LogError("Harvest complete handler failed: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
case "harvest_failed":
|
||||
if reason, ok := data.(string); ok {
|
||||
if err := hea.handler.OnHarvestFailed(gs, player, reason); err != nil && hea.logger != nil {
|
||||
hea.logger.LogError("Harvest failed handler failed: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
case "ground_spawn_depleted":
|
||||
if err := hea.handler.OnGroundSpawnDepleted(gs); err != nil && hea.logger != nil {
|
||||
hea.logger.LogError("Ground spawn depleted handler failed: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,652 +0,0 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// NewManager creates a new ground spawn manager
|
||||
func NewManager(database Database, logger Logger) *Manager {
|
||||
return &Manager{
|
||||
groundSpawns: make(map[int32]*GroundSpawn),
|
||||
spawnsByZone: make(map[int32][]*GroundSpawn),
|
||||
entriesByID: make(map[int32][]*GroundSpawnEntry),
|
||||
itemsByID: make(map[int32][]*GroundSpawnEntryItem),
|
||||
respawnQueue: make(map[int32]time.Time),
|
||||
activeSpawns: make(map[int32]*GroundSpawn),
|
||||
depletedSpawns: make(map[int32]*GroundSpawn),
|
||||
database: database,
|
||||
logger: logger,
|
||||
nextSpawnID: 1,
|
||||
harvestsBySkill: make(map[string]int64),
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize loads ground spawn data from database
|
||||
func (m *Manager) Initialize() error {
|
||||
if m.logger != nil {
|
||||
m.logger.LogInfo("Initializing ground spawn manager...")
|
||||
}
|
||||
|
||||
if m.database == nil {
|
||||
if m.logger != nil {
|
||||
m.logger.LogWarning("No database provided, starting with empty ground spawn list")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Load ground spawns from database
|
||||
groundSpawns, err := m.database.LoadAllGroundSpawns()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to load ground spawns from database: %w", err)
|
||||
}
|
||||
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
var maxID int32
|
||||
for _, gs := range groundSpawns {
|
||||
spawnID := gs.GetID()
|
||||
m.groundSpawns[spawnID] = gs
|
||||
|
||||
// Track max ID for nextSpawnID initialization
|
||||
if spawnID > maxID {
|
||||
maxID = spawnID
|
||||
}
|
||||
|
||||
// Populate active/depleted caches based on current state
|
||||
if gs.IsAvailable() {
|
||||
m.activeSpawns[spawnID] = gs
|
||||
} else if gs.IsDepleted() {
|
||||
m.depletedSpawns[spawnID] = gs
|
||||
}
|
||||
|
||||
// Group by zone (placeholder - zone ID would come from spawn location)
|
||||
zoneID := int32(1) // TODO: Get actual zone ID from spawn
|
||||
m.spawnsByZone[zoneID] = append(m.spawnsByZone[zoneID], gs)
|
||||
|
||||
// Load harvest entries and items
|
||||
if err := m.loadGroundSpawnData(gs); err != nil && m.logger != nil {
|
||||
m.logger.LogWarning("Failed to load data for ground spawn %d: %v", spawnID, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Set nextSpawnID to avoid collisions
|
||||
m.nextSpawnID = maxID + 1
|
||||
|
||||
if m.logger != nil {
|
||||
m.logger.LogInfo("Loaded %d ground spawns from database", len(groundSpawns))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// loadGroundSpawnData loads entries and items for a ground spawn
|
||||
func (m *Manager) loadGroundSpawnData(gs *GroundSpawn) error {
|
||||
groundspawnID := gs.GetGroundSpawnEntryID()
|
||||
|
||||
// Load harvest entries
|
||||
entries, err := m.database.LoadGroundSpawnEntries(groundspawnID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to load entries for groundspawn %d: %w", groundspawnID, err)
|
||||
}
|
||||
m.entriesByID[groundspawnID] = entries
|
||||
|
||||
// Load harvest items
|
||||
items, err := m.database.LoadGroundSpawnItems(groundspawnID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to load items for groundspawn %d: %w", groundspawnID, err)
|
||||
}
|
||||
m.itemsByID[groundspawnID] = items
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateGroundSpawn creates a new ground spawn
|
||||
func (m *Manager) CreateGroundSpawn(config GroundSpawnConfig) *GroundSpawn {
|
||||
gs := NewGroundSpawn(config)
|
||||
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
// Use efficient ID counter instead of len()
|
||||
newID := m.nextSpawnID
|
||||
m.nextSpawnID++
|
||||
gs.SetID(newID)
|
||||
|
||||
// Store ground spawn
|
||||
m.groundSpawns[newID] = gs
|
||||
|
||||
// Add to active cache (new spawns are typically active)
|
||||
if gs.IsAvailable() {
|
||||
m.activeSpawns[newID] = gs
|
||||
}
|
||||
|
||||
// Group by zone - pre-allocate zone slice if needed
|
||||
zoneID := int32(1) // TODO: Get actual zone ID from config.Location
|
||||
if m.spawnsByZone[zoneID] == nil {
|
||||
m.spawnsByZone[zoneID] = make([]*GroundSpawn, 0, 16) // Pre-allocate with reasonable capacity
|
||||
}
|
||||
m.spawnsByZone[zoneID] = append(m.spawnsByZone[zoneID], gs)
|
||||
|
||||
if m.logger != nil {
|
||||
m.logger.LogInfo("Created ground spawn %d: %s", newID, gs.GetName())
|
||||
}
|
||||
|
||||
return gs
|
||||
}
|
||||
|
||||
// GetGroundSpawn returns a ground spawn by ID
|
||||
func (m *Manager) GetGroundSpawn(id int32) *GroundSpawn {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
return m.groundSpawns[id]
|
||||
}
|
||||
|
||||
// GetGroundSpawnsByZone returns all ground spawns in a zone
|
||||
func (m *Manager) GetGroundSpawnsByZone(zoneID int32) []*GroundSpawn {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
spawns := m.spawnsByZone[zoneID]
|
||||
if len(spawns) == 0 {
|
||||
return []*GroundSpawn{}
|
||||
}
|
||||
|
||||
// Return a copy to prevent external modification - use append for better performance
|
||||
result := make([]*GroundSpawn, 0, len(spawns))
|
||||
result = append(result, spawns...)
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
// ProcessHarvest handles harvesting for a player
|
||||
func (m *Manager) ProcessHarvest(gs *GroundSpawn, player *Player) (*HarvestResult, error) {
|
||||
if gs == nil {
|
||||
return nil, fmt.Errorf("ground spawn cannot be nil")
|
||||
}
|
||||
|
||||
if player == nil {
|
||||
return nil, fmt.Errorf("player cannot be nil")
|
||||
}
|
||||
|
||||
// Record statistics
|
||||
m.mutex.Lock()
|
||||
m.totalHarvests++
|
||||
skill := gs.GetCollectionSkill()
|
||||
m.harvestsBySkill[skill]++
|
||||
m.mutex.Unlock()
|
||||
|
||||
// Build harvest context
|
||||
context, err := m.buildHarvestContext(gs, player)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to build harvest context: %w", err)
|
||||
}
|
||||
|
||||
// Process the harvest
|
||||
result, err := gs.ProcessHarvest(context)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("harvest processing failed: %w", err)
|
||||
}
|
||||
|
||||
// Update statistics
|
||||
if result != nil && result.Success {
|
||||
m.mutex.Lock()
|
||||
m.successfulHarvests++
|
||||
|
||||
// Count rare items
|
||||
for _, item := range result.ItemsAwarded {
|
||||
if item.IsRare {
|
||||
m.rareItemsHarvested++
|
||||
}
|
||||
}
|
||||
|
||||
if result.SkillGained {
|
||||
m.skillUpsGenerated++
|
||||
}
|
||||
m.mutex.Unlock()
|
||||
}
|
||||
|
||||
// Handle respawn if depleted and update cache
|
||||
if gs.IsDepleted() {
|
||||
m.mutex.Lock()
|
||||
m.updateSpawnStateCache(gs)
|
||||
m.mutex.Unlock()
|
||||
m.scheduleRespawn(gs)
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// buildHarvestContext creates a harvest context for processing
|
||||
func (m *Manager) buildHarvestContext(gs *GroundSpawn, player *Player) (*HarvestContext, error) {
|
||||
groundspawnID := gs.GetGroundSpawnEntryID()
|
||||
|
||||
m.mutex.RLock()
|
||||
entries := m.entriesByID[groundspawnID]
|
||||
items := m.itemsByID[groundspawnID]
|
||||
m.mutex.RUnlock()
|
||||
|
||||
if len(entries) == 0 {
|
||||
return nil, fmt.Errorf("no harvest entries found for groundspawn %d", groundspawnID)
|
||||
}
|
||||
|
||||
if len(items) == 0 {
|
||||
return nil, fmt.Errorf("no harvest items found for groundspawn %d", groundspawnID)
|
||||
}
|
||||
|
||||
// Get player skill
|
||||
skillName := gs.GetCollectionSkill()
|
||||
if skillName == SkillCollecting {
|
||||
skillName = SkillGathering // Collections use gathering skill
|
||||
}
|
||||
|
||||
playerSkill := (*player).GetSkillByName(skillName)
|
||||
if playerSkill == nil {
|
||||
return nil, fmt.Errorf("player lacks required skill: %s", skillName)
|
||||
}
|
||||
|
||||
// Calculate total skill (base + bonuses)
|
||||
totalSkill := (*playerSkill).GetCurrentValue()
|
||||
// TODO: Add stat bonuses when stat system is integrated
|
||||
|
||||
// Find max skill required
|
||||
var maxSkillRequired int16
|
||||
for _, entry := range entries {
|
||||
if entry.MinSkillLevel > maxSkillRequired {
|
||||
maxSkillRequired = entry.MinSkillLevel
|
||||
}
|
||||
}
|
||||
|
||||
return &HarvestContext{
|
||||
Player: player,
|
||||
GroundSpawn: gs,
|
||||
PlayerSkill: playerSkill,
|
||||
TotalSkill: totalSkill,
|
||||
GroundSpawnEntries: entries,
|
||||
GroundSpawnItems: items,
|
||||
IsCollection: gs.GetCollectionSkill() == SkillCollecting,
|
||||
MaxSkillRequired: maxSkillRequired,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// scheduleRespawn schedules a ground spawn for respawn
|
||||
func (m *Manager) scheduleRespawn(gs *GroundSpawn) {
|
||||
if gs == nil {
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: Get respawn timer from configuration or database
|
||||
respawnDelay := 5 * time.Minute // Default 5 minutes
|
||||
respawnTime := time.Now().Add(respawnDelay)
|
||||
|
||||
m.mutex.Lock()
|
||||
m.respawnQueue[gs.GetID()] = respawnTime
|
||||
m.mutex.Unlock()
|
||||
|
||||
if m.logger != nil {
|
||||
m.logger.LogDebug("Scheduled ground spawn %d for respawn at %v", gs.GetID(), respawnTime)
|
||||
}
|
||||
}
|
||||
|
||||
// ProcessRespawns handles ground spawn respawning
|
||||
func (m *Manager) ProcessRespawns() {
|
||||
now := time.Now()
|
||||
var toRespawn []int32
|
||||
|
||||
m.mutex.Lock()
|
||||
for spawnID, respawnTime := range m.respawnQueue {
|
||||
if now.After(respawnTime) {
|
||||
toRespawn = append(toRespawn, spawnID)
|
||||
delete(m.respawnQueue, spawnID)
|
||||
}
|
||||
}
|
||||
m.mutex.Unlock()
|
||||
|
||||
// Respawn outside of lock
|
||||
for _, spawnID := range toRespawn {
|
||||
if gs := m.GetGroundSpawn(spawnID); gs != nil {
|
||||
gs.Respawn()
|
||||
|
||||
// Update cache after respawn
|
||||
m.mutex.Lock()
|
||||
m.updateSpawnStateCache(gs)
|
||||
m.mutex.Unlock()
|
||||
|
||||
if m.logger != nil {
|
||||
m.logger.LogDebug("Ground spawn %d respawned", spawnID)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// GetStatistics returns ground spawn system statistics
|
||||
func (m *Manager) GetStatistics() *HarvestStatistics {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
// Count spawns by zone
|
||||
spawnsByZone := make(map[int32]int)
|
||||
for zoneID, spawns := range m.spawnsByZone {
|
||||
spawnsByZone[zoneID] = len(spawns)
|
||||
}
|
||||
|
||||
// Copy harvests by skill
|
||||
harvestsBySkill := make(map[string]int64)
|
||||
for skill, count := range m.harvestsBySkill {
|
||||
harvestsBySkill[skill] = count
|
||||
}
|
||||
|
||||
return &HarvestStatistics{
|
||||
TotalHarvests: m.totalHarvests,
|
||||
SuccessfulHarvests: m.successfulHarvests,
|
||||
RareItemsHarvested: m.rareItemsHarvested,
|
||||
SkillUpsGenerated: m.skillUpsGenerated,
|
||||
HarvestsBySkill: harvestsBySkill,
|
||||
ActiveGroundSpawns: len(m.groundSpawns),
|
||||
GroundSpawnsByZone: spawnsByZone,
|
||||
}
|
||||
}
|
||||
|
||||
// ResetStatistics resets all statistics
|
||||
func (m *Manager) ResetStatistics() {
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
m.totalHarvests = 0
|
||||
m.successfulHarvests = 0
|
||||
m.rareItemsHarvested = 0
|
||||
m.skillUpsGenerated = 0
|
||||
m.harvestsBySkill = make(map[string]int64)
|
||||
}
|
||||
|
||||
// AddGroundSpawn adds a ground spawn to the manager
|
||||
func (m *Manager) AddGroundSpawn(gs *GroundSpawn) error {
|
||||
if gs == nil {
|
||||
return fmt.Errorf("ground spawn cannot be nil")
|
||||
}
|
||||
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
// Check if ID is already used
|
||||
if _, exists := m.groundSpawns[gs.GetID()]; exists {
|
||||
return fmt.Errorf("ground spawn with ID %d already exists", gs.GetID())
|
||||
}
|
||||
|
||||
m.groundSpawns[gs.GetID()] = gs
|
||||
|
||||
// Group by zone (placeholder)
|
||||
zoneID := int32(1) // TODO: Get actual zone ID
|
||||
m.spawnsByZone[zoneID] = append(m.spawnsByZone[zoneID], gs)
|
||||
|
||||
// Load harvest data if database is available
|
||||
if m.database != nil {
|
||||
if err := m.loadGroundSpawnData(gs); err != nil && m.logger != nil {
|
||||
m.logger.LogWarning("Failed to load data for ground spawn %d: %v", gs.GetID(), err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// RemoveGroundSpawn removes a ground spawn from the manager
|
||||
func (m *Manager) RemoveGroundSpawn(id int32) bool {
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
gs, exists := m.groundSpawns[id]
|
||||
if !exists {
|
||||
return false
|
||||
}
|
||||
|
||||
delete(m.groundSpawns, id)
|
||||
delete(m.respawnQueue, id)
|
||||
delete(m.activeSpawns, id)
|
||||
delete(m.depletedSpawns, id)
|
||||
|
||||
// Remove from zone list
|
||||
// TODO: Get actual zone ID from ground spawn
|
||||
zoneID := int32(1)
|
||||
if spawns, exists := m.spawnsByZone[zoneID]; exists {
|
||||
for i, spawn := range spawns {
|
||||
if spawn.GetID() == id {
|
||||
m.spawnsByZone[zoneID] = append(spawns[:i], spawns[i+1:]...)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Clean up harvest data
|
||||
if gs != nil {
|
||||
groundspawnID := gs.GetGroundSpawnEntryID()
|
||||
delete(m.entriesByID, groundspawnID)
|
||||
delete(m.itemsByID, groundspawnID)
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// GetGroundSpawnCount returns the total number of ground spawns
|
||||
func (m *Manager) GetGroundSpawnCount() int {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
return len(m.groundSpawns)
|
||||
}
|
||||
|
||||
// GetActiveGroundSpawns returns all active (harvestable) ground spawns
|
||||
func (m *Manager) GetActiveGroundSpawns() []*GroundSpawn {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
// Use cached active spawns for O(1) performance instead of O(N) iteration
|
||||
active := make([]*GroundSpawn, 0, len(m.activeSpawns))
|
||||
for _, gs := range m.activeSpawns {
|
||||
active = append(active, gs)
|
||||
}
|
||||
|
||||
return active
|
||||
}
|
||||
|
||||
// GetDepletedGroundSpawns returns all depleted ground spawns
|
||||
func (m *Manager) GetDepletedGroundSpawns() []*GroundSpawn {
|
||||
m.mutex.RLock()
|
||||
defer m.mutex.RUnlock()
|
||||
|
||||
// Use cached depleted spawns for O(1) performance instead of O(N) iteration
|
||||
depleted := make([]*GroundSpawn, 0, len(m.depletedSpawns))
|
||||
for _, gs := range m.depletedSpawns {
|
||||
depleted = append(depleted, gs)
|
||||
}
|
||||
|
||||
return depleted
|
||||
}
|
||||
|
||||
// updateSpawnStateCache updates the active/depleted caches when a spawn's state changes
|
||||
// IMPORTANT: This method must be called while holding the manager's mutex
|
||||
func (m *Manager) updateSpawnStateCache(gs *GroundSpawn) {
|
||||
spawnID := gs.GetID()
|
||||
|
||||
// Remove from both caches first
|
||||
delete(m.activeSpawns, spawnID)
|
||||
delete(m.depletedSpawns, spawnID)
|
||||
|
||||
// Add to appropriate cache based on current state
|
||||
if gs.IsAvailable() {
|
||||
m.activeSpawns[spawnID] = gs
|
||||
} else if gs.IsDepleted() {
|
||||
m.depletedSpawns[spawnID] = gs
|
||||
}
|
||||
}
|
||||
|
||||
// ProcessCommand handles ground spawn management commands
|
||||
func (m *Manager) ProcessCommand(command string, args []string) (string, error) {
|
||||
switch command {
|
||||
case "stats":
|
||||
return m.handleStatsCommand(args)
|
||||
case "list":
|
||||
return m.handleListCommand(args)
|
||||
case "respawn":
|
||||
return m.handleRespawnCommand(args)
|
||||
case "info":
|
||||
return m.handleInfoCommand(args)
|
||||
case "reload":
|
||||
return m.handleReloadCommand(args)
|
||||
default:
|
||||
return "", fmt.Errorf("unknown ground spawn command: %s", command)
|
||||
}
|
||||
}
|
||||
|
||||
// handleStatsCommand shows ground spawn system statistics
|
||||
func (m *Manager) handleStatsCommand(args []string) (string, error) {
|
||||
stats := m.GetStatistics()
|
||||
|
||||
result := "Ground Spawn System Statistics:\n"
|
||||
result += fmt.Sprintf("Total Harvests: %d\n", stats.TotalHarvests)
|
||||
result += fmt.Sprintf("Successful Harvests: %d\n", stats.SuccessfulHarvests)
|
||||
result += fmt.Sprintf("Rare Items Harvested: %d\n", stats.RareItemsHarvested)
|
||||
result += fmt.Sprintf("Skill Ups Generated: %d\n", stats.SkillUpsGenerated)
|
||||
result += fmt.Sprintf("Active Ground Spawns: %d\n", stats.ActiveGroundSpawns)
|
||||
|
||||
if len(stats.HarvestsBySkill) > 0 {
|
||||
result += "\nHarvests by Skill:\n"
|
||||
for skill, count := range stats.HarvestsBySkill {
|
||||
result += fmt.Sprintf(" %s: %d\n", skill, count)
|
||||
}
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// handleListCommand lists ground spawns
|
||||
func (m *Manager) handleListCommand(args []string) (string, error) {
|
||||
count := m.GetGroundSpawnCount()
|
||||
if count == 0 {
|
||||
return "No ground spawns loaded.", nil
|
||||
}
|
||||
|
||||
active := m.GetActiveGroundSpawns()
|
||||
depleted := m.GetDepletedGroundSpawns()
|
||||
|
||||
result := fmt.Sprintf("Ground Spawns (Total: %d, Active: %d, Depleted: %d):\n",
|
||||
count, len(active), len(depleted))
|
||||
|
||||
// Show first 10 active spawns
|
||||
shown := 0
|
||||
for _, gs := range active {
|
||||
if shown >= 10 {
|
||||
result += "... (and more)\n"
|
||||
break
|
||||
}
|
||||
result += fmt.Sprintf(" %d: %s (%s) - %d harvests remaining\n",
|
||||
gs.GetID(), gs.GetName(), gs.GetCollectionSkill(), gs.GetNumberHarvests())
|
||||
shown++
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// handleRespawnCommand respawns ground spawns
|
||||
func (m *Manager) handleRespawnCommand(args []string) (string, error) {
|
||||
if len(args) > 0 {
|
||||
// Respawn specific ground spawn
|
||||
var spawnID int32
|
||||
if _, err := fmt.Sscanf(args[0], "%d", &spawnID); err != nil {
|
||||
return "", fmt.Errorf("invalid ground spawn ID: %s", args[0])
|
||||
}
|
||||
|
||||
gs := m.GetGroundSpawn(spawnID)
|
||||
if gs == nil {
|
||||
return fmt.Sprintf("Ground spawn %d not found.", spawnID), nil
|
||||
}
|
||||
|
||||
gs.Respawn()
|
||||
return fmt.Sprintf("Ground spawn %d respawned.", spawnID), nil
|
||||
}
|
||||
|
||||
// Respawn all depleted spawns
|
||||
depleted := m.GetDepletedGroundSpawns()
|
||||
for _, gs := range depleted {
|
||||
gs.Respawn()
|
||||
}
|
||||
|
||||
return fmt.Sprintf("Respawned %d depleted ground spawns.", len(depleted)), nil
|
||||
}
|
||||
|
||||
// handleInfoCommand shows information about a specific ground spawn
|
||||
func (m *Manager) handleInfoCommand(args []string) (string, error) {
|
||||
if len(args) == 0 {
|
||||
return "", fmt.Errorf("ground spawn ID required")
|
||||
}
|
||||
|
||||
var spawnID int32
|
||||
if _, err := fmt.Sscanf(args[0], "%d", &spawnID); err != nil {
|
||||
return "", fmt.Errorf("invalid ground spawn ID: %s", args[0])
|
||||
}
|
||||
|
||||
gs := m.GetGroundSpawn(spawnID)
|
||||
if gs == nil {
|
||||
return fmt.Sprintf("Ground spawn %d not found.", spawnID), nil
|
||||
}
|
||||
|
||||
result := "Ground Spawn Information:\n"
|
||||
result += fmt.Sprintf("ID: %d\n", gs.GetID())
|
||||
result += fmt.Sprintf("Name: %s\n", gs.GetName())
|
||||
result += fmt.Sprintf("Collection Skill: %s\n", gs.GetCollectionSkill())
|
||||
result += fmt.Sprintf("Harvests Remaining: %d\n", gs.GetNumberHarvests())
|
||||
result += fmt.Sprintf("Attempts per Harvest: %d\n", gs.GetAttemptsPerHarvest())
|
||||
result += fmt.Sprintf("Ground Spawn Entry ID: %d\n", gs.GetGroundSpawnEntryID())
|
||||
result += fmt.Sprintf("Available: %v\n", gs.IsAvailable())
|
||||
result += fmt.Sprintf("Depleted: %v\n", gs.IsDepleted())
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// handleReloadCommand reloads ground spawns from database
|
||||
func (m *Manager) handleReloadCommand(_ []string) (string, error) {
|
||||
if m.database == nil {
|
||||
return "", fmt.Errorf("no database available")
|
||||
}
|
||||
|
||||
// Clear current data
|
||||
m.mutex.Lock()
|
||||
m.groundSpawns = make(map[int32]*GroundSpawn)
|
||||
m.spawnsByZone = make(map[int32][]*GroundSpawn)
|
||||
m.entriesByID = make(map[int32][]*GroundSpawnEntry)
|
||||
m.itemsByID = make(map[int32][]*GroundSpawnEntryItem)
|
||||
m.respawnQueue = make(map[int32]time.Time)
|
||||
m.activeSpawns = make(map[int32]*GroundSpawn)
|
||||
m.depletedSpawns = make(map[int32]*GroundSpawn)
|
||||
m.nextSpawnID = 1 // Reset ID counter
|
||||
m.mutex.Unlock()
|
||||
|
||||
// Reload from database
|
||||
if err := m.Initialize(); err != nil {
|
||||
return "", fmt.Errorf("failed to reload ground spawns: %w", err)
|
||||
}
|
||||
|
||||
count := m.GetGroundSpawnCount()
|
||||
return fmt.Sprintf("Successfully reloaded %d ground spawns from database.", count), nil
|
||||
}
|
||||
|
||||
// Shutdown gracefully shuts down the manager
|
||||
func (m *Manager) Shutdown() {
|
||||
if m.logger != nil {
|
||||
m.logger.LogInfo("Shutting down ground spawn manager...")
|
||||
}
|
||||
|
||||
m.mutex.Lock()
|
||||
defer m.mutex.Unlock()
|
||||
|
||||
// Clear all data
|
||||
m.groundSpawns = make(map[int32]*GroundSpawn)
|
||||
m.spawnsByZone = make(map[int32][]*GroundSpawn)
|
||||
m.entriesByID = make(map[int32][]*GroundSpawnEntry)
|
||||
m.itemsByID = make(map[int32][]*GroundSpawnEntryItem)
|
||||
m.respawnQueue = make(map[int32]time.Time)
|
||||
m.activeSpawns = make(map[int32]*GroundSpawn)
|
||||
m.depletedSpawns = make(map[int32]*GroundSpawn)
|
||||
m.nextSpawnID = 1
|
||||
}
|
||||
180
internal/ground_spawn/master.go
Normal file
180
internal/ground_spawn/master.go
Normal file
@ -0,0 +1,180 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"eq2emu/internal/common"
|
||||
"eq2emu/internal/database"
|
||||
"zombiezen.com/go/sqlite"
|
||||
)
|
||||
|
||||
// MasterList manages all ground spawns using the generic base
|
||||
type MasterList struct {
|
||||
*common.MasterList[int32, *GroundSpawn]
|
||||
}
|
||||
|
||||
// NewMasterList creates a new ground spawn master list
|
||||
func NewMasterList() *MasterList {
|
||||
return &MasterList{
|
||||
MasterList: common.NewMasterList[int32, *GroundSpawn](),
|
||||
}
|
||||
}
|
||||
|
||||
// AddGroundSpawn adds a ground spawn to the master list
|
||||
func (ml *MasterList) AddGroundSpawn(gs *GroundSpawn) bool {
|
||||
return ml.MasterList.Add(gs)
|
||||
}
|
||||
|
||||
// GetGroundSpawn retrieves a ground spawn by ID
|
||||
func (ml *MasterList) GetGroundSpawn(groundSpawnID int32) *GroundSpawn {
|
||||
return ml.MasterList.Get(groundSpawnID)
|
||||
}
|
||||
|
||||
// RemoveGroundSpawn removes a ground spawn by ID
|
||||
func (ml *MasterList) RemoveGroundSpawn(groundSpawnID int32) bool {
|
||||
return ml.MasterList.Remove(groundSpawnID)
|
||||
}
|
||||
|
||||
// GetByZone returns all ground spawns in a specific zone
|
||||
func (ml *MasterList) GetByZone(zoneID int32) []*GroundSpawn {
|
||||
return ml.MasterList.Filter(func(gs *GroundSpawn) bool {
|
||||
return gs.ZoneID == zoneID
|
||||
})
|
||||
}
|
||||
|
||||
// GetBySkill returns all ground spawns that require a specific skill
|
||||
func (ml *MasterList) GetBySkill(skill string) []*GroundSpawn {
|
||||
return ml.MasterList.Filter(func(gs *GroundSpawn) bool {
|
||||
return gs.CollectionSkill == skill
|
||||
})
|
||||
}
|
||||
|
||||
// GetAvailableSpawns returns all harvestable ground spawns
|
||||
func (ml *MasterList) GetAvailableSpawns() []*GroundSpawn {
|
||||
return ml.MasterList.Filter(func(gs *GroundSpawn) bool {
|
||||
return gs.IsAvailable()
|
||||
})
|
||||
}
|
||||
|
||||
// GetDepletedSpawns returns all depleted ground spawns
|
||||
func (ml *MasterList) GetDepletedSpawns() []*GroundSpawn {
|
||||
return ml.MasterList.Filter(func(gs *GroundSpawn) bool {
|
||||
return gs.IsDepleted()
|
||||
})
|
||||
}
|
||||
|
||||
// LoadFromDatabase loads all ground spawns from database
|
||||
func (ml *MasterList) LoadFromDatabase(db *database.Database) error {
|
||||
if db.GetType() == database.SQLite {
|
||||
return ml.loadFromSQLite(db)
|
||||
}
|
||||
return ml.loadFromMySQL(db)
|
||||
}
|
||||
|
||||
func (ml *MasterList) loadFromSQLite(db *database.Database) error {
|
||||
return db.ExecTransient(`
|
||||
SELECT id, groundspawn_id, name, collection_skill, number_harvests,
|
||||
attempts_per_harvest, randomize_heading, respawn_time,
|
||||
x, y, z, heading, zone_id, grid_id
|
||||
FROM ground_spawns
|
||||
ORDER BY groundspawn_id
|
||||
`, func(stmt *sqlite.Stmt) error {
|
||||
gs := &GroundSpawn{
|
||||
ID: stmt.ColumnInt32(0),
|
||||
GroundSpawnID: stmt.ColumnInt32(1),
|
||||
Name: stmt.ColumnText(2),
|
||||
CollectionSkill: stmt.ColumnText(3),
|
||||
NumberHarvests: int8(stmt.ColumnInt32(4)),
|
||||
AttemptsPerHarvest: int8(stmt.ColumnInt32(5)),
|
||||
RandomizeHeading: stmt.ColumnBool(6),
|
||||
RespawnTime: stmt.ColumnInt32(7),
|
||||
X: float32(stmt.ColumnFloat(8)),
|
||||
Y: float32(stmt.ColumnFloat(9)),
|
||||
Z: float32(stmt.ColumnFloat(10)),
|
||||
Heading: float32(stmt.ColumnFloat(11)),
|
||||
ZoneID: stmt.ColumnInt32(12),
|
||||
GridID: stmt.ColumnInt32(13),
|
||||
db: db,
|
||||
isNew: false,
|
||||
IsAlive: true,
|
||||
CurrentHarvests: int8(stmt.ColumnInt32(4)), // Initialize to max harvests
|
||||
HarvestEntries: make([]*HarvestEntry, 0),
|
||||
HarvestItems: make([]*HarvestEntryItem, 0),
|
||||
}
|
||||
|
||||
// Load harvest data for this ground spawn
|
||||
if err := gs.loadHarvestData(); err != nil {
|
||||
return fmt.Errorf("failed to load harvest data for ground spawn %d: %w", gs.GroundSpawnID, err)
|
||||
}
|
||||
|
||||
ml.MasterList.Add(gs)
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func (ml *MasterList) loadFromMySQL(db *database.Database) error {
|
||||
rows, err := db.Query(`
|
||||
SELECT id, groundspawn_id, name, collection_skill, number_harvests,
|
||||
attempts_per_harvest, randomize_heading, respawn_time,
|
||||
x, y, z, heading, zone_id, grid_id
|
||||
FROM ground_spawns
|
||||
ORDER BY groundspawn_id
|
||||
`)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to query ground spawns: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
gs := &GroundSpawn{
|
||||
db: db,
|
||||
isNew: false,
|
||||
IsAlive: true,
|
||||
HarvestEntries: make([]*HarvestEntry, 0),
|
||||
HarvestItems: make([]*HarvestEntryItem, 0),
|
||||
}
|
||||
|
||||
err := rows.Scan(&gs.ID, &gs.GroundSpawnID, &gs.Name, &gs.CollectionSkill,
|
||||
&gs.NumberHarvests, &gs.AttemptsPerHarvest, &gs.RandomizeHeading,
|
||||
&gs.RespawnTime, &gs.X, &gs.Y, &gs.Z, &gs.Heading, &gs.ZoneID, &gs.GridID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to scan ground spawn: %w", err)
|
||||
}
|
||||
|
||||
// Initialize current harvests to max
|
||||
gs.CurrentHarvests = gs.NumberHarvests
|
||||
|
||||
// Load harvest data for this ground spawn
|
||||
if err := gs.loadHarvestData(); err != nil {
|
||||
return fmt.Errorf("failed to load harvest data for ground spawn %d: %w", gs.GroundSpawnID, err)
|
||||
}
|
||||
|
||||
ml.MasterList.Add(gs)
|
||||
}
|
||||
|
||||
return rows.Err()
|
||||
}
|
||||
|
||||
// GetStatistics returns statistics about the ground spawn system
|
||||
func (ml *MasterList) GetStatistics() *Statistics {
|
||||
availableSpawns := len(ml.GetAvailableSpawns())
|
||||
|
||||
// Count by zone
|
||||
zoneMap := make(map[int32]int)
|
||||
skillMap := make(map[string]int64)
|
||||
|
||||
ml.MasterList.ForEach(func(id int32, gs *GroundSpawn) {
|
||||
zoneMap[gs.ZoneID]++
|
||||
skillMap[gs.CollectionSkill]++
|
||||
})
|
||||
|
||||
return &Statistics{
|
||||
TotalHarvests: 0, // Would need to be tracked separately
|
||||
SuccessfulHarvests: 0, // Would need to be tracked separately
|
||||
RareItemsHarvested: 0, // Would need to be tracked separately
|
||||
SkillUpsGenerated: 0, // Would need to be tracked separately
|
||||
HarvestsBySkill: skillMap,
|
||||
ActiveGroundSpawns: availableSpawns,
|
||||
GroundSpawnsByZone: zoneMap,
|
||||
}
|
||||
}
|
||||
@ -1,8 +0,0 @@
|
||||
package ground_spawn
|
||||
|
||||
type mockLogger struct{}
|
||||
|
||||
func (l *mockLogger) LogInfo(message string, args ...any) {}
|
||||
func (l *mockLogger) LogError(message string, args ...any) {}
|
||||
func (l *mockLogger) LogDebug(message string, args ...any) {}
|
||||
func (l *mockLogger) LogWarning(message string, args ...any) {}
|
||||
@ -1,136 +1,85 @@
|
||||
package ground_spawn
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"time"
|
||||
import "time"
|
||||
|
||||
"eq2emu/internal/spawn"
|
||||
)
|
||||
|
||||
// GroundSpawn represents a harvestable resource node in the game world
|
||||
type GroundSpawn struct {
|
||||
*spawn.Spawn // Embed spawn for base functionality
|
||||
|
||||
numberHarvests int8 // Number of harvests remaining
|
||||
numAttemptsPerHarvest int8 // Attempts per harvest session
|
||||
groundspawnID int32 // Database ID for this groundspawn entry
|
||||
collectionSkill string // Required skill for harvesting
|
||||
randomizeHeading bool // Whether to randomize heading on spawn
|
||||
|
||||
harvestMutex sync.Mutex // Thread safety for harvest operations
|
||||
harvestUseMutex sync.Mutex // Thread safety for use operations
|
||||
// HarvestEntry represents harvest table data from database
|
||||
type HarvestEntry struct {
|
||||
GroundSpawnID int32 `json:"groundspawn_id" db:"groundspawn_id"` // Ground spawn ID
|
||||
MinSkillLevel int16 `json:"min_skill_level" db:"min_skill_level"` // Minimum skill level required
|
||||
MinAdventureLevel int16 `json:"min_adventure_level" db:"min_adventure_level"` // Minimum adventure level required
|
||||
BonusTable bool `json:"bonus_table" db:"bonus_table"` // Whether this is a bonus table
|
||||
Harvest1 float32 `json:"harvest1" db:"harvest1"` // Chance for 1 item (percentage)
|
||||
Harvest3 float32 `json:"harvest3" db:"harvest3"` // Chance for 3 items (percentage)
|
||||
Harvest5 float32 `json:"harvest5" db:"harvest5"` // Chance for 5 items (percentage)
|
||||
HarvestImbue float32 `json:"harvest_imbue" db:"harvest_imbue"` // Chance for imbue item (percentage)
|
||||
HarvestRare float32 `json:"harvest_rare" db:"harvest_rare"` // Chance for rare item (percentage)
|
||||
Harvest10 float32 `json:"harvest10" db:"harvest10"` // Chance for 10 + rare items (percentage)
|
||||
HarvestCoin float32 `json:"harvest_coin" db:"harvest_coin"` // Chance for coin reward (percentage)
|
||||
}
|
||||
|
||||
// GroundSpawnEntry represents harvest table data from database
|
||||
type GroundSpawnEntry struct {
|
||||
MinSkillLevel int16 // Minimum skill level required
|
||||
MinAdventureLevel int16 // Minimum adventure level required
|
||||
BonusTable bool // Whether this is a bonus table
|
||||
Harvest1 float32 // Chance for 1 item (percentage)
|
||||
Harvest3 float32 // Chance for 3 items (percentage)
|
||||
Harvest5 float32 // Chance for 5 items (percentage)
|
||||
HarvestImbue float32 // Chance for imbue item (percentage)
|
||||
HarvestRare float32 // Chance for rare item (percentage)
|
||||
Harvest10 float32 // Chance for 10 + rare items (percentage)
|
||||
HarvestCoin float32 // Chance for coin reward (percentage)
|
||||
}
|
||||
|
||||
// GroundSpawnEntryItem represents items that can be harvested
|
||||
type GroundSpawnEntryItem struct {
|
||||
ItemID int32 // Item database ID
|
||||
IsRare int8 // 0=normal, 1=rare, 2=imbue
|
||||
GridID int32 // Grid restriction (0=any)
|
||||
Quantity int16 // Item quantity (usually 1)
|
||||
// HarvestEntryItem represents items that can be harvested
|
||||
type HarvestEntryItem struct {
|
||||
GroundSpawnID int32 `json:"groundspawn_id" db:"groundspawn_id"` // Ground spawn ID
|
||||
ItemID int32 `json:"item_id" db:"item_id"` // Item database ID
|
||||
IsRare int8 `json:"is_rare" db:"is_rare"` // 0=normal, 1=rare, 2=imbue
|
||||
GridID int32 `json:"grid_id" db:"grid_id"` // Grid restriction (0=any)
|
||||
Quantity int16 `json:"quantity" db:"quantity"` // Item quantity (usually 1)
|
||||
}
|
||||
|
||||
// HarvestResult represents the outcome of a harvest attempt
|
||||
type HarvestResult struct {
|
||||
Success bool // Whether harvest succeeded
|
||||
HarvestType int8 // Type of harvest achieved
|
||||
ItemsAwarded []*HarvestedItem // Items given to player
|
||||
MessageText string // Message to display to player
|
||||
SkillGained bool // Whether skill was gained
|
||||
Error error // Any error that occurred
|
||||
Success bool `json:"success"` // Whether harvest succeeded
|
||||
HarvestType int8 `json:"harvest_type"` // Type of harvest achieved
|
||||
ItemsAwarded []*HarvestedItem `json:"items_awarded"` // Items given to player
|
||||
MessageText string `json:"message_text"` // Message to display to player
|
||||
SkillGained bool `json:"skill_gained"` // Whether skill was gained
|
||||
Error error `json:"error,omitempty"` // Any error that occurred
|
||||
}
|
||||
|
||||
// HarvestedItem represents an item awarded from harvesting
|
||||
type HarvestedItem struct {
|
||||
ItemID int32 // Database item ID
|
||||
Quantity int16 // Number of items
|
||||
IsRare bool // Whether this is a rare item
|
||||
Name string // Item name for messages
|
||||
ItemID int32 `json:"item_id"` // Database item ID
|
||||
Quantity int16 `json:"quantity"` // Number of items
|
||||
IsRare bool `json:"is_rare"` // Whether this is a rare item
|
||||
Name string `json:"name"` // Item name for messages
|
||||
}
|
||||
|
||||
// HarvestContext contains all data needed for a harvest operation
|
||||
type HarvestContext struct {
|
||||
Player *Player // Player attempting harvest
|
||||
GroundSpawn *GroundSpawn // The ground spawn being harvested
|
||||
PlayerSkill *Skill // Player's harvesting skill
|
||||
TotalSkill int16 // Total skill including bonuses
|
||||
GroundSpawnEntries []*GroundSpawnEntry // Available harvest tables
|
||||
GroundSpawnItems []*GroundSpawnEntryItem // Available harvest items
|
||||
IsCollection bool // Whether this is collection harvesting
|
||||
MaxSkillRequired int16 // Maximum skill required for any table
|
||||
// Player interface for harvest operations (simplified)
|
||||
type Player interface {
|
||||
GetLevel() int16
|
||||
GetLocation() int32
|
||||
GetName() string
|
||||
}
|
||||
|
||||
// SpawnLocation represents a spawn position with grid information
|
||||
type SpawnLocation struct {
|
||||
X float32 // World X coordinate
|
||||
Y float32 // World Y coordinate
|
||||
Z float32 // World Z coordinate
|
||||
Heading float32 // Spawn heading/rotation
|
||||
GridID int32 // Grid zone identifier
|
||||
// Skill interface for harvest operations (simplified)
|
||||
type Skill interface {
|
||||
GetCurrentValue() int16
|
||||
GetMaxValue() int16
|
||||
}
|
||||
|
||||
// HarvestModifiers contains modifiers that affect harvesting
|
||||
type HarvestModifiers struct {
|
||||
SkillMultiplier float32 // Skill gain multiplier
|
||||
RareChanceBonus float32 // Bonus to rare item chance
|
||||
QuantityMultiplier float32 // Quantity multiplier
|
||||
LuckModifier int16 // Player luck modifier
|
||||
// Client interface for ground spawn use operations (simplified)
|
||||
type Client interface {
|
||||
GetPlayer() *Player
|
||||
GetVersion() int16
|
||||
GetLogger() Logger
|
||||
}
|
||||
|
||||
// GroundSpawnConfig contains configuration for ground spawn creation
|
||||
type GroundSpawnConfig struct {
|
||||
GroundSpawnID int32 // Database entry ID
|
||||
CollectionSkill string // Required harvesting skill
|
||||
NumberHarvests int8 // Harvests before depletion
|
||||
AttemptsPerHarvest int8 // Attempts per harvest session
|
||||
RandomizeHeading bool // Randomize spawn heading
|
||||
RespawnTimer time.Duration // Time before respawn
|
||||
Location SpawnLocation // Spawn position
|
||||
Name string // Display name
|
||||
Description string // Spawn description
|
||||
// Logger interface for logging operations
|
||||
type Logger interface {
|
||||
LogDebug(format string, args ...interface{})
|
||||
LogError(format string, args ...interface{})
|
||||
}
|
||||
|
||||
// Manager manages all ground spawn operations
|
||||
type Manager struct {
|
||||
groundSpawns map[int32]*GroundSpawn // Active ground spawns by ID
|
||||
spawnsByZone map[int32][]*GroundSpawn // Ground spawns by zone ID
|
||||
entriesByID map[int32][]*GroundSpawnEntry // Harvest entries by groundspawn ID
|
||||
itemsByID map[int32][]*GroundSpawnEntryItem // Harvest items by groundspawn ID
|
||||
respawnQueue map[int32]time.Time // Respawn timestamps
|
||||
|
||||
// Performance optimization: cache active/depleted spawns to avoid O(N) scans
|
||||
activeSpawns map[int32]*GroundSpawn // Cache of active spawns for O(1) lookups
|
||||
depletedSpawns map[int32]*GroundSpawn // Cache of depleted spawns for O(1) lookups
|
||||
|
||||
database Database // Database interface
|
||||
logger Logger // Logging interface
|
||||
|
||||
mutex sync.RWMutex // Thread safety
|
||||
nextSpawnID int32 // Efficient ID counter to avoid len() calls
|
||||
|
||||
// Statistics
|
||||
totalHarvests int64 // Total harvest attempts
|
||||
successfulHarvests int64 // Successful harvests
|
||||
rareItemsHarvested int64 // Rare items harvested
|
||||
skillUpsGenerated int64 // Skill increases given
|
||||
harvestsBySkill map[string]int64 // Harvests by skill type
|
||||
// RespawnConfig holds respawn timing configuration
|
||||
type RespawnConfig struct {
|
||||
BaseTime time.Duration `json:"base_time"` // Base respawn time
|
||||
RandomDelay time.Duration `json:"random_delay"` // Random delay addition
|
||||
ZoneModifier float64 `json:"zone_modifier"` // Zone-specific modifier
|
||||
}
|
||||
|
||||
// HarvestStatistics contains harvest system statistics
|
||||
type HarvestStatistics struct {
|
||||
// Statistics holds ground spawn system statistics
|
||||
type Statistics struct {
|
||||
TotalHarvests int64 `json:"total_harvests"`
|
||||
SuccessfulHarvests int64 `json:"successful_harvests"`
|
||||
RareItemsHarvested int64 `json:"rare_items_harvested"`
|
||||
@ -138,4 +87,4 @@ type HarvestStatistics struct {
|
||||
HarvestsBySkill map[string]int64 `json:"harvests_by_skill"`
|
||||
ActiveGroundSpawns int `json:"active_ground_spawns"`
|
||||
GroundSpawnsByZone map[int32]int `json:"ground_spawns_by_zone"`
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user