Files

155 lines
5.3 KiB
Go

package store
import (
"aeternalis/server/internal/game"
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"maps"
)
var ErrRevival = errors.New("revival rejected")
type reviveClaim struct{ Account, Character, Corpse, World string }
// A permanent account pointer records the most recently created life, including
// after its death. Repeated deaths never make an older life current again.
func (d *DB) reserveCharacterLife(ctx context.Context, tx *sql.Tx, world string, c *game.Character) error {
if _, e := tx.ExecContext(ctx, d.q(`INSERT INTO account_lives(account_id,character_id) VALUES(?,?) ON CONFLICT(account_id) DO NOTHING`), c.Account, c.View.Entity.ID); e != nil {
return e
}
if _, e := tx.ExecContext(ctx, d.q(`UPDATE account_lives SET character_id=character_id WHERE account_id=?`), c.Account); e != nil {
return e
}
var current string
if e := tx.QueryRowContext(ctx, d.q(`SELECT character_id FROM account_lives WHERE account_id=?`), c.Account).Scan(&current); e != nil {
return e
}
var state, oldWorld string
e := tx.QueryRowContext(ctx, d.q(`SELECT state,world_id FROM character_records WHERE character_id=?`), c.View.Entity.ID).Scan(&state, &oldWorld)
if e != nil && !errors.Is(e, sql.ErrNoRows) {
return e
}
if errors.Is(e, sql.ErrNoRows) && c.View.Entity.State != "dead" {
if _, e = tx.ExecContext(ctx, d.q(`UPDATE account_lives SET character_id=? WHERE account_id=?`), c.View.Entity.ID, c.Account); e != nil {
return e
}
} else if e == nil && oldWorld == world && c.View.Entity.State != "dead" {
if current != c.View.Entity.ID {
return ErrLivingCharacter
}
if state == "dead" {
var revived int
if e = tx.QueryRowContext(ctx, d.q(`SELECT revived FROM character_deaths WHERE corpse_id=? AND character_id=?`), c.RevivalCorpse, c.View.Entity.ID).Scan(&revived); e != nil || revived != 1 {
return ErrRevival
}
}
}
if c.View.Entity.State == "dead" && c.RevivalCorpse != "" {
raw, e := json.Marshal(c)
if e != nil {
return e
}
_, e = tx.ExecContext(ctx, d.q(`INSERT INTO character_deaths(corpse_id,character_id,world_id,character,revived) VALUES(?,?,?,?,0) ON CONFLICT(corpse_id) DO NOTHING`), c.RevivalCorpse, c.View.Entity.ID, world, string(raw))
if e != nil {
return e
}
}
return nil
}
func (d *DB) checkRevival(ctx context.Context, tx *sql.Tx, r *reviveClaim) error {
if _, e := tx.ExecContext(ctx, d.q(`UPDATE account_lives SET character_id=character_id WHERE account_id=?`), r.Account); e != nil {
return e
}
var current string
if e := tx.QueryRowContext(ctx, d.q(`SELECT character_id FROM account_lives WHERE account_id=?`), r.Account).Scan(&current); e != nil {
return e
}
if current != r.Character {
return fmt.Errorf("%w: a replacement character was created", ErrRevival)
}
var state, world, raw string
if e := tx.QueryRowContext(ctx, d.q(`SELECT state,world_id,character FROM character_records WHERE character_id=? AND account_id=?`), r.Character, r.Account).Scan(&state, &world, &raw); e != nil {
return e
}
var dead game.Character
if e := json.Unmarshal([]byte(raw), &dead); e != nil {
return e
}
if state != "dead" || world != r.World || dead.RevivalCorpse != r.Corpse || !dead.RevivalAllowed {
return ErrRevival
}
result, e := tx.ExecContext(ctx, d.q(`UPDATE character_deaths SET revived=1 WHERE corpse_id=? AND character_id=? AND revived=0`), r.Corpse, r.Character)
if e != nil {
return e
}
n, _ := result.RowsAffected()
if n != 1 {
return ErrRevival
}
return nil
}
func (d *DB) RevivalCurrent(ctx context.Context, account, id string) (bool, error) {
var current string
e := d.sql.QueryRowContext(ctx, d.q(`SELECT character_id FROM account_lives WHERE account_id=?`), account).Scan(&current)
if errors.Is(e, sql.ErrNoRows) {
return false, nil
}
return current == id, e
}
func (l *Lease) RevivalConsent(ctx context.Context, w *game.World, account, id string, allowed bool) error {
c := w.Characters[id]
if c == nil || c.Account != account || c.View.Entity.State != "dead" || c.RevivalCorpse == "" || w.Corpses[c.RevivalCorpse] == nil || w.Phase == "lost" {
return ErrRevival
}
current, e := l.DB.RevivalCurrent(ctx, account, id)
if e != nil {
return e
}
if !current {
return ErrRevival
}
staged := stageTitleWorld(w)
staged.Characters[id].RevivalAllowed = allowed
if e = l.Save(ctx, staged, ""); e != nil {
return e
}
for id, c := range staged.Characters {
*w.Characters[id] = *c
}
w.Saved()
return nil
}
func (l *Lease) Revive(ctx context.Context, w *game.World, account, corpse, power string) error {
caster := w.ForAccount(account)
if caster == nil || game.HouseID(caster) != "" {
return ErrRevival
}
active, e := l.DB.ActiveCharacter(ctx, account)
if e != nil {
return e
}
if active == nil || active.ID != caster.View.Entity.ID || active.WorldID != w.ID {
return ErrRevival
}
staged := stageTitleWorld(w)
staged.Corpses = maps.Clone(w.Corpses)
target, e := staged.Revive(staged.Characters[caster.View.Entity.ID], corpse, power)
if e != nil {
return fmt.Errorf("%w: %v", ErrRevival, e)
}
claim := &reviveClaim{target.Account, target.View.Entity.ID, corpse, w.ID}
if e = l.save(ctx, staged, "", nil, "", nil, claim, nil); e != nil {
return e
}
for id, c := range staged.Characters {
*w.Characters[id] = *c
}
w.Corpses = staged.Corpses
w.PendingTitles = nil
w.Saved()
return nil
}