155 lines
3.0 KiB
Go
155 lines
3.0 KiB
Go
package drops
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
nigiri "git.sharkk.net/Sharkk/Nigiri"
|
|
)
|
|
|
|
// Drop represents a drop item in the game
|
|
type Drop struct {
|
|
ID int `json:"id"`
|
|
Name string `json:"name" db:"required"`
|
|
Level int `json:"level" db:"index"`
|
|
Type int `json:"type" db:"index"`
|
|
Att string `json:"att"`
|
|
}
|
|
|
|
// DropType constants for drop types
|
|
const (
|
|
TypeConsumable = 1
|
|
)
|
|
|
|
// Global store
|
|
var store *nigiri.BaseStore[Drop]
|
|
var db *nigiri.Collection
|
|
|
|
// Init sets up the Nigiri store and indices
|
|
func Init(collection *nigiri.Collection) {
|
|
db = collection
|
|
store = nigiri.NewBaseStore[Drop]()
|
|
|
|
// Register custom indices
|
|
store.RegisterIndex("byLevel", nigiri.BuildIntGroupIndex(func(d *Drop) int {
|
|
return d.Level
|
|
}))
|
|
|
|
store.RegisterIndex("byType", nigiri.BuildIntGroupIndex(func(d *Drop) int {
|
|
return d.Type
|
|
}))
|
|
|
|
store.RegisterIndex("allByID", nigiri.BuildSortedListIndex(func(a, b *Drop) bool {
|
|
return a.ID < b.ID
|
|
}))
|
|
|
|
store.RebuildIndices()
|
|
}
|
|
|
|
// GetStore returns the drops store
|
|
func GetStore() *nigiri.BaseStore[Drop] {
|
|
if store == nil {
|
|
panic("drops store not initialized - call Initialize first")
|
|
}
|
|
return store
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// CRUD operations
|
|
func (d *Drop) Save() error {
|
|
if d.ID == 0 {
|
|
id, err := store.Create(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.ID = id
|
|
return nil
|
|
}
|
|
return store.Update(d.ID, d)
|
|
}
|
|
|
|
func (d *Drop) Delete() error {
|
|
store.Remove(d.ID)
|
|
return nil
|
|
}
|
|
|
|
// Insert with ID assignment
|
|
func (d *Drop) Insert() error {
|
|
id, err := store.Create(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.ID = id
|
|
return nil
|
|
}
|
|
|
|
// Query functions
|
|
func Find(id int) (*Drop, error) {
|
|
drop, exists := store.Find(id)
|
|
if !exists {
|
|
return nil, fmt.Errorf("drop with ID %d not found", id)
|
|
}
|
|
return drop, nil
|
|
}
|
|
|
|
func All() ([]*Drop, error) {
|
|
return store.AllSorted("allByID"), nil
|
|
}
|
|
|
|
func ByLevel(minLevel int) ([]*Drop, error) {
|
|
return store.FilterByIndex("allByID", func(d *Drop) bool {
|
|
return d.Level <= minLevel
|
|
}), nil
|
|
}
|
|
|
|
func ByType(dropType int) ([]*Drop, error) {
|
|
return store.GroupByIndex("byType", dropType), nil
|
|
}
|
|
|
|
// 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"
|
|
}
|
|
}
|
|
|
|
// Legacy compatibility functions (will be removed later)
|
|
func LoadData(dataPath string) error {
|
|
// No longer needed - Nigiri handles this
|
|
return nil
|
|
}
|
|
|
|
func SaveData(dataPath string) error {
|
|
// No longer needed - Nigiri handles this
|
|
return nil
|
|
}
|