645 lines
15 KiB
Go
645 lines
15 KiB
Go
package loot
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"log"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// LootDatabase handles all database operations for the loot system
|
|
type LootDatabase struct {
|
|
db *sql.DB
|
|
queries map[string]*sql.Stmt
|
|
lootTables map[int32]*LootTable
|
|
spawnLoot map[int32][]int32 // spawn_id -> []loot_table_id
|
|
globalLoot []*GlobalLoot
|
|
mutex sync.RWMutex
|
|
}
|
|
|
|
// NewLootDatabase creates a new loot database manager
|
|
func NewLootDatabase(db *sql.DB) *LootDatabase {
|
|
ldb := &LootDatabase{
|
|
db: db,
|
|
queries: make(map[string]*sql.Stmt),
|
|
lootTables: make(map[int32]*LootTable),
|
|
spawnLoot: make(map[int32][]int32),
|
|
globalLoot: make([]*GlobalLoot, 0),
|
|
}
|
|
|
|
// Prepare commonly used queries
|
|
ldb.prepareQueries()
|
|
|
|
return ldb
|
|
}
|
|
|
|
// prepareQueries prepares all commonly used SQL queries
|
|
func (ldb *LootDatabase) prepareQueries() {
|
|
queries := map[string]string{
|
|
"load_loot_tables": `
|
|
SELECT id, name, mincoin, maxcoin, maxlootitems, lootdrop_probability, coin_probability
|
|
FROM loottable
|
|
ORDER BY id
|
|
`,
|
|
|
|
"load_loot_drops": `
|
|
SELECT loot_table_id, item_id, item_charges, equip_item, probability, no_drop_quest_completed_id
|
|
FROM lootdrop
|
|
WHERE loot_table_id = ?
|
|
ORDER BY probability DESC
|
|
`,
|
|
|
|
"load_spawn_loot": `
|
|
SELECT spawn_id, loottable_id
|
|
FROM spawn_loot
|
|
ORDER BY spawn_id
|
|
`,
|
|
|
|
"load_global_loot": `
|
|
SELECT type, loot_table, value1, value2, value3, value4
|
|
FROM loot_global
|
|
ORDER BY type, value1
|
|
`,
|
|
|
|
"insert_loot_table": `
|
|
INSERT INTO loottable (id, name, mincoin, maxcoin, maxlootitems, lootdrop_probability, coin_probability)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
|
|
"update_loot_table": `
|
|
UPDATE loottable
|
|
SET name = ?, mincoin = ?, maxcoin = ?, maxlootitems = ?, lootdrop_probability = ?, coin_probability = ?
|
|
WHERE id = ?
|
|
`,
|
|
|
|
"delete_loot_table": `
|
|
DELETE FROM loottable WHERE id = ?
|
|
`,
|
|
|
|
"insert_loot_drop": `
|
|
INSERT INTO lootdrop (loot_table_id, item_id, item_charges, equip_item, probability, no_drop_quest_completed_id)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`,
|
|
|
|
"delete_loot_drops": `
|
|
DELETE FROM lootdrop WHERE loot_table_id = ?
|
|
`,
|
|
|
|
"insert_spawn_loot": `
|
|
INSERT OR REPLACE INTO spawn_loot (spawn_id, loottable_id)
|
|
VALUES (?, ?)
|
|
`,
|
|
|
|
"delete_spawn_loot": `
|
|
DELETE FROM spawn_loot WHERE spawn_id = ?
|
|
`,
|
|
|
|
"insert_global_loot": `
|
|
INSERT INTO loot_global (type, loot_table, value1, value2, value3, value4)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`,
|
|
|
|
"delete_global_loot": `
|
|
DELETE FROM loot_global WHERE type = ?
|
|
`,
|
|
|
|
"get_loot_table": `
|
|
SELECT id, name, mincoin, maxcoin, maxlootitems, lootdrop_probability, coin_probability
|
|
FROM loottable
|
|
WHERE id = ?
|
|
`,
|
|
|
|
"get_spawn_loot_tables": `
|
|
SELECT loottable_id
|
|
FROM spawn_loot
|
|
WHERE spawn_id = ?
|
|
`,
|
|
|
|
"count_loot_tables": `
|
|
SELECT COUNT(*) FROM loottable
|
|
`,
|
|
|
|
"count_loot_drops": `
|
|
SELECT COUNT(*) FROM lootdrop
|
|
`,
|
|
|
|
"count_spawn_loot": `
|
|
SELECT COUNT(*) FROM spawn_loot
|
|
`,
|
|
}
|
|
|
|
for name, query := range queries {
|
|
if stmt, err := ldb.db.Prepare(query); err != nil {
|
|
log.Printf("%s Failed to prepare query %s: %v", LogPrefixDatabase, name, err)
|
|
} else {
|
|
ldb.queries[name] = stmt
|
|
}
|
|
}
|
|
}
|
|
|
|
// LoadAllLootData loads all loot data from the database
|
|
func (ldb *LootDatabase) LoadAllLootData() error {
|
|
log.Printf("%s Loading loot data from database...", LogPrefixDatabase)
|
|
|
|
// Load loot tables first
|
|
if err := ldb.loadLootTables(); err != nil {
|
|
return fmt.Errorf("failed to load loot tables: %v", err)
|
|
}
|
|
|
|
// Load loot drops for each table
|
|
if err := ldb.loadLootDrops(); err != nil {
|
|
return fmt.Errorf("failed to load loot drops: %v", err)
|
|
}
|
|
|
|
// Load spawn loot assignments
|
|
if err := ldb.loadSpawnLoot(); err != nil {
|
|
return fmt.Errorf("failed to load spawn loot: %v", err)
|
|
}
|
|
|
|
// Load global loot configuration
|
|
if err := ldb.loadGlobalLoot(); err != nil {
|
|
return fmt.Errorf("failed to load global loot: %v", err)
|
|
}
|
|
|
|
ldb.mutex.RLock()
|
|
tableCount := len(ldb.lootTables)
|
|
spawnCount := len(ldb.spawnLoot)
|
|
globalCount := len(ldb.globalLoot)
|
|
ldb.mutex.RUnlock()
|
|
|
|
log.Printf("%s Loaded %d loot tables, %d spawn assignments, %d global loot entries",
|
|
LogPrefixDatabase, tableCount, spawnCount, globalCount)
|
|
|
|
return nil
|
|
}
|
|
|
|
// loadLootTables loads all loot tables from the database
|
|
func (ldb *LootDatabase) loadLootTables() error {
|
|
stmt := ldb.queries["load_loot_tables"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("load_loot_tables query not prepared")
|
|
}
|
|
|
|
rows, err := stmt.Query()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to query loot tables: %v", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
ldb.mutex.Lock()
|
|
defer ldb.mutex.Unlock()
|
|
|
|
// Clear existing tables
|
|
ldb.lootTables = make(map[int32]*LootTable)
|
|
|
|
for rows.Next() {
|
|
table := &LootTable{
|
|
Drops: make([]*LootDrop, 0),
|
|
}
|
|
|
|
err := rows.Scan(
|
|
&table.ID,
|
|
&table.Name,
|
|
&table.MinCoin,
|
|
&table.MaxCoin,
|
|
&table.MaxLootItems,
|
|
&table.LootDropProbability,
|
|
&table.CoinProbability,
|
|
)
|
|
|
|
if err != nil {
|
|
log.Printf("%s Error scanning loot table row: %v", LogPrefixDatabase, err)
|
|
continue
|
|
}
|
|
|
|
ldb.lootTables[table.ID] = table
|
|
}
|
|
|
|
return rows.Err()
|
|
}
|
|
|
|
// loadLootDrops loads all loot drops for the loaded loot tables
|
|
func (ldb *LootDatabase) loadLootDrops() error {
|
|
stmt := ldb.queries["load_loot_drops"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("load_loot_drops query not prepared")
|
|
}
|
|
|
|
ldb.mutex.Lock()
|
|
defer ldb.mutex.Unlock()
|
|
|
|
for tableID, table := range ldb.lootTables {
|
|
rows, err := stmt.Query(tableID)
|
|
if err != nil {
|
|
log.Printf("%s Failed to query loot drops for table %d: %v", LogPrefixDatabase, tableID, err)
|
|
continue
|
|
}
|
|
|
|
for rows.Next() {
|
|
drop := &LootDrop{}
|
|
var equipItem int8
|
|
|
|
err := rows.Scan(
|
|
&drop.LootTableID,
|
|
&drop.ItemID,
|
|
&drop.ItemCharges,
|
|
&equipItem,
|
|
&drop.Probability,
|
|
&drop.NoDropQuestCompletedID,
|
|
)
|
|
|
|
if err != nil {
|
|
log.Printf("%s Error scanning loot drop row: %v", LogPrefixDatabase, err)
|
|
continue
|
|
}
|
|
|
|
drop.EquipItem = equipItem == 1
|
|
table.Drops = append(table.Drops, drop)
|
|
}
|
|
|
|
rows.Close()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// loadSpawnLoot loads spawn to loot table assignments
|
|
func (ldb *LootDatabase) loadSpawnLoot() error {
|
|
stmt := ldb.queries["load_spawn_loot"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("load_spawn_loot query not prepared")
|
|
}
|
|
|
|
rows, err := stmt.Query()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to query spawn loot: %v", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
ldb.mutex.Lock()
|
|
defer ldb.mutex.Unlock()
|
|
|
|
// Clear existing spawn loot
|
|
ldb.spawnLoot = make(map[int32][]int32)
|
|
|
|
for rows.Next() {
|
|
var spawnID, lootTableID int32
|
|
|
|
err := rows.Scan(&spawnID, &lootTableID)
|
|
if err != nil {
|
|
log.Printf("%s Error scanning spawn loot row: %v", LogPrefixDatabase, err)
|
|
continue
|
|
}
|
|
|
|
ldb.spawnLoot[spawnID] = append(ldb.spawnLoot[spawnID], lootTableID)
|
|
}
|
|
|
|
return rows.Err()
|
|
}
|
|
|
|
// loadGlobalLoot loads global loot configuration
|
|
func (ldb *LootDatabase) loadGlobalLoot() error {
|
|
stmt := ldb.queries["load_global_loot"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("load_global_loot query not prepared")
|
|
}
|
|
|
|
rows, err := stmt.Query()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to query global loot: %v", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
ldb.mutex.Lock()
|
|
defer ldb.mutex.Unlock()
|
|
|
|
// Clear existing global loot
|
|
ldb.globalLoot = make([]*GlobalLoot, 0)
|
|
|
|
for rows.Next() {
|
|
var lootType string
|
|
var tableID, value1, value2, value3, value4 int32
|
|
|
|
err := rows.Scan(&lootType, &tableID, &value1, &value2, &value3, &value4)
|
|
if err != nil {
|
|
log.Printf("%s Error scanning global loot row: %v", LogPrefixDatabase, err)
|
|
continue
|
|
}
|
|
|
|
global := &GlobalLoot{
|
|
TableID: tableID,
|
|
}
|
|
|
|
// Parse loot type and values
|
|
switch lootType {
|
|
case "level":
|
|
global.Type = GlobalLootTypeLevel
|
|
global.MinLevel = int8(value1)
|
|
global.MaxLevel = int8(value2)
|
|
global.LootTier = value3
|
|
case "race":
|
|
global.Type = GlobalLootTypeRace
|
|
global.Race = int16(value1)
|
|
global.LootTier = value2
|
|
case "zone":
|
|
global.Type = GlobalLootTypeZone
|
|
global.ZoneID = value1
|
|
global.LootTier = value2
|
|
default:
|
|
log.Printf("%s Unknown global loot type: %s", LogPrefixDatabase, lootType)
|
|
continue
|
|
}
|
|
|
|
ldb.globalLoot = append(ldb.globalLoot, global)
|
|
}
|
|
|
|
return rows.Err()
|
|
}
|
|
|
|
// GetLootTable returns a loot table by ID (thread-safe)
|
|
func (ldb *LootDatabase) GetLootTable(tableID int32) *LootTable {
|
|
ldb.mutex.RLock()
|
|
defer ldb.mutex.RUnlock()
|
|
|
|
return ldb.lootTables[tableID]
|
|
}
|
|
|
|
// GetSpawnLootTables returns all loot table IDs for a spawn (thread-safe)
|
|
func (ldb *LootDatabase) GetSpawnLootTables(spawnID int32) []int32 {
|
|
ldb.mutex.RLock()
|
|
defer ldb.mutex.RUnlock()
|
|
|
|
tables := ldb.spawnLoot[spawnID]
|
|
if tables == nil {
|
|
return nil
|
|
}
|
|
|
|
// Return a copy to prevent external modification
|
|
result := make([]int32, len(tables))
|
|
copy(result, tables)
|
|
return result
|
|
}
|
|
|
|
// GetGlobalLootTables returns applicable global loot tables for given parameters
|
|
func (ldb *LootDatabase) GetGlobalLootTables(level int16, race int16, zoneID int32) []*GlobalLoot {
|
|
ldb.mutex.RLock()
|
|
defer ldb.mutex.RUnlock()
|
|
|
|
var result []*GlobalLoot
|
|
|
|
for _, global := range ldb.globalLoot {
|
|
switch global.Type {
|
|
case GlobalLootTypeLevel:
|
|
if level >= int16(global.MinLevel) && level <= int16(global.MaxLevel) {
|
|
result = append(result, global)
|
|
}
|
|
case GlobalLootTypeRace:
|
|
if race == global.Race {
|
|
result = append(result, global)
|
|
}
|
|
case GlobalLootTypeZone:
|
|
if zoneID == global.ZoneID {
|
|
result = append(result, global)
|
|
}
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// AddLootTable adds a new loot table to the database
|
|
func (ldb *LootDatabase) AddLootTable(table *LootTable) error {
|
|
stmt := ldb.queries["insert_loot_table"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("insert_loot_table query not prepared")
|
|
}
|
|
|
|
_, err := stmt.Exec(
|
|
table.ID,
|
|
table.Name,
|
|
table.MinCoin,
|
|
table.MaxCoin,
|
|
table.MaxLootItems,
|
|
table.LootDropProbability,
|
|
table.CoinProbability,
|
|
)
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to insert loot table: %v", err)
|
|
}
|
|
|
|
// Add drops if any
|
|
for _, drop := range table.Drops {
|
|
if err := ldb.AddLootDrop(drop); err != nil {
|
|
log.Printf("%s Failed to add loot drop for table %d: %v", LogPrefixDatabase, table.ID, err)
|
|
}
|
|
}
|
|
|
|
// Update in-memory cache
|
|
ldb.mutex.Lock()
|
|
ldb.lootTables[table.ID] = table
|
|
ldb.mutex.Unlock()
|
|
|
|
log.Printf("%s Added loot table %d (%s) with %d drops", LogPrefixDatabase, table.ID, table.Name, len(table.Drops))
|
|
return nil
|
|
}
|
|
|
|
// AddLootDrop adds a new loot drop to the database
|
|
func (ldb *LootDatabase) AddLootDrop(drop *LootDrop) error {
|
|
stmt := ldb.queries["insert_loot_drop"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("insert_loot_drop query not prepared")
|
|
}
|
|
|
|
equipItem := int8(0)
|
|
if drop.EquipItem {
|
|
equipItem = 1
|
|
}
|
|
|
|
_, err := stmt.Exec(
|
|
drop.LootTableID,
|
|
drop.ItemID,
|
|
drop.ItemCharges,
|
|
equipItem,
|
|
drop.Probability,
|
|
drop.NoDropQuestCompletedID,
|
|
)
|
|
|
|
return err
|
|
}
|
|
|
|
// UpdateLootTable updates an existing loot table
|
|
func (ldb *LootDatabase) UpdateLootTable(table *LootTable) error {
|
|
stmt := ldb.queries["update_loot_table"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("update_loot_table query not prepared")
|
|
}
|
|
|
|
_, err := stmt.Exec(
|
|
table.Name,
|
|
table.MinCoin,
|
|
table.MaxCoin,
|
|
table.MaxLootItems,
|
|
table.LootDropProbability,
|
|
table.CoinProbability,
|
|
table.ID,
|
|
)
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to update loot table: %v", err)
|
|
}
|
|
|
|
// Update drops - delete old ones and insert new ones
|
|
if err := ldb.DeleteLootDrops(table.ID); err != nil {
|
|
log.Printf("%s Failed to delete old loot drops for table %d: %v", LogPrefixDatabase, table.ID, err)
|
|
}
|
|
|
|
for _, drop := range table.Drops {
|
|
if err := ldb.AddLootDrop(drop); err != nil {
|
|
log.Printf("%s Failed to add updated loot drop for table %d: %v", LogPrefixDatabase, table.ID, err)
|
|
}
|
|
}
|
|
|
|
// Update in-memory cache
|
|
ldb.mutex.Lock()
|
|
ldb.lootTables[table.ID] = table
|
|
ldb.mutex.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteLootTable removes a loot table and all its drops
|
|
func (ldb *LootDatabase) DeleteLootTable(tableID int32) error {
|
|
// Delete drops first
|
|
if err := ldb.DeleteLootDrops(tableID); err != nil {
|
|
return fmt.Errorf("failed to delete loot drops: %v", err)
|
|
}
|
|
|
|
// Delete table
|
|
stmt := ldb.queries["delete_loot_table"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("delete_loot_table query not prepared")
|
|
}
|
|
|
|
_, err := stmt.Exec(tableID)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete loot table: %v", err)
|
|
}
|
|
|
|
// Remove from in-memory cache
|
|
ldb.mutex.Lock()
|
|
delete(ldb.lootTables, tableID)
|
|
ldb.mutex.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteLootDrops removes all drops for a loot table
|
|
func (ldb *LootDatabase) DeleteLootDrops(tableID int32) error {
|
|
stmt := ldb.queries["delete_loot_drops"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("delete_loot_drops query not prepared")
|
|
}
|
|
|
|
_, err := stmt.Exec(tableID)
|
|
return err
|
|
}
|
|
|
|
// AddSpawnLoot assigns a loot table to a spawn
|
|
func (ldb *LootDatabase) AddSpawnLoot(spawnID, tableID int32) error {
|
|
stmt := ldb.queries["insert_spawn_loot"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("insert_spawn_loot query not prepared")
|
|
}
|
|
|
|
_, err := stmt.Exec(spawnID, tableID)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to insert spawn loot: %v", err)
|
|
}
|
|
|
|
// Update in-memory cache
|
|
ldb.mutex.Lock()
|
|
ldb.spawnLoot[spawnID] = append(ldb.spawnLoot[spawnID], tableID)
|
|
ldb.mutex.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteSpawnLoot removes all loot table assignments for a spawn
|
|
func (ldb *LootDatabase) DeleteSpawnLoot(spawnID int32) error {
|
|
stmt := ldb.queries["delete_spawn_loot"]
|
|
if stmt == nil {
|
|
return fmt.Errorf("delete_spawn_loot query not prepared")
|
|
}
|
|
|
|
_, err := stmt.Exec(spawnID)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete spawn loot: %v", err)
|
|
}
|
|
|
|
// Remove from in-memory cache
|
|
ldb.mutex.Lock()
|
|
delete(ldb.spawnLoot, spawnID)
|
|
ldb.mutex.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetLootStatistics returns database statistics
|
|
func (ldb *LootDatabase) GetLootStatistics() (map[string]any, error) {
|
|
stats := make(map[string]any)
|
|
|
|
// Count loot tables
|
|
if stmt := ldb.queries["count_loot_tables"]; stmt != nil {
|
|
var count int
|
|
if err := stmt.QueryRow().Scan(&count); err == nil {
|
|
stats["loot_tables"] = count
|
|
}
|
|
}
|
|
|
|
// Count loot drops
|
|
if stmt := ldb.queries["count_loot_drops"]; stmt != nil {
|
|
var count int
|
|
if err := stmt.QueryRow().Scan(&count); err == nil {
|
|
stats["loot_drops"] = count
|
|
}
|
|
}
|
|
|
|
// Count spawn loot assignments
|
|
if stmt := ldb.queries["count_spawn_loot"]; stmt != nil {
|
|
var count int
|
|
if err := stmt.QueryRow().Scan(&count); err == nil {
|
|
stats["spawn_loot_assignments"] = count
|
|
}
|
|
}
|
|
|
|
// In-memory statistics
|
|
ldb.mutex.RLock()
|
|
stats["cached_loot_tables"] = len(ldb.lootTables)
|
|
stats["cached_spawn_assignments"] = len(ldb.spawnLoot)
|
|
stats["cached_global_loot"] = len(ldb.globalLoot)
|
|
ldb.mutex.RUnlock()
|
|
|
|
stats["loaded_at"] = time.Now().Format(time.RFC3339)
|
|
|
|
return stats, nil
|
|
}
|
|
|
|
// ReloadLootData reloads all loot data from the database
|
|
func (ldb *LootDatabase) ReloadLootData() error {
|
|
log.Printf("%s Reloading loot data from database...", LogPrefixDatabase)
|
|
|
|
return ldb.LoadAllLootData()
|
|
}
|
|
|
|
// Close closes all prepared statements
|
|
func (ldb *LootDatabase) Close() error {
|
|
for name, stmt := range ldb.queries {
|
|
if err := stmt.Close(); err != nil {
|
|
log.Printf("%s Error closing statement %s: %v", LogPrefixDatabase, name, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|