feat: turn generate api

internal/controller/cache.go

@@ -28,6 +28,10 @@ func NewCache(g *game.Game) *Cache {
 	return c
 }
 
+func (c *Cache) StageCommand() {
+	c.g.Stage++
+}
+
 func (c Cache) Stage() uint {
 	return c.g.Stage
 }

internal/controller/controller.go

@@ -70,19 +70,31 @@ type Ctrl interface {
 	PlanetRouteRemove(actor, loadType string, origin uint) error
 }
 
-func GenerateGame(configure func(*Param), races []string) (ID uuid.UUID, err error) {
+func GenerateGame(configure func(*Param), races []string) (s game.State, err error) {
 	ec, err := NewRepoController(configure)
 	if err != nil {
-		return uuid.Nil, err
+		return game.State{}, err
 	}
 	if err = ec.Repo.Lock(); err != nil {
 		return
 	}
 	defer func() {
 		err = errors.Join(err, ec.Repo.Release())
+		if err == nil {
+			s, err = GameState(configure)
+		}
 	}()
 
-	ID, err = NewGame(ec.Repo, races)
+	_, err = NewGame(ec.Repo, races)
+	return
+}
+
+func GenerateTurn(configure func(*Param)) (err error) {
+	ec, err := NewRepoController(configure)
+	if err != nil {
+		return err
+	}
+	err = ec.ExecuteLocked(func(c *Controller) error { return c.MakeTurn() })
 	return
 }
 
@@ -96,6 +108,9 @@ func ExecuteCommand(configure func(*Param), consumer func(c Ctrl) error) (err er
 
 func GameState(configure func(*Param)) (s game.State, err error) {
 	ec, err := NewRepoController(configure)
+	if err != nil {
+		return game.State{}, err
+	}
 
 	g, err := ec.Repo.LoadStateSafe()
 	if err != nil {
@@ -123,7 +138,7 @@ type RepoController struct {
 	Repo Repo
 }
 
-func (ec *RepoController) ExecuteCommand(consumer func(c *Controller) error) (err error) {
+func (ec *RepoController) ExecuteLocked(consumer func(*Controller) error) (err error) {
 	if err := ec.Repo.Lock(); err != nil {
 		return err
 	}
@@ -136,15 +151,21 @@ func (ec *RepoController) ExecuteCommand(consumer func(c *Controller) error) (er
 		return err
 	}
 
-	err = consumer(NewGameController(g))
+	err = consumer(ec.NewGameController(g))
-
-	if err == nil {
-		g.Stage += 1
-		ec.Repo.SaveLastState(g)
-	}
 	return
 }
 
+func (ec *RepoController) ExecuteCommand(consumer func(*Controller) error) (err error) {
+	return ec.ExecuteLocked(func(c *Controller) error {
+		err = consumer(c)
+		if err == nil {
+			c.Cache.StageCommand()
+			err = c.saveState()
+		}
+		return err
+	})
+}
+
 func NewRepoController(config Configurer) (*RepoController, error) {
 	c := &Param{
 		StoragePath: ".",
@@ -161,14 +182,19 @@ func NewRepoController(config Configurer) (*RepoController, error) {
 	}, nil
 }
 
-func NewGameController(g *game.Game) *Controller {
+func (ec *RepoController) NewGameController(g *game.Game) *Controller {
 	return &Controller{
+		RepoController: ec,
 		Cache:          NewCache(g),
 	}
 }
 
+func (c *Controller) saveState() error {
+	return c.Repo.SaveLastState(c.Cache.g)
+}
+
 type Controller struct {
-	Repo  Repo
+	*RepoController
 	Cache *Cache
 }
 

internal/controller/controller_test.go

@@ -129,17 +129,19 @@ func newGame() *game.Game {
 }
 
 func newCache() (*controller.Cache, *controller.Controller) {
-	ctl := controller.NewGameController(newGame())
+	ctl := &controller.Controller{
-	c := ctl.Cache
+		RepoController: nil,
-	assertNoError(c.ShipClassCreate(Race_0_idx, Race_0_Gunship, 60, 3, 30, 100, 0))
+		Cache:          controller.NewCache(newGame()),
-	assertNoError(c.ShipClassCreate(Race_0_idx, Race_0_Freighter, 8, 0, 0, 2, 10))
+	}
-	assertNoError(c.ShipClassCreate(Race_0_idx, ShipType_Cruiser, Cruiser.Drive.F(), int(Cruiser.Armament), Cruiser.Weapons.F(), Cruiser.Shields.F(), Cruiser.Cargo.F()))
+	assertNoError(ctl.Cache.ShipClassCreate(Race_0_idx, Race_0_Gunship, 60, 3, 30, 100, 0))
+	assertNoError(ctl.Cache.ShipClassCreate(Race_0_idx, Race_0_Freighter, 8, 0, 0, 2, 10))
+	assertNoError(ctl.Cache.ShipClassCreate(Race_0_idx, ShipType_Cruiser, Cruiser.Drive.F(), int(Cruiser.Armament), Cruiser.Weapons.F(), Cruiser.Shields.F(), Cruiser.Cargo.F()))
 
-	assertNoError(c.ShipClassCreate(Race_1_idx, Race_1_Gunship, 60, 3, 30, 100, 0))
+	assertNoError(ctl.Cache.ShipClassCreate(Race_1_idx, Race_1_Gunship, 60, 3, 30, 100, 0))
-	assertNoError(c.ShipClassCreate(Race_1_idx, Race_1_Freighter, 8, 0, 0, 2, 10))
+	assertNoError(ctl.Cache.ShipClassCreate(Race_1_idx, Race_1_Freighter, 8, 0, 0, 2, 10))
-	assertNoError(c.ShipClassCreate(Race_1_idx, ShipType_Cruiser, 15, 2, 15, 15, 0)) // same name - different type (why.)
+	assertNoError(ctl.Cache.ShipClassCreate(Race_1_idx, ShipType_Cruiser, 15, 2, 15, 15, 0)) // same name - different type (why.)
 
-	return c, ctl
+	return ctl.Cache, ctl
 }
 
 func floatRef(v float64) *game.Float {

internal/controller/generate_game.go

@@ -61,6 +61,7 @@ func buildGameOnMap(races []string, m generator.Map) (*game.Game, error) {
 			ID:      raceID,
 			Name:    races[i],
 			VoteFor: raceID,
+			TTL:     10,
 			Tech:    game.NewTechSet(),
 		}
 		gameMap.Planet = append(gameMap.Planet, NewPlanet(

internal/controller/generate_game_test.go

@@ -3,6 +3,7 @@ package controller_test
 import (
 	"fmt"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/google/uuid"
@@ -41,6 +42,7 @@ func TestNewGame(t *testing.T) {
 	for r := range g.Race {
 		assert.NotEqual(t, uuid.Nil, g.Race[r].ID)
 		assert.Equal(t, players-1, len(g.Race[r].Relations))
+		assert.Equal(t, uint(10), g.Race[r].TTL)
 		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 {
@@ -52,7 +54,13 @@ func TestNewGame(t *testing.T) {
 
 	numShuffled := false
 	for i := range g.Map.Planet {
-		numShuffled = numShuffled || g.Map.Planet[i].Number != uint(i)
+		p := &g.Map.Planet[i]
+		if strings.HasPrefix(p.Name, "HW") || strings.HasPrefix(p.Name, "DW") {
+			assert.True(t, p.Owned())
+			assert.NotNil(t, p.Owner)
+			assert.NotEqual(t, uuid.Nil, *p.Owner)
+		}
+		numShuffled = numShuffled || p.Number != uint(i)
 	}
 	assert.True(t, numShuffled)
 

internal/controller/generate_turn.go

@@ -9,7 +9,7 @@ import (
 	"github.com/iliadenisov/galaxy/internal/model/report"
 )
 
-func MakeTurn(c *Controller, r Repo) error {
+func (c *Controller) MakeTurn() error {
 	// Next turn
 	c.Cache.g.Turn += 1
 	c.Cache.g.Stage = 0
@@ -61,7 +61,7 @@ func MakeTurn(c *Controller, r Repo) error {
 	// Store bombings
 	bombingReport := make([]*report.Bombing, len(bombings))
 	if len(bombings) > 0 {
-		if err := r.SaveBombings(c.Cache.g.Turn, bombings); err != nil {
+		if err := c.Repo.SaveBombings(c.Cache.g.Turn, bombings); err != nil {
 			return err
 		}
 		for i := range bombings {
@@ -101,7 +101,7 @@ func MakeTurn(c *Controller, r Repo) error {
 			}
 
 			report := TransformBattle(c.Cache, b)
-			if err := r.SaveBattle(c.Cache.g.Turn, report, &battleMeta[i]); err != nil {
+			if err := c.Repo.SaveBattle(c.Cache.g.Turn, report, &battleMeta[i]); err != nil {
 				return err
 			}
 			battleReport[i] = report
@@ -112,12 +112,12 @@ func MakeTurn(c *Controller, r Repo) error {
 	c.Cache.DeleteKilledShipGroups()
 
 	// Store game state for the new turn and 'current' state as well
-	if err := r.SaveNewTurn(c.Cache.g.Turn, c.Cache.g); err != nil {
+	if err := c.Repo.SaveNewTurn(c.Cache.g.Turn, c.Cache.g); err != nil {
 		return err
 	}
 
 	for rep := range c.Cache.Report(c.Cache.g.Turn, battleReport, bombingReport) {
-		if err := r.SaveReport(c.Cache.g.Turn, rep); err != nil {
+		if err := c.Repo.SaveReport(c.Cache.g.Turn, rep); err != nil {
 			return err
 		}
 	}

internal/model/rest/init.go

@@ -1,7 +1,5 @@
 package rest
 
-import "github.com/google/uuid"
-
 type Init struct {
 	Races []Race `json:"races" binding:"required,gte=10"`
 }
@@ -9,7 +7,3 @@ type Init struct {
 type Race struct {
 	Name string `json:"name" binding:"required,notblank"`
 }
-
-type InitResponse struct {
-	UUID uuid.UUID `json:"uuid"`
-}

internal/router/handler/handler.go

@@ -7,14 +7,15 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/go-playground/validator/v10"
-	"github.com/google/uuid"
 	"github.com/iliadenisov/galaxy/internal/controller"
 	e "github.com/iliadenisov/galaxy/internal/error"
+	"github.com/iliadenisov/galaxy/internal/model/game"
 	"github.com/iliadenisov/galaxy/internal/model/rest"
 )
 
 type CommandExecutor interface {
-	GenerateGame([]string) (uuid.UUID, error)
+	GenerateGame([]string) (rest.StateResponse, error)
+	GenerateTurn() (rest.StateResponse, error)
 	GameState() (rest.StateResponse, error)
 	Execute(cmd ...Command) error
 }
@@ -50,8 +51,20 @@ func (e *executor) Execute(command ...Command) error {
 	})
 }
 
-func (e *executor) GenerateGame(races []string) (uuid.UUID, error) {
+func (e *executor) GenerateGame(races []string) (rest.StateResponse, error) {
-	return controller.GenerateGame(e.cfg, races)
+	s, err := controller.GenerateGame(e.cfg, races)
+	if err != nil {
+		return rest.StateResponse{}, err
+	}
+	return stateResponse(s), nil
+}
+
+func (e *executor) GenerateTurn() (rest.StateResponse, error) {
+	err := controller.GenerateTurn(e.cfg)
+	if err != nil {
+		return rest.StateResponse{}, err
+	}
+	return e.GameState()
 }
 
 func (e *executor) GameState() (rest.StateResponse, error) {
@@ -59,6 +72,10 @@ func (e *executor) GameState() (rest.StateResponse, error) {
 	if err != nil {
 		return rest.StateResponse{}, err
 	}
+	return stateResponse(s), nil
+}
+
+func stateResponse(s game.State) rest.StateResponse {
 	result := &rest.StateResponse{
 		ID:      s.ID,
 		Turn:    s.Turn,
@@ -70,7 +87,7 @@ func (e *executor) GameState() (rest.StateResponse, error) {
 		result.Players[i].Name = s.Players[i].Name
 		result.Players[i].Extinct = s.Players[i].Extinct
 	}
-	return *result, nil
+	return *result
 }
 
 func errorResponded(c *gin.Context, err error) bool {

internal/router/handler/init.go

@@ -18,12 +18,10 @@ func InitHandler(c *gin.Context, executor CommandExecutor) {
 		races[i] = init.Races[i].Name
 	}
 
-	uuid, err := executor.GenerateGame(races)
+	s, err := executor.GenerateGame(races)
 	if errorResponded(c, err) {
 		return
 	}
 
-	c.JSON(http.StatusCreated, rest.InitResponse{
+	c.JSON(http.StatusCreated, s)
-		UUID: uuid,
-	})
 }

internal/router/handler/turn.go

@@ -0,0 +1,17 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+func TurnHandler(c *gin.Context, executor CommandExecutor) {
+	state, err := executor.GenerateTurn()
+
+	if errorResponded(c, err) {
+		return
+	}
+
+	c.JSON(http.StatusOK, state)
+}

internal/router/init_test.go

@@ -28,9 +28,10 @@ func TestInit(t *testing.T) {
 	r.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusCreated, w.Code, w.Body)
-	var initResponse rest.InitResponse
+	var initResponse rest.StateResponse
 	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &initResponse))
-	assert.NoError(t, uuid.Validate(initResponse.UUID.String()))
+	assert.NoError(t, uuid.Validate(initResponse.ID.String()))
+	assert.NotEqual(t, uuid.Nil, uuid.MustParse(initResponse.ID.String()))
 }
 
 func TestInitValidators(t *testing.T) {

internal/router/router.go

@@ -67,6 +67,7 @@ func setupRouter(executor handler.CommandExecutor) *gin.Engine {
 	groupV1.GET("/status", func(ctx *gin.Context) { handler.StatusHandler(ctx, executor) })
 	groupV1.POST("/init", func(ctx *gin.Context) { handler.InitHandler(ctx, executor) })
 	groupV1.PUT("/command", LimitMiddleware(1), func(ctx *gin.Context) { handler.CommandHandler(ctx, executor) })
+	groupV1.PUT("/turn", func(ctx *gin.Context) { handler.TurnHandler(ctx, executor) })
 
 	return r
 }

internal/router/router_export_test.go

@@ -6,5 +6,6 @@ import (
 )
 
 func SetupRouter(e handler.CommandExecutor) *gin.Engine {
+	gin.SetMode(gin.TestMode)
 	return setupRouter(e)
 }

internal/router/router_helper_test.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 
 	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
 	"github.com/iliadenisov/galaxy/internal/model/rest"
 	"github.com/iliadenisov/galaxy/internal/router"
 	"github.com/iliadenisov/galaxy/internal/router/handler"
@@ -19,8 +18,12 @@ func (e *dummyExecutor) Execute(command ...handler.Command) error {
 	return nil
 }
 
-func (e *dummyExecutor) GenerateGame(races []string) (uuid.UUID, error) {
+func (e *dummyExecutor) GenerateGame(races []string) (rest.StateResponse, error) {
-	return uuid.New(), nil
+	return rest.StateResponse{}, nil
+}
+
+func (e *dummyExecutor) GenerateTurn() (rest.StateResponse, error) {
+	return rest.StateResponse{}, nil
 }
 
 func (e *dummyExecutor) GameState() (rest.StateResponse, error) {
@@ -32,7 +35,6 @@ func setupRouter() *gin.Engine {
 }
 
 func setupRouterExecutor(e handler.CommandExecutor) *gin.Engine {
-	gin.SetMode(gin.TestMode)
 	return router.SetupRouter(e)
 }
 

internal/router/status_test.go

@@ -28,9 +28,10 @@ func TestGetStatus(t *testing.T) {
 	r.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusCreated, w.Code, w.Body)
-	var initResponse rest.InitResponse
+	var initResponse rest.StateResponse
 	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &initResponse))
-	assert.NoError(t, uuid.Validate(initResponse.UUID.String()))
+	assert.NoError(t, uuid.Validate(initResponse.ID.String()))
+	assert.NotEqual(t, uuid.Nil, uuid.MustParse(initResponse.ID.String()))
 
 	w = httptest.NewRecorder()
 	req, _ = http.NewRequest("GET", "/api/v1/status", nil)
@@ -40,6 +41,7 @@ func TestGetStatus(t *testing.T) {
 	var stateResponse rest.StateResponse
 	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &stateResponse))
 	assert.NoError(t, uuid.Validate(stateResponse.ID.String()))
+	assert.Equal(t, initResponse.ID, stateResponse.ID)
 	assert.Equal(t, uint(0), stateResponse.Turn)
 	assert.Equal(t, uint(0), stateResponse.Stage)
 	assert.Len(t, stateResponse.Players, 10)

internal/router/turn_test.go

@@ -0,0 +1,67 @@
+package router_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/iliadenisov/galaxy/internal/controller"
+	"github.com/iliadenisov/galaxy/internal/model/rest"
+	"github.com/iliadenisov/galaxy/internal/router"
+	"github.com/iliadenisov/galaxy/internal/router/handler"
+	"github.com/iliadenisov/galaxy/internal/util"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetTurn(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+
+	r := router.SetupRouter(handler.NewDefaultConfigExecutor(func(p *controller.Param) { p.StoragePath = root }))
+
+	// create game
+
+	payload := generateInitRequest(10)
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("POST", "/api/v1/init", asBody(payload))
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusCreated, w.Code, w.Body)
+	var initResponse rest.StateResponse
+	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &initResponse))
+	assert.NoError(t, uuid.Validate(initResponse.ID.String()))
+	assert.NotEqual(t, uuid.Nil, uuid.MustParse(initResponse.ID.String()))
+	assert.Equal(t, uint(0), initResponse.Turn)
+	assert.Equal(t, uint(0), initResponse.Stage)
+
+	// generate next turn
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("PUT", "/api/v1/turn", nil)
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusOK, w.Code, w.Body)
+
+	var turnResponse rest.StateResponse
+	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &turnResponse))
+	assert.NoError(t, uuid.Validate(turnResponse.ID.String()))
+	assert.Equal(t, initResponse.ID, turnResponse.ID)
+	assert.Equal(t, uint(1), turnResponse.Turn)
+	assert.Equal(t, uint(0), turnResponse.Stage)
+
+	// validate status
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("GET", "/api/v1/status", nil)
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusOK, w.Code, w.Body)
+	var stateResponse rest.StateResponse
+	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &stateResponse))
+	assert.Equal(t, initResponse.ID, stateResponse.ID)
+	assert.Equal(t, uint(1), stateResponse.Turn)
+	assert.Equal(t, uint(0), stateResponse.Stage)
+}