split builder components out

This commit is contained in:
Sky Johnson 2025-08-08 23:27:35 -05:00
parent 53d131a96e
commit 89af7644ba
6 changed files with 339 additions and 313 deletions

88
internal/drops/builder.go Normal file
View File

@ -0,0 +1,88 @@
package drops
import (
"dk/internal/database"
"fmt"
"zombiezen.com/go/sqlite"
)
// Builder provides a fluent interface for creating drops
type Builder struct {
drop *Drop
db *database.DB
}
// NewBuilder creates a new drop builder
func NewBuilder(db *database.DB) *Builder {
return &Builder{
drop: &Drop{db: db},
db: db,
}
}
// WithName sets the drop name
func (b *Builder) WithName(name string) *Builder {
b.drop.Name = name
return b
}
// WithLevel sets the drop level requirement
func (b *Builder) WithLevel(level int) *Builder {
b.drop.Level = level
return b
}
// WithType sets the drop type
func (b *Builder) WithType(dropType int) *Builder {
b.drop.Type = dropType
return b
}
// WithAtt sets the attributes
func (b *Builder) WithAtt(att string) *Builder {
b.drop.Att = att
return b
}
// Create saves the drop to the database and returns it
func (b *Builder) Create() (*Drop, error) {
// Use a transaction to ensure we can get the ID
var drop *Drop
err := b.db.Transaction(func(tx *database.Tx) error {
query := `INSERT INTO drops (name, level, type, att)
VALUES (?, ?, ?, ?)`
if err := tx.Exec(query, b.drop.Name, b.drop.Level, b.drop.Type, b.drop.Att); err != nil {
return fmt.Errorf("failed to insert drop: %w", err)
}
// Get the last inserted ID within the same transaction
var lastID int
err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
lastID = stmt.ColumnInt(0)
return nil
})
if err != nil {
return fmt.Errorf("failed to get last insert ID: %w", err)
}
// Create the drop with the ID
drop = &Drop{
ID: lastID,
Name: b.drop.Name,
Level: b.drop.Level,
Type: b.drop.Type,
Att: b.drop.Att,
db: b.db,
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to create drop: %w", err)
}
return drop, nil
}

View File

