153 lines
3.0 KiB
Go
153 lines
3.0 KiB
Go
package drops
|
|
|
|
import (
|
|
"dk/internal/store"
|
|
"fmt"
|
|
)
|
|
|
|
// Drop represents a drop item in the game
|
|
type Drop struct {
|
|
ID int `json:"id"`
|
|
Name string `json:"name"`
|
|
Level int `json:"level"`
|
|
Type int `json:"type"`
|
|
Att string `json:"att"`
|
|
}
|
|
|
|
func (d *Drop) Save() error {
|
|
return GetStore().UpdateWithRebuild(d.ID, d)
|
|
}
|
|
|
|
func (d *Drop) Delete() error {
|
|
GetStore().RemoveWithRebuild(d.ID)
|
|
return nil
|
|
}
|
|
|
|
// Creates a new Drop with sensible defaults
|
|
func New() *Drop {
|
|
return &Drop{
|
|
Name: "",
|
|
Level: 1, // Default minimum level
|
|
Type: TypeConsumable, // Default to consumable
|
|
Att: "",
|
|
}
|
|
}
|
|
|
|
// Validate checks if drop has valid values
|
|
func (d *Drop) Validate() error {
|
|
if d.Name == "" {
|
|
return fmt.Errorf("drop name cannot be empty")
|
|
}
|
|
if d.Level < 1 {
|
|
return fmt.Errorf("drop Level must be at least 1")
|
|
}
|
|
if d.Type < TypeConsumable {
|
|
return fmt.Errorf("invalid drop type: %d", d.Type)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DropType constants for drop types
|
|
const (
|
|
TypeConsumable = 1
|
|
)
|
|
|
|
// DropStore with enhanced BaseStore
|
|
type DropStore struct {
|
|
*store.BaseStore[Drop]
|
|
}
|
|
|
|
// Global store with singleton pattern
|
|
var GetStore = store.NewSingleton(func() *DropStore {
|
|
ds := &DropStore{BaseStore: store.NewBaseStore[Drop]()}
|
|
|
|
// Register indices
|
|
ds.RegisterIndex("byLevel", store.BuildIntGroupIndex(func(d *Drop) int {
|
|
return d.Level
|
|
}))
|
|
|
|
ds.RegisterIndex("byType", store.BuildIntGroupIndex(func(d *Drop) int {
|
|
return d.Type
|
|
}))
|
|
|
|
ds.RegisterIndex("allByID", store.BuildSortedListIndex(func(a, b *Drop) bool {
|
|
return a.ID < b.ID
|
|
}))
|
|
|
|
return ds
|
|
})
|
|
|
|
// Enhanced CRUD operations
|
|
func (ds *DropStore) AddDrop(drop *Drop) error {
|
|
return ds.AddWithRebuild(drop.ID, drop)
|
|
}
|
|
|
|
func (ds *DropStore) RemoveDrop(id int) {
|
|
ds.RemoveWithRebuild(id)
|
|
}
|
|
|
|
func (ds *DropStore) UpdateDrop(drop *Drop) error {
|
|
return ds.UpdateWithRebuild(drop.ID, drop)
|
|
}
|
|
|
|
// Data persistence
|
|
func LoadData(dataPath string) error {
|
|
ds := GetStore()
|
|
return ds.BaseStore.LoadData(dataPath)
|
|
}
|
|
|
|
func SaveData(dataPath string) error {
|
|
ds := GetStore()
|
|
return ds.BaseStore.SaveData(dataPath)
|
|
}
|
|
|
|
// Query functions using enhanced store
|
|
func Find(id int) (*Drop, error) {
|
|
ds := GetStore()
|
|
drop, exists := ds.Find(id)
|
|
if !exists {
|
|
return nil, fmt.Errorf("drop with ID %d not found", id)
|
|
}
|
|
return drop, nil
|
|
}
|
|
|
|
func All() ([]*Drop, error) {
|
|
ds := GetStore()
|
|
return ds.AllSorted("allByID"), nil
|
|
}
|
|
|
|
func ByLevel(minLevel int) ([]*Drop, error) {
|
|
ds := GetStore()
|
|
return ds.FilterByIndex("allByID", func(d *Drop) bool {
|
|
return d.Level <= minLevel
|
|
}), nil
|
|
}
|
|
|
|
func ByType(dropType int) ([]*Drop, error) {
|
|
ds := GetStore()
|
|
return ds.GroupByIndex("byType", dropType), nil
|
|
}
|
|
|
|
// Insert with ID assignment
|
|
func (d *Drop) Insert() error {
|
|
ds := GetStore()
|
|
if d.ID == 0 {
|
|
d.ID = ds.GetNextID()
|
|
}
|
|
return ds.AddDrop(d)
|
|
}
|
|
|
|
// Helper methods
|
|
func (d *Drop) IsConsumable() bool {
|
|
return d.Type == TypeConsumable
|
|
}
|
|
|
|
func (d *Drop) TypeName() string {
|
|
switch d.Type {
|
|
case TypeConsumable:
|
|
return "Consumable"
|
|
default:
|
|
return "Unknown"
|
|
}
|
|
}
|