chore: refactor structure

2025-11-21 21:40:15 +03:00
parent 126f381b04
commit 269de2184c
72 changed files with 512 additions and 393 deletions
@@ -0,0 +1,71 @@
+package controller
+
+import (
+	"fmt"
+
+	"github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/iliadenisov/galaxy/internal/repo"
+)
+
+type Repo interface {
+	// Lock must be called before any repository operations
+	Lock() error
+
+	// Release must be called after first and only repository operation
+	Release() error
+
+	// SaveTurn stores just generated new turn
+	SaveTurn(uint, game.Game) error
+
+	// SaveState stores current game state updated between turns
+	SaveState(game.Game) error
+
+	// LoadState retrieves game current state
+	LoadState() (game.Game, error)
+}
+
+type Ctrl struct {
+	param Param
+	Repo  Repo
+}
+
+type Param struct {
+	StoragePath string
+}
+
+func NewController(configure func(*Param)) (*Ctrl, error) {
+	c := &Param{
+		StoragePath: ".",
+	}
+	if configure != nil {
+		configure(c)
+	}
+	r, err := repo.NewFileRepo(c.StoragePath)
+	if err != nil {
+		return nil, err
+	}
+	return &Ctrl{
+		param: *c,
+		Repo:  r,
+	}, nil
+}
+
+func (c *Ctrl) ExecuteInit(consumer func(Repo)) error {
+	if err := c.Repo.Lock(); err != nil {
+		return fmt.Errorf("execute: lock failed: %s", err)
+	}
+	consumer(c.Repo)
+	return c.Repo.Release()
+}
+
+func (c *Ctrl) Execute(consumer func(Repo, game.Game)) error {
+	if err := c.Repo.Lock(); err != nil {
+		return fmt.Errorf("execute: lock failed: %s", err)
+	}
+	g, err := c.Repo.LoadState()
+	if err != nil {
+		return err
+	}
+	consumer(c.Repo, g)
+	return c.Repo.Release()
+}
@@ -0,0 +1,147 @@
+package controller
+
+import (
+	"fmt"
+	"math/rand/v2"
+	"slices"
+
+	"github.com/google/uuid"
+	"github.com/iliadenisov/galaxy/internal/generator"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+)
+
+func NewGame(r Repo, races []string) (uuid.UUID, error) {
+	m, err := generator.Generate(func(ms *generator.MapSetting) {
+		ms.Players = uint32(len(races))
+	})
+	if err != nil {
+		return uuid.Nil, fmt.Errorf("generate map: %s", err)
+	}
+	return newGameOnMap(r, races, m)
+}
+
+func newGameOnMap(r Repo, races []string, m generator.Map) (uuid.UUID, error) {
+	g, err := buildGameOnMap(races, m)
+	if err != nil {
+		return uuid.Nil, err
+	}
+	if err := r.SaveTurn(0, *g); err != nil {
+		return uuid.Nil, err
+	}
+	return g.ID, nil
+}
+
+func buildGameOnMap(races []string, m generator.Map) (*game.Game, error) {
+	if len(races) != len(m.HomePlanets) {
+		return nil, fmt.Errorf("generate map: wrong number of home planets: %d, expected: %d ", len(m.HomePlanets), len(races))
+	}
+	gameID, err := uuid.NewRandom()
+	if err != nil {
+		return nil, fmt.Errorf("generate game uuid: %s", err)
+	}
+	g := &game.Game{
+		ID:   gameID,
+		Race: make([]game.Race, len(races)),
+	}
+	gameMap := &game.Map{
+		Width:  m.Width,
+		Height: m.Height,
+		Planet: make([]game.Planet, 0),
+	}
+	var planetCount uint = 0
+	relations := make([]game.RaceRelation, len(races))
+	for i := range races {
+		raceID, err := uuid.NewRandom()
+		if err != nil {
+			return nil, fmt.Errorf("generate race uuid: %s", err)
+		}
+		relations[i] = game.RaceRelation{RaceID: raceID, Relation: game.RelationWar}
+		g.Race[i] = game.Race{
+			ID:      raceID,
+			Name:    races[i],
+			Vote:    raceID,
+			Drive:   1,
+			Weapons: 1,
+			Shields: 1,
+			Cargo:   1,
+		}
+		gameMap.Planet = append(gameMap.Planet, NewPlanet(
+			planetCount,
+			m.HomePlanets[i].HW.RandomName(),
+			raceID,
+			m.HomePlanets[i].HW.Position.X,
+			m.HomePlanets[i].HW.Position.Y,
+			m.HomePlanets[i].HW.Size,
+			m.HomePlanets[i].HW.Size, // HW's pop & ind = size
+			m.HomePlanets[i].HW.Size,
+			m.HomePlanets[i].HW.Resources,
+			game.ResearchDrive.AsType(uuid.Nil),
+		))
+		planetCount++
+		for dw := range m.HomePlanets[i].DW {
+			gameMap.Planet = append(gameMap.Planet, NewPlanet(
+				planetCount,
+				m.HomePlanets[i].DW[dw].RandomName(),
+				raceID,
+				m.HomePlanets[i].DW[dw].Position.X,
+				m.HomePlanets[i].DW[dw].Position.Y,
+				m.HomePlanets[i].DW[dw].Size,
+				m.HomePlanets[i].DW[dw].Size, // DW's pop & ind = size
+				m.HomePlanets[i].DW[dw].Size,
+				m.HomePlanets[i].DW[dw].Resources,
+				game.ResearchDrive.AsType(uuid.Nil),
+			))
+			planetCount++
+		}
+	}
+	for i := range g.Race {
+		rel := slices.Clone(relations)
+		ri := slices.IndexFunc(rel, func(a game.RaceRelation) bool { return a.RaceID == g.Race[i].ID })
+		g.Race[i].Relations = append(rel[:ri], rel[ri+1:]...)
+	}
+
+	for i := range m.FreePlanets {
+		gameMap.Planet = append(gameMap.Planet, NewPlanet(
+			planetCount,
+			m.FreePlanets[i].RandomName(),
+			uuid.Nil,
+			m.FreePlanets[i].Position.X,
+			m.FreePlanets[i].Position.Y,
+			m.FreePlanets[i].Size,
+			0,
+			0,
+			m.FreePlanets[i].Resources,
+			game.ProductionNone.AsType(uuid.Nil),
+		))
+		planetCount++
+	}
+
+	rand.Shuffle(len(gameMap.Planet), func(i, j int) {
+		gameMap.Planet[i].Number, gameMap.Planet[j].Number = gameMap.Planet[j].Number, gameMap.Planet[i].Number
+	})
+
+	g.Map = *gameMap
+
+	return g, nil
+}
+
+func NewPlanet(num uint, name string, owner uuid.UUID, x, y, size, pop, ind, res float64, prod game.ProductionType) game.Planet {
+	return game.Planet{
+		Owner: owner,
+		PlanetReport: game.PlanetReport{
+			UninhabitedPlanet: game.UninhabitedPlanet{
+				UnidentifiedPlanet: game.UnidentifiedPlanet{
+					X:      x,
+					Y:      y,
+					Number: num,
+				},
+				Size:      size,
+				Name:      name,
+				Resources: res,
+			},
+			Population: pop,
+			Industry:   ind,
+			Production: prod,
+		},
+	}
+}
@@ -0,0 +1,60 @@
+package controller_test
+
+import (
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/game"
+	"github.com/iliadenisov/galaxy/internal/repo"
+	"github.com/iliadenisov/galaxy/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewGame(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+
+	r, err := repo.NewFileRepo(root)
+	assert.NoError(t, err)
+
+	players := 20
+	races := make([]string, players)
+	for i := range players {
+		races[i] = fmt.Sprintf("race_%02d", i)
+	}
+	assert.NoError(t, r.Lock())
+	gameID, err := controller.NewGame(r, races)
+	assert.NoError(t, err)
+
+	assert.FileExists(t, filepath.Join(root, "state.json"))
+	assert.FileExists(t, filepath.Join(root, "000/state.json"))
+
+	g, err := r.LoadState()
+	assert.NoError(t, err)
+	assert.Equal(t, gameID, g.ID)
+	assert.Equal(t, uint(0), g.Age)
+	assert.Equal(t, players, len(g.Race))
+
+	for r := range g.Race {
+		assert.NotEqual(t, uuid.Nil, g.Race[r].ID)
+		assert.Equal(t, players-1, len(g.Race[r].Relations))
+		for i := range g.Race[r].Relations {
+			assert.NotEqual(t, uuid.Nil, g.Race[r].Relations[i].RaceID)
+			if g.Race[r].Relations[i].RaceID == g.Race[r].ID {
+				assert.Fail(t, "race relation with itself")
+			}
+			assert.Equal(t, game.RelationWar, g.Race[r].Relations[i].Relation)
+		}
+	}
+
+	numShuffled := false
+	for i := range g.Map.Planet {
+		numShuffled = numShuffled || g.Map.Planet[i].Number != uint(i)
+	}
+	assert.True(t, numShuffled)
+
+	assert.NoError(t, r.Release())
+}