@ -124,86 +124,6 @@ func ByType(db *database.DB, dropType int) ([]*Drop, error) {
return drops, nil
}
// Builder provides a fluent interface for creating drops
type Builder struct {
drop *Drop
db *database.DB
}
// NewBuilder creates a new drop builder
func NewBuilder(db *database.DB) *Builder {
return &Builder{
drop: &Drop{db: db},
db: db,
}
}
// WithName sets the drop name
func (b *Builder) WithName(name string) *Builder {
b.drop.Name = name
return b
}
// WithLevel sets the drop level requirement
func (b *Builder) WithLevel(level int) *Builder {
b.drop.Level = level
return b
}
// WithType sets the drop type
func (b *Builder) WithType(dropType int) *Builder {
b.drop.Type = dropType
return b
}
// WithAtt sets the attributes
func (b *Builder) WithAtt(att string) *Builder {
b.drop.Att = att
return b
}
// Create saves the drop to the database and returns it
func (b *Builder) Create() (*Drop, error) {
// Use a transaction to ensure we can get the ID
var drop *Drop
err := b.db.Transaction(func(tx *database.Tx) error {
query := `INSERT INTO drops (name, level, type, att)
VALUES (?, ?, ?, ?)`
if err := tx.Exec(query, b.drop.Name, b.drop.Level, b.drop.Type, b.drop.Att); err != nil {
return fmt.Errorf("failed to insert drop: %w", err)
}
// Get the last inserted ID within the same transaction
var lastID int
err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
lastID = stmt.ColumnInt(0)
return nil
})
if err != nil {
return fmt.Errorf("failed to get last insert ID: %w", err)
}
// Create the drop with the ID
drop = &Drop{
ID: lastID,
Name: b.drop.Name,
Level: b.drop.Level,
Type: b.drop.Type,
Att: b.drop.Att,
db: b.db,
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to create drop: %w", err)
}
return drop, nil
}
// Save updates an existing drop in the database
func (d *Drop) Save() error {
if d.ID == 0 {

95
internal/items/builder.go Normal file
View File

@ -0,0 +1,95 @@
package items
import (
"dk/internal/database"
"fmt"
"zombiezen.com/go/sqlite"
)
// Builder provides a fluent interface for creating items
type Builder struct {
item *Item
db *database.DB
}
// NewBuilder creates a new item builder
func NewBuilder(db *database.DB) *Builder {
return &Builder{
item: &Item{db: db},
db: db,
}
}
// WithType sets the item type
func (b *Builder) WithType(itemType int) *Builder {
b.item.Type = itemType
return b
}
// WithName sets the item name
func (b *Builder) WithName(name string) *Builder {
b.item.Name = name
return b
}
// WithValue sets the item value
func (b *Builder) WithValue(value int) *Builder {
b.item.Value = value
return b
}
// WithAtt sets the item attack/defense value
func (b *Builder) WithAtt(att int) *Builder {
b.item.Att = att
return b
}
// WithSpecial sets the item special attributes
func (b *Builder) WithSpecial(special string) *Builder {
b.item.Special = special
return b
}
// Create saves the item to the database and returns it
func (b *Builder) Create() (*Item, error) {
// Use a transaction to ensure we can get the ID
var item *Item
err := b.db.Transaction(func(tx *database.Tx) error {
query := `INSERT INTO items (type, name, value, att, special)
VALUES (?, ?, ?, ?, ?)`
if err := tx.Exec(query, b.item.Type, b.item.Name, b.item.Value, b.item.Att, b.item.Special); err != nil {
return fmt.Errorf("failed to insert item: %w", err)
}
// Get the last inserted ID within the same transaction
var lastID int
err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
lastID = stmt.ColumnInt(0)
return nil
})
if err != nil {
return fmt.Errorf("failed to get last insert ID: %w", err)
}
// Create the item with the ID
item = &Item{
ID: lastID,
Type: b.item.Type,
Name: b.item.Name,
Value: b.item.Value,
Att: b.item.Att,
Special: b.item.Special,
db: b.db,
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to create item: %w", err)
}
return item, nil
}

View File

@ -4,6 +4,7 @@ import (
"fmt"
"dk/internal/database"
"zombiezen.com/go/sqlite"
)
@ -104,93 +105,6 @@ func ByType(db *database.DB, itemType int) ([]*Item, error) {
return items, nil
}
// Builder provides a fluent interface for creating items
type Builder struct {
item *Item
db *database.DB
}
// NewBuilder creates a new item builder
func NewBuilder(db *database.DB) *Builder {
return &Builder{
item: &Item{db: db},
db: db,
}
}
// WithType sets the item type
func (b *Builder) WithType(itemType int) *Builder {
b.item.Type = itemType
return b
}
// WithName sets the item name
func (b *Builder) WithName(name string) *Builder {
b.item.Name = name
return b
}
// WithValue sets the item value
func (b *Builder) WithValue(value int) *Builder {
b.item.Value = value
return b
}
// WithAtt sets the item attack/defense value
func (b *Builder) WithAtt(att int) *Builder {
b.item.Att = att
return b
}
// WithSpecial sets the item special attributes
func (b *Builder) WithSpecial(special string) *Builder {
b.item.Special = special
return b
}
// Create saves the item to the database and returns it
func (b *Builder) Create() (*Item, error) {
// Use a transaction to ensure we can get the ID
var item *Item
err := b.db.Transaction(func(tx *database.Tx) error {
query := `INSERT INTO items (type, name, value, att, special)
VALUES (?, ?, ?, ?, ?)`
if err := tx.Exec(query, b.item.Type, b.item.Name, b.item.Value, b.item.Att, b.item.Special); err != nil {
return fmt.Errorf("failed to insert item: %w", err)
}
// Get the last inserted ID within the same transaction
var lastID int
err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
lastID = stmt.ColumnInt(0)
return nil
})
if err != nil {
return fmt.Errorf("failed to get last insert ID: %w", err)
}
// Create the item with the ID
item = &Item{
ID: lastID,
Type: b.item.Type,
Name: b.item.Name,
Value: b.item.Value,
Att: b.item.Att,
Special: b.item.Special,
db: b.db,
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to create item: %w", err)
}
return item, nil
}
// Save updates an existing item in the database
func (i *Item) Save() error {
if i.ID == 0 {

View File

@ -0,0 +1,117 @@
package monsters
import (
"dk/internal/database"
"fmt"
"zombiezen.com/go/sqlite"
)
// Builder provides a fluent interface for creating monsters
type Builder struct {
monster *Monster
db *database.DB
}
// NewBuilder creates a new monster builder
func NewBuilder(db *database.DB) *Builder {
return &Builder{
monster: &Monster{db: db},
db: db,
}
}
// WithName sets the monster name
func (b *Builder) WithName(name string) *Builder {
b.monster.Name = name
return b
}
// WithMaxHP sets the monster's maximum hit points
func (b *Builder) WithMaxHP(maxHP int) *Builder {
b.monster.MaxHP = maxHP
return b
}
// WithMaxDmg sets the monster's maximum damage
func (b *Builder) WithMaxDmg(maxDmg int) *Builder {
b.monster.MaxDmg = maxDmg
return b
}
// WithArmor sets the monster's armor value
func (b *Builder) WithArmor(armor int) *Builder {
b.monster.Armor = armor
return b
}
// WithLevel sets the monster's level
func (b *Builder) WithLevel(level int) *Builder {
b.monster.Level = level
return b
}
// WithMaxExp sets the monster's maximum experience reward
func (b *Builder) WithMaxExp(maxExp int) *Builder {
b.monster.MaxExp = maxExp
return b
}
// WithMaxGold sets the monster's maximum gold reward
func (b *Builder) WithMaxGold(maxGold int) *Builder {
b.monster.MaxGold = maxGold
return b
}
// WithImmunity sets the monster's immunity type
func (b *Builder) WithImmunity(immunity int) *Builder {
b.monster.Immune = immunity
return b
}
// Create saves the monster to the database and returns it
func (b *Builder) Create() (*Monster, error) {
// Use a transaction to ensure we can get the ID
var monster *Monster
err := b.db.Transaction(func(tx *database.Tx) error {
query := `INSERT INTO monsters (name, max_hp, max_dmg, armor, level, max_exp, max_gold, immune)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
if err := tx.Exec(query, b.monster.Name, b.monster.MaxHP, b.monster.MaxDmg, b.monster.Armor,
b.monster.Level, b.monster.MaxExp, b.monster.MaxGold, b.monster.Immune); err != nil {
return fmt.Errorf("failed to insert monster: %w", err)
}
// Get the last inserted ID within the same transaction
var lastID int
err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
lastID = stmt.ColumnInt(0)
return nil
})
if err != nil {
return fmt.Errorf("failed to get last insert ID: %w", err)
}
// Create the monster with the ID
monster = &Monster{
ID: lastID,
Name: b.monster.Name,
MaxHP: b.monster.MaxHP,
MaxDmg: b.monster.MaxDmg,
Armor: b.monster.Armor,
Level: b.monster.Level,
MaxExp: b.monster.MaxExp,
MaxGold: b.monster.MaxGold,
Immune: b.monster.Immune,
db: b.db,
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to create monster: %w", err)
}
return monster, nil
}

View File

@ -4,6 +4,7 @@ import (
"fmt"
"dk/internal/database"
"zombiezen.com/go/sqlite"
)
@ -24,9 +25,9 @@ type Monster struct {
// Immunity constants for monster immunity types
const (
ImmuneNone = 0
ImmuneHurt = 1 // Immune to Hurt spells
ImmuneSleep = 2 // Immune to Sleep spells
ImmuneNone = 0
ImmuneHurt = 1 // Immune to Hurt spells
ImmuneSleep = 2 // Immune to Sleep spells
)
// Find retrieves a monster by ID
@ -174,115 +175,6 @@ func ByImmunity(db *database.DB, immunityType int) ([]*Monster, error) {
return monsters, nil
}
// Builder provides a fluent interface for creating monsters
type Builder struct {
monster *Monster
db *database.DB
}
// NewBuilder creates a new monster builder
func NewBuilder(db *database.DB) *Builder {
return &Builder{
monster: &Monster{db: db},
db: db,
}
}
// WithName sets the monster name
func (b *Builder) WithName(name string) *Builder {
b.monster.Name = name
return b
}
// WithMaxHP sets the monster's maximum hit points
func (b *Builder) WithMaxHP(maxHP int) *Builder {
b.monster.MaxHP = maxHP
return b
}
// WithMaxDmg sets the monster's maximum damage
func (b *Builder) WithMaxDmg(maxDmg int) *Builder {
b.monster.MaxDmg = maxDmg
return b
}
// WithArmor sets the monster's armor value
func (b *Builder) WithArmor(armor int) *Builder {
b.monster.Armor = armor
return b
}
// WithLevel sets the monster's level
func (b *Builder) WithLevel(level int) *Builder {
b.monster.Level = level
return b
}
// WithMaxExp sets the monster's maximum experience reward
func (b *Builder) WithMaxExp(maxExp int) *Builder {
b.monster.MaxExp = maxExp
return b
}
// WithMaxGold sets the monster's maximum gold reward
func (b *Builder) WithMaxGold(maxGold int) *Builder {
b.monster.MaxGold = maxGold
return b
}
// WithImmunity sets the monster's immunity type
func (b *Builder) WithImmunity(immunity int) *Builder {
b.monster.Immune = immunity
return b
}
// Create saves the monster to the database and returns it
func (b *Builder) Create() (*Monster, error) {
// Use a transaction to ensure we can get the ID
var monster *Monster
err := b.db.Transaction(func(tx *database.Tx) error {
query := `INSERT INTO monsters (name, max_hp, max_dmg, armor, level, max_exp, max_gold, immune)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
if err := tx.Exec(query, b.monster.Name, b.monster.MaxHP, b.monster.MaxDmg, b.monster.Armor,
b.monster.Level, b.monster.MaxExp, b.monster.MaxGold, b.monster.Immune); err != nil {
return fmt.Errorf("failed to insert monster: %w", err)
}
// Get the last inserted ID within the same transaction
var lastID int
err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
lastID = stmt.ColumnInt(0)
return nil
})
if err != nil {
return fmt.Errorf("failed to get last insert ID: %w", err)
}
// Create the monster with the ID
monster = &Monster{
ID: lastID,
Name: b.monster.Name,
MaxHP: b.monster.MaxHP,
MaxDmg: b.monster.MaxDmg,
Armor: b.monster.Armor,
Level: b.monster.Level,
MaxExp: b.monster.MaxExp,
MaxGold: b.monster.MaxGold,
Immune: b.monster.Immune,
db: b.db,
}
return nil
})
if err != nil {
return nil, fmt.Errorf("failed to create monster: %w", err)
}
return monster, nil
}
// Save updates an existing monster in the database
func (m *Monster) Save() error {
if m.ID == 0 {