Ilia Denisov
156 lines
3.4 KiB
Go
156 lines
3.4 KiB
Go
package repo
|
|
|
|
/*
|
|
TODO: only state will be saved once (current, turn); meta and bombings are saved at turn generation and saved twice
|
|
/state.json
|
|
/0001/state.json
|
|
/0001/meta.json
|
|
/0001/bombing.json
|
|
/0001/battle/{UUID}.json
|
|
/0001/report/{UUID}.json
|
|
*/
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/iliadenisov/galaxy/internal/model/game"
|
|
"github.com/iliadenisov/galaxy/internal/model/report"
|
|
)
|
|
|
|
const (
|
|
statePath = "state.json"
|
|
metaPath = "meta.json"
|
|
)
|
|
|
|
func (r *repo) SaveTurn(t uint, g *game.Game) error {
|
|
return saveTurn(r.s, t, g)
|
|
}
|
|
|
|
func saveTurn(s Storage, t uint, g *game.Game) error {
|
|
path := fmt.Sprintf("%s/state.json", turnDir(t))
|
|
exist, err := s.Exists(path)
|
|
if err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
if exist {
|
|
return NewStateError(fmt.Sprintf("state for turn %d already saved", t))
|
|
}
|
|
if err := s.Write(path, g); err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
return saveState(s, g) // FIXME: either save it here, or in tre repo controller
|
|
}
|
|
|
|
func (r *repo) SaveState(g *game.Game) error {
|
|
return saveState(r.s, g)
|
|
}
|
|
|
|
func saveState(s Storage, g *game.Game) error {
|
|
if err := s.Write(statePath, g); err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *repo) LoadState() (*game.Game, error) {
|
|
return loadState(r.s, true)
|
|
}
|
|
|
|
func (r *repo) LoadStateSafe() (*game.Game, error) {
|
|
return loadState(r.s, false)
|
|
}
|
|
|
|
func loadState(s Storage, locked bool) (*game.Game, error) {
|
|
var result *game.Game = new(game.Game)
|
|
path := statePath
|
|
exist, err := s.Exists(path)
|
|
if err != nil {
|
|
return nil, NewStorageError(err)
|
|
}
|
|
if !exist {
|
|
return nil, NewGameNotInitializedError()
|
|
}
|
|
if locked {
|
|
if err := s.Read(path, result); err != nil {
|
|
return nil, NewStorageError(err)
|
|
}
|
|
} else {
|
|
if err := s.ReadSafe(path, result); err != nil {
|
|
return nil, NewStorageError(err)
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func loadMeta(s Storage) (*game.GameMeta, error) {
|
|
var result *game.GameMeta = new(game.GameMeta)
|
|
path := metaPath
|
|
exist, err := s.Exists(path)
|
|
if err != nil {
|
|
return nil, NewStorageError(err)
|
|
}
|
|
if !exist {
|
|
return result, nil
|
|
}
|
|
// TODO: create separate Read func for meta ops
|
|
if err := s.ReadSafe(path, result); err != nil {
|
|
return nil, NewStorageError(err)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func saveMeta(s Storage, t uint, gm *game.GameMeta) error {
|
|
// save turn's meta
|
|
path := fmt.Sprintf("%s/%s", turnDir(t), metaPath)
|
|
if err := s.Write(path, gm); err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
// also save as latest meta
|
|
path = metaPath
|
|
if err := s.Write(path, gm); err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *repo) SaveBattle(t uint, b *report.BattleReport, m *game.BattleMeta) error {
|
|
meta, err := loadMeta(r.s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = saveBattle(r.s, t, b)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
meta.Battles = append(meta.Battles, *m)
|
|
return saveMeta(r.s, t, meta)
|
|
}
|
|
|
|
func saveBattle(s Storage, t uint, b *report.BattleReport) error {
|
|
path := fmt.Sprintf("%s/battle/%s.json", turnDir(t), b.ID)
|
|
exist, err := s.Exists(path)
|
|
if err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
if exist {
|
|
return NewStateError(fmt.Sprintf("battle %s for turn %d already has been saved", b.ID, t))
|
|
}
|
|
if err := s.Write(path, b); err != nil {
|
|
return NewStorageError(err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *repo) SaveBombings(t uint, b []report.BombingPlanetReport) error {
|
|
meta, err := loadMeta(r.s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
meta.Bombings = b
|
|
return saveMeta(r.s, t, meta)
|
|
}
|
|
|
|
func turnDir(t uint) string {
|
|
return fmt.Sprintf("%04d", t)
|
|
}
|