refactor: func naming

internal/controller/battle_test.go

@@ -134,11 +134,11 @@ func TestProduceBattles(t *testing.T) {
 	race_C_idx, _ := c.AddRace(race_C_name)
 	race_D_idx, _ := c.AddRace(race_D_name)
 
-	assert.NoError(t, g.UpdateRelation(Race_0.Name, Race_1.Name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.Name, game.RelationWar.String()))
-	assert.NoError(t, g.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
 
-	assert.NoError(t, g.UpdateRelation(race_C_name, race_D_name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(race_C_name, race_D_name, game.RelationWar.String()))
-	assert.NoError(t, g.UpdateRelation(race_D_name, race_C_name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(race_D_name, race_C_name, game.RelationWar.String()))
 
 	assert.Equal(t, game.RelationPeace, c.Relation(Race_0_idx, race_C_idx))
 	assert.Equal(t, game.RelationPeace, c.Relation(Race_1_idx, race_C_idx))

internal/controller/bombing_test.go

@@ -37,8 +37,8 @@ func TestBombPlanet(t *testing.T) {
 func TestCollectBombingGroups(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.UpdateRelation(Race_0.Name, Race_1.Name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.Name, game.RelationWar.String()))
-	assert.NoError(t, g.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
 
 	// 1: idx = 0 / Ready to bomb: Race_1/Planet_1
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 2)) // bombs
@@ -82,7 +82,7 @@ func TestCollectBombingGroups(t *testing.T) {
 	assert.Equal(t, 1, bg[R0_Planet_2_num][Race_1_idx][0])
 
 	// remove bombings from Race_1
-	assert.NoError(t, g.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationPeace.String()))
+	assert.NoError(t, g.RaceRelation(Race_1.Name, Race_0.Name, game.RelationPeace.String()))
 	bg = c.CollectBombingGroups()
 	assert.Len(t, bg, 1)
 	assert.Contains(t, bg, R1_Planet_1_num)
@@ -95,8 +95,8 @@ func TestCollectBombingGroups(t *testing.T) {
 func TestProduceBombings(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.UpdateRelation(Race_0.Name, Race_1.Name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.Name, game.RelationWar.String()))
-	assert.NoError(t, g.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
+	assert.NoError(t, g.RaceRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
 
 	// 1: idx = 0 / Bombs on: Race_1/Planet_1
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 3))
@@ -110,10 +110,10 @@ func TestProduceBombings(t *testing.T) {
 	c.ShipGroup(2).Destination = R0_Planet_2_num
 	c.MustPlanet(R0_Planet_2_num).Population = 500
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "CAP", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", R0_Planet_2_num, R0_Planet_0_num))
 	assert.NotEmpty(t, c.MustPlanet(R0_Planet_2_num).Route)
 
-	assert.NoError(t, g.SetRoute(Race_1.Name, "EMP", R1_Planet_1_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "EMP", R1_Planet_1_num, R0_Planet_2_num))
 	assert.NotEmpty(t, c.MustPlanet(R1_Planet_1_num).Route)
 
 	reports := c.ProduceBombings()

internal/controller/command.go

@@ -16,7 +16,7 @@ func (c Controller) RaceID(actor string) (uuid.UUID, error) {
 	return c.Cache.g.Race[ri].ID, nil
 }
 
-func (c Controller) QuitGame(actor string) error {
+func (c Controller) RaceQuit(actor string) error {
 	ri, err := c.Cache.validRace(actor)
 	if err != nil {
 		return err
@@ -25,7 +25,7 @@ func (c Controller) QuitGame(actor string) error {
 	return nil
 }
 
-func (c Controller) GiveVotes(actor, acceptor string) error {
+func (c Controller) RaceVote(actor, acceptor string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -38,7 +38,7 @@ func (c Controller) GiveVotes(actor, acceptor string) error {
 	return nil
 }
 
-func (c Controller) UpdateRelation(actor, acceptor string, v string) error {
+func (c Controller) RaceRelation(actor, acceptor string, v string) error {
 	rel, ok := game.ParseRelation(v)
 	if !ok {
 		return e.NewUnknownRelationError(v)
@@ -54,7 +54,7 @@ func (c Controller) UpdateRelation(actor, acceptor string, v string) error {
 	return c.Cache.UpdateRelation(ri, other, rel)
 }
 
-func (c *Controller) CreateShipType(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error {
+func (c *Controller) ShipClassCreate(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -62,7 +62,7 @@ func (c *Controller) CreateShipType(actor, typeName string, drive float64, ammo
 	return c.Cache.ShipClassCreate(ri, typeName, drive, ammo, weapons, shileds, cargo)
 }
 
-func (c *Controller) MergeShipType(actor, name, targetName string) error {
+func (c *Controller) ShipClassMerge(actor, name, targetName string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -70,7 +70,7 @@ func (c *Controller) MergeShipType(actor, name, targetName string) error {
 	return c.Cache.shipClassMerge(ri, name, targetName)
 }
 
-func (c *Controller) DeleteShipType(actor, typeName string) error {
+func (c *Controller) ShipClassRemove(actor, typeName string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -78,7 +78,7 @@ func (c *Controller) DeleteShipType(actor, typeName string) error {
 	return c.Cache.shipClassRemove(ri, typeName)
 }
 
-func (c *Controller) LoadCargo(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error {
+func (c *Controller) ShipGroupLoad(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -90,7 +90,7 @@ func (c *Controller) LoadCargo(actor string, groupIndex uint, cargoType string,
 	return c.Cache.shipGroupLoad(ri, groupIndex, ct, ships, quantity)
 }
 
-func (c *Controller) UnloadCargo(actor string, groupIndex uint, ships uint, quantity float64) error {
+func (c *Controller) ShipGroupUnload(actor string, groupIndex uint, ships uint, quantity float64) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -98,7 +98,7 @@ func (c *Controller) UnloadCargo(actor string, groupIndex uint, ships uint, quan
 	return c.Cache.shipGroupUnload(ri, groupIndex, ships, quantity)
 }
 
-func (c *Controller) SendGroup(actor string, groupIndex, planetNumber, quantity uint) error {
+func (c *Controller) ShipGroupSend(actor string, groupIndex, planetNumber, quantity uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -106,7 +106,7 @@ func (c *Controller) SendGroup(actor string, groupIndex, planetNumber, quantity
 	return c.Cache.shipGroupSend(ri, groupIndex, planetNumber, quantity)
 }
 
-func (c *Controller) UpgradeGroup(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error {
+func (c *Controller) ShipGroupUpgrade(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -114,7 +114,7 @@ func (c *Controller) UpgradeGroup(actor string, groupIndex uint, techInput strin
 	return c.Cache.shipGroupUpgrade(ri, groupIndex, techInput, limitShips, limitLevel)
 }
 
-func (c *Controller) JoinEqualGroups(actor string) error {
+func (c *Controller) ShipGroupMerge(actor string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -123,7 +123,7 @@ func (c *Controller) JoinEqualGroups(actor string) error {
 	return nil
 }
 
-func (c *Controller) BreakGroup(actor string, groupIndex, quantity uint) error {
+func (c *Controller) ShipGroupBreak(actor string, groupIndex, quantity uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -131,7 +131,7 @@ func (c *Controller) BreakGroup(actor string, groupIndex, quantity uint) error {
 	return c.Cache.ShipGroupBreak(ri, groupIndex, quantity)
 }
 
-func (c *Controller) DisassembleGroup(actor string, groupIndex, quantity uint) error {
+func (c *Controller) ShipGroupDismantle(actor string, groupIndex, quantity uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -139,7 +139,7 @@ func (c *Controller) DisassembleGroup(actor string, groupIndex, quantity uint) e
 	return c.Cache.shipGroupDismantle(ri, groupIndex, quantity)
 }
 
-func (c *Controller) TransferGroup(actor, acceptor string, groupIndex, quantity uint) error {
+func (c *Controller) ShipGroupTransfer(actor, acceptor string, groupIndex, quantity uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -151,7 +151,7 @@ func (c *Controller) TransferGroup(actor, acceptor string, groupIndex, quantity
 	return c.Cache.shipGroupTransfer(ri, riAccept, groupIndex, quantity)
 }
 
-func (c *Controller) JoinShipGroupToFleet(actor, fleetName string, group, count uint) error {
+func (c *Controller) ShipGroupJoinFleet(actor, fleetName string, group, count uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -159,7 +159,7 @@ func (c *Controller) JoinShipGroupToFleet(actor, fleetName string, group, count
 	return c.Cache.ShipGroupJoinFleet(ri, fleetName, group, count)
 }
 
-func (c *Controller) JoinFleets(actor, fleetSourceName, fleetTargetName string) error {
+func (c *Controller) FleetMerge(actor, fleetSourceName, fleetTargetName string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -167,7 +167,7 @@ func (c *Controller) JoinFleets(actor, fleetSourceName, fleetTargetName string)
 	return c.Cache.fleetMerge(ri, fleetSourceName, fleetTargetName)
 }
 
-func (c *Controller) SendFleet(actor, fleetName string, planetNumber uint) error {
+func (c *Controller) FleetSend(actor, fleetName string, planetNumber uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -179,7 +179,7 @@ func (c *Controller) SendFleet(actor, fleetName string, planetNumber uint) error
 	return c.Cache.FleetSend(ri, fi, planetNumber)
 }
 
-func (c *Controller) CreateScience(actor, typeName string, drive, weapons, shields, cargo float64) error {
+func (c *Controller) ScienceCreate(actor, typeName string, drive, weapons, shields, cargo float64) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -187,7 +187,7 @@ func (c *Controller) CreateScience(actor, typeName string, drive, weapons, shiel
 	return c.Cache.ScienceCreate(ri, typeName, drive, weapons, shields, cargo)
 }
 
-func (c *Controller) DeleteScience(actor, typeName string) error {
+func (c *Controller) ScienceRemove(actor, typeName string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -195,7 +195,7 @@ func (c *Controller) DeleteScience(actor, typeName string) error {
 	return c.Cache.ScienceRemove(ri, typeName)
 }
 
-func (c *Controller) RenamePlanet(actor string, planetNumber int, typeName string) error {
+func (c *Controller) PlanetRename(actor string, planetNumber int, typeName string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -203,7 +203,7 @@ func (c *Controller) RenamePlanet(actor string, planetNumber int, typeName strin
 	return c.Cache.PlanetRename(ri, planetNumber, typeName)
 }
 
-func (c *Controller) PlanetProduction(actor string, planetNumber int, prodType, subject string) error {
+func (c *Controller) PlanetProduce(actor string, planetNumber int, prodType, subject string) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -232,7 +232,7 @@ func (c *Controller) PlanetProduction(actor string, planetNumber int, prodType,
 	return c.Cache.PlanetProduce(ri, planetNumber, prod, subject)
 }
 
-func (c *Controller) SetRoute(actor, loadType string, origin, destination uint) error {
+func (c *Controller) PlanetRouteSet(actor, loadType string, origin, destination uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err
@@ -244,7 +244,7 @@ func (c *Controller) SetRoute(actor, loadType string, origin, destination uint)
 	return c.Cache.PlanetRouteSet(ri, rt, origin, destination)
 }
 
-func (c *Controller) RemoveRoute(actor, loadType string, origin uint) error {
+func (c *Controller) PlanetRouteRemove(actor, loadType string, origin uint) error {
 	ri, err := c.Cache.validActor(actor)
 	if err != nil {
 		return err

internal/controller/controller.go

@@ -45,29 +45,29 @@ type Repo interface {
 
 type Ctrl interface {
 	RaceID(actor string) (uuid.UUID, error)
-	QuitGame(actor string) error
+	RaceQuit(actor string) error
-	GiveVotes(actor, acceptor string) error
+	RaceVote(actor, acceptor string) error
-	UpdateRelation(actor, acceptor string, rel string) error
+	RaceRelation(actor, acceptor string, rel string) error
-	JoinShipGroupToFleet(actor, fleetName string, group, count uint) error
+	ShipClassCreate(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error
-	JoinFleets(actor, fleetSourceName, fleetTargetName string) error
+	ShipClassMerge(actor, name, targetName string) error
-	SendFleet(actor, fleetName string, planetNumber uint) error
+	ShipClassRemove(actor, typeName string) error
-	RenamePlanet(actor string, planetNumber int, typeName string) error
+	ShipGroupLoad(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error
-	PlanetProduction(actor string, planetNumber int, prodType, subject string) error
+	ShipGroupUnload(actor string, groupIndex uint, ships uint, quantity float64) error
-	SetRoute(actor, loadType string, origin, destination uint) error
+	ShipGroupSend(actor string, groupIndex, planetNumber, quantity uint) error
-	RemoveRoute(actor, loadType string, origin uint) error
+	ShipGroupUpgrade(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error
-	CreateScience(actor, typeName string, drive, weapons, shields, cargo float64) error
+	ShipGroupBreak(actor string, groupIndex, quantity uint) error
-	DeleteScience(actor, typeName string) error
+	ShipGroupMerge(actor string) error
-	CreateShipType(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error
+	ShipGroupDismantle(actor string, groupIndex, quantity uint) error
-	MergeShipType(actor, name, targetName string) error
+	ShipGroupTransfer(actor, acceptor string, groupIndex, quantity uint) error
-	DeleteShipType(actor, typeName string) error
+	ShipGroupJoinFleet(actor, fleetName string, group, count uint) error
-	SendGroup(actor string, groupIndex, planetNumber, quantity uint) error
+	FleetMerge(actor, fleetSourceName, fleetTargetName string) error
-	UpgradeGroup(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error
+	FleetSend(actor, fleetName string, planetNumber uint) error
-	JoinEqualGroups(actor string) error
+	ScienceCreate(actor, typeName string, drive, weapons, shields, cargo float64) error
-	BreakGroup(actor string, groupIndex, quantity uint) error
+	ScienceRemove(actor, typeName string) error
-	DisassembleGroup(actor string, groupIndex, quantity uint) error
+	PlanetRename(actor string, planetNumber int, typeName string) error
-	LoadCargo(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error
+	PlanetProduce(actor string, planetNumber int, prodType, subject string) error
-	UnloadCargo(actor string, groupIndex uint, ships uint, quantity float64) error
+	PlanetRouteSet(actor, loadType string, origin, destination uint) error
-	TransferGroup(actor, acceptor string, groupIndex, quantity uint) error
+	PlanetRouteRemove(actor, loadType string, origin uint) error
 }
 
 func GenerateGame(configure func(*Param), races []string) (ID uuid.UUID, err error) {

internal/controller/fleet_send_test.go

@@ -9,14 +9,14 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSendFleet(t *testing.T) {
+func TestFleetSend(t *testing.T) {
 	c, g := newCache()
 	// group #1 - in_orbit Planet_0
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 1))
 	// group #2 - in_space (later)
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 3))
 	// group #3 - in_orbit Planet_0, unmovable
-	g.CreateShipType(Race_0.Name, "Fortress", 0, 50, 30, 100, 0)
+	g.ShipClassCreate(Race_0.Name, "Fortress", 0, 50, 30, 100, 0)
 	assert.NoError(t, c.CreateShips(Race_0_idx, "Fortress", R0_Planet_0_num, 1))
 	// group #4 - in_orbit Planet_0
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 2))
@@ -29,57 +29,57 @@ func TestSendFleet(t *testing.T) {
 	fleetUnmovable := "R0_Fleet_unmovable"
 	fleetUnmovable2 := "R0_Fleet_unmovable2"
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetSending, 1, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetSending, 1, 0))
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 1)
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetSending, 3, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetSending, 3, 0))
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 1)
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetInSpace, 2, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetInSpace, 2, 0))
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 2)
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetUnmovable, 3, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetUnmovable, 3, 0))
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 3)
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetUnmovable2, 4, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetUnmovable2, 4, 0))
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 4)
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetUnmovable, 4, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetUnmovable, 4, 0))
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 3)
 
 	// group #2 - in_space
 	c.ShipGroup(1).StateInSpace = &InSpace
 
 	assert.ErrorContains(t,
-		g.SendFleet(UnknownRace, fleetSending, 2),
+		g.FleetSend(UnknownRace, fleetSending, 2),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.SendFleet(Race_Extinct.Name, fleetSending, 2),
+		g.FleetSend(Race_Extinct.Name, fleetSending, 2),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.SendFleet(Race_0.Name, "UnknownFleet", 2),
+		g.FleetSend(Race_0.Name, "UnknownFleet", 2),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.SendFleet(Race_0.Name, fleetInSpace, 2),
+		g.FleetSend(Race_0.Name, fleetInSpace, 2),
 		e.GenericErrorText(e.ErrShipsBusy))
 	assert.ErrorContains(t,
-		g.SendFleet(Race_0.Name, fleetSending, 200),
+		g.FleetSend(Race_0.Name, fleetSending, 200),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.SendFleet(Race_0.Name, fleetSending, 3),
+		g.FleetSend(Race_0.Name, fleetSending, 3),
 		e.GenericErrorText(e.ErrSendUnreachableDestination))
 	assert.ErrorContains(t,
-		g.SendFleet(Race_0.Name, fleetUnmovable, 2),
+		g.FleetSend(Race_0.Name, fleetUnmovable, 2),
 		e.GenericErrorText(e.ErrSendShipHasNoDrives))
 
-	assert.NoError(t, g.SendFleet(Race_0.Name, fleetSending, 2))
+	assert.NoError(t, g.FleetSend(Race_0.Name, fleetSending, 2))
 	fleetState := c.FleetState(c.MustFleetID(Race_0_idx, fleetSending))
 	assert.Equal(t, game.StateLaunched, fleetState.State)
 	for sg := range c.FleetGroups(Race_0_idx, c.MustFleetIndex(c.MustFleetID(Race_0_idx, fleetSending))) {
 		assert.Equal(t, game.StateLaunched, sg.State())
 	}
 
-	assert.NoError(t, g.SendFleet(Race_0.Name, fleetSending, 0))
+	assert.NoError(t, g.FleetSend(Race_0.Name, fleetSending, 0))
 	fleetState = c.FleetState(c.MustFleetID(Race_0_idx, fleetSending))
 	assert.Equal(t, game.StateInOrbit, fleetState.State)
 	for sg := range c.FleetGroups(Race_0_idx, c.MustFleetIndex(c.MustFleetID(Race_0_idx, fleetSending))) {

internal/controller/fleet_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestJoinShipGroupToFleet(t *testing.T) {
+func TestShipGroupJoinFleet(t *testing.T) {
 	c, g := newCache()
 	var groupIndex uint = 1
 
@@ -18,31 +18,31 @@ func TestJoinShipGroupToFleet(t *testing.T) {
 	fleetTwo := "R0_Fleet_two"
 
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_0.Name, BadEntityName, groupIndex, 0),
+		g.ShipGroupJoinFleet(Race_0.Name, BadEntityName, groupIndex, 0),
 		e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
 
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_0.Name, "Unnamed", groupIndex, 0),
+		g.ShipGroupJoinFleet(Race_0.Name, "Unnamed", groupIndex, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 
 	// creating ShipGroup
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 5))
 
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(UnknownRace, fleetOne, groupIndex, 0),
+		g.ShipGroupJoinFleet(UnknownRace, fleetOne, groupIndex, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_Extinct.Name, fleetOne, groupIndex, 0),
+		g.ShipGroupJoinFleet(Race_Extinct.Name, fleetOne, groupIndex, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_0.Name, "Unnamed", groupIndex, 6),
+		g.ShipGroupJoinFleet(Race_0.Name, "Unnamed", groupIndex, 6),
 		e.GenericErrorText(e.ErrJoinFleetGroupNumberNotEnough))
 
 	// ensure race has no Fleets
 	assert.Len(t, slices.Collect(c.ListFleets(Race_0_idx)), 0)
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetOne, groupIndex, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetOne, groupIndex, 0))
 	fleets := slices.Collect(c.ListFleets(Race_0_idx))
 	groups := slices.Collect(c.RaceShipGroups(Race_0_idx))
 	assert.Len(t, groups, 1)
@@ -58,7 +58,7 @@ func TestJoinShipGroupToFleet(t *testing.T) {
 	// create another ShipGroup
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 3))
 	groupIndex = 2
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetTwo, groupIndex, 2))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetTwo, groupIndex, 2))
 	fleets = slices.Collect(c.ListFleets(Race_0_idx))
 	groups = slices.Collect(c.RaceShipGroups(Race_0_idx))
 	assert.Len(t, groups, 3)
@@ -80,7 +80,7 @@ func TestJoinShipGroupToFleet(t *testing.T) {
 	assert.Equal(t, uint(2), groups[gi].Index)
 
 	groupIndex = groups[gi].Index
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetOne, groupIndex, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetOne, groupIndex, 0))
 	fleets = slices.Collect(c.ListFleets(Race_0_idx))
 	assert.Len(t, fleets, 2)
 	groups = slices.Collect(c.RaceShipGroups(Race_0_idx))
@@ -94,7 +94,7 @@ func TestJoinShipGroupToFleet(t *testing.T) {
 	gi = 3
 	c.ShipGroup(gi).StateInSpace = &InSpace
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_0.Name, fleetOne, c.ShipGroup(gi).Index, 0),
+		g.ShipGroupJoinFleet(Race_0.Name, fleetOne, c.ShipGroup(gi).Index, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 	c.ShipGroup(gi).StateInSpace = nil
 
@@ -102,11 +102,11 @@ func TestJoinShipGroupToFleet(t *testing.T) {
 	c.ShipGroup(0).StateInSpace = &InSpace
 	c.ShipGroup(1).StateInSpace = c.ShipGroup(0).StateInSpace
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_0.Name, fleetOne, c.ShipGroup(gi).Index, 0),
+		g.ShipGroupJoinFleet(Race_0.Name, fleetOne, c.ShipGroup(gi).Index, 0),
 		e.GenericErrorText(e.ErrShipsNotOnSamePlanet))
 }
 
-func TestJoinFleets(t *testing.T) {
+func TestFleetMerge(t *testing.T) {
 	c, g := newCache()
 	// creating ShipGroup #1 at Planet_0
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 1)) // group #1
@@ -123,34 +123,34 @@ func TestJoinFleets(t *testing.T) {
 	fleetTargetTwo := "R0_Fleet_two"
 
 	assert.ErrorContains(t,
-		g.JoinFleets(Race_0.Name, fleetSourceOne, fleetTargetTwo),
+		g.FleetMerge(Race_0.Name, fleetSourceOne, fleetTargetTwo),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.JoinFleets(UnknownRace, fleetSourceOne, fleetTargetTwo),
+		g.FleetMerge(UnknownRace, fleetSourceOne, fleetTargetTwo),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.JoinFleets(Race_Extinct.Name, fleetSourceOne, fleetTargetTwo),
+		g.FleetMerge(Race_Extinct.Name, fleetSourceOne, fleetTargetTwo),
 		e.GenericErrorText(e.ErrRaceExinct))
 
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(UnknownRace, fleetSourceOne, 1, 0),
+		g.ShipGroupJoinFleet(UnknownRace, fleetSourceOne, 1, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.JoinShipGroupToFleet(Race_Extinct.Name, fleetSourceOne, 1, 0),
+		g.ShipGroupJoinFleet(Race_Extinct.Name, fleetSourceOne, 1, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetSourceOne, 1, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetSourceOne, 1, 0))
 
 	assert.ErrorContains(t,
-		g.JoinFleets(Race_0.Name, fleetSourceOne, fleetTargetTwo),
+		g.FleetMerge(Race_0.Name, fleetSourceOne, fleetTargetTwo),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetTargetTwo, 3, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetTargetTwo, 3, 0))
-	assert.NoError(t, g.JoinFleets(Race_0.Name, fleetSourceOne, fleetTargetTwo))
+	assert.NoError(t, g.FleetMerge(Race_0.Name, fleetSourceOne, fleetTargetTwo))
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetOnPlanet2, 2, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetOnPlanet2, 2, 0))
 
 	assert.ErrorContains(t,
-		g.JoinFleets(Race_0.Name, fleetOnPlanet2, fleetTargetTwo),
+		g.FleetMerge(Race_0.Name, fleetOnPlanet2, fleetTargetTwo),
 		e.GenericErrorText(e.ErrShipsNotOnSamePlanet))
 }
 
@@ -168,12 +168,12 @@ func TestFleetSpeedAndMass(t *testing.T) {
 	m := c.ShipGroup(0).FullMass(c.MustShipClass(Race_0_idx, Race_0_Gunship))
 
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 5)) // 2
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 2, "MAT", 10., 0))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 2, "MAT", 10., 0))
 
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 7)) // 3
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 3, "CAP", 10., 0))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 3, "CAP", 10., 0))
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleet, 1, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleet, 1, 0))
 	fleetIndex := 0
 	speed, mass = c.FleetSpeedAndMass(fleetIndex)
 	assert.Equal(t, s, speed)
@@ -182,7 +182,7 @@ func TestFleetSpeedAndMass(t *testing.T) {
 	s = math.Min(s, c.ShipGroup(1).Speed(c.MustShipClass(Race_0_idx, Race_0_Freighter)))
 	m += c.ShipGroup(1).FullMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleet, 2, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleet, 2, 0))
 	speed, mass = c.FleetSpeedAndMass(fleetIndex)
 	assert.Equal(t, s, speed)
 	assert.Equal(t, m, mass)
@@ -190,7 +190,7 @@ func TestFleetSpeedAndMass(t *testing.T) {
 	s = math.Min(s, c.ShipGroup(2).Speed(c.MustShipClass(Race_0_idx, Race_0_Freighter)))
 	m += c.ShipGroup(2).FullMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleet, 3, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleet, 3, 0))
 	speed, mass = c.FleetSpeedAndMass(fleetIndex)
 	assert.Equal(t, s, speed)
 	assert.Equal(t, m, mass)

internal/controller/planet_test.go

@@ -12,85 +12,85 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestRenamePlanet(t *testing.T) {
+func TestPlanetRename(t *testing.T) {
 	c, g := newCache()
 
 	assert.Equal(t, "Planet_0", c.MustPlanet(R0_Planet_0_num).Name)
-	assert.NoError(t, g.RenamePlanet(Race_0.Name, int(R0_Planet_0_num), "Home_World"))
+	assert.NoError(t, g.PlanetRename(Race_0.Name, int(R0_Planet_0_num), "Home_World"))
 	assert.Equal(t, "Home_World", c.MustPlanet(R0_Planet_0_num).Name)
 
 	assert.ErrorContains(t,
-		g.RenamePlanet(UnknownRace, int(R0_Planet_0_num), "Home_World"),
+		g.PlanetRename(UnknownRace, int(R0_Planet_0_num), "Home_World"),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.RenamePlanet(Race_Extinct.Name, int(R0_Planet_0_num), "Home_World"),
+		g.PlanetRename(Race_Extinct.Name, int(R0_Planet_0_num), "Home_World"),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.RenamePlanet(Race_0.Name, -1, "Home_World"),
+		g.PlanetRename(Race_0.Name, -1, "Home_World"),
 		e.GenericErrorText(e.ErrInputPlanetNumber))
 	assert.ErrorContains(t,
-		g.RenamePlanet(Race_0.Name, 500, "Home_World"),
+		g.PlanetRename(Race_0.Name, 500, "Home_World"),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.RenamePlanet(Race_0.Name, int(R1_Planet_1_num), "Home_World"),
+		g.PlanetRename(Race_0.Name, int(R1_Planet_1_num), "Home_World"),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 }
 
-func TestPlanetProduction(t *testing.T) {
+func TestPlanetProduce(t *testing.T) {
 	c, g := newCache()
 
 	scienceName := "Drive_Shields"
-	assert.NoError(t, g.CreateScience(Race_0.Name, scienceName, 0.4, 0, 0.6, 0))
+	assert.NoError(t, g.ScienceCreate(Race_0.Name, scienceName, 0.4, 0, 0.6, 0))
 	assert.Len(t, c.RaceScience(Race_0_idx), 1)
 	scID := c.RaceScience(Race_0_idx)[0].ID
 
 	assert.Equal(t, "-", c.PlanetProductionDisplayName(3))
 
 	pn := int(R0_Planet_0_num)
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "MAT", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "MAT", ""))
 	assert.Equal(t, game.ProductionMaterial, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.Equal(t, "Material", c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "CAP", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "CAP", ""))
 	assert.Equal(t, game.ProductionCapital, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.Equal(t, "Capital", c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "Weapons", "500"))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "Weapons", "500"))
 	assert.Equal(t, game.ResearchWeapons, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.Equal(t, "Weapons", c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "cargo", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "cargo", ""))
 	assert.Equal(t, game.ResearchCargo, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.Equal(t, "Cargo", c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIELDS", scienceName))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SHIELDS", scienceName))
 	assert.Equal(t, game.ResearchShields, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.Equal(t, "Shields", c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "DrivE", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "DrivE", ""))
 	assert.Equal(t, game.ResearchDrive, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.Equal(t, "Drive", c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "Science", scienceName))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "Science", scienceName))
 	assert.Equal(t, game.ResearchScience, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.Nil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.NotNil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Equal(t, scID, *c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
 	assert.Equal(t, scienceName, c.PlanetProductionDisplayName(R0_Planet_0_num))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIP", Race_0_Gunship))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SHIP", Race_0_Gunship))
 	assert.Equal(t, game.ProductionShip, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.NotNil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.NotNil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
@@ -100,34 +100,34 @@ func TestPlanetProduction(t *testing.T) {
 
 	pn = int(R0_Planet_2_num)
 	assert.ErrorContains(t,
-		g.PlanetProduction(UnknownRace, pn, "DRIVE", ""),
+		g.PlanetProduce(UnknownRace, pn, "DRIVE", ""),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_Extinct.Name, pn, "DRIVE", ""),
+		g.PlanetProduce(Race_Extinct.Name, pn, "DRIVE", ""),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, pn, "Hyperdrive", ""),
+		g.PlanetProduce(Race_0.Name, pn, "Hyperdrive", ""),
 		e.GenericErrorText(e.ErrInputProductionInvalid))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, -1, "DRIVE", ""),
+		g.PlanetProduce(Race_0.Name, -1, "DRIVE", ""),
 		e.GenericErrorText(e.ErrInputPlanetNumber))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, 500, "DRIVE", ""),
+		g.PlanetProduce(Race_0.Name, 500, "DRIVE", ""),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, int(R1_Planet_1_num), "DRIVE", ""),
+		g.PlanetProduce(Race_0.Name, int(R1_Planet_1_num), "DRIVE", ""),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, pn, "Science", ""),
+		g.PlanetProduce(Race_0.Name, pn, "Science", ""),
 		e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, pn, "SHIP", ""),
+		g.PlanetProduce(Race_0.Name, pn, "SHIP", ""),
 		e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, pn, "Science", "Winning"),
+		g.PlanetProduce(Race_0.Name, pn, "Science", "Winning"),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.PlanetProduction(Race_0.Name, pn, "SHIP", "Drone"),
+		g.PlanetProduce(Race_0.Name, pn, "SHIP", "Drone"),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 }
 
@@ -143,7 +143,7 @@ func TestProduceShips(t *testing.T) {
 	c, g := newCache()
 
 	pn := int(R0_Planet_0_num)
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIP", Race_0_Gunship))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SHIP", Race_0_Gunship))
 	assert.Equal(t, game.ProductionShip, c.MustPlanet(R0_Planet_0_num).Production.Type)
 	assert.NotNil(t, c.MustPlanet(R0_Planet_0_num).Production.Progress)
 	assert.NotNil(t, c.MustPlanet(R0_Planet_0_num).Production.SubjectID)
@@ -167,7 +167,7 @@ func TestProduceShips(t *testing.T) {
 	assert.NoError(t, c.CreateShips(Race_0_idx, "Drone", uint(pn), 7))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 1)
 	assert.Equal(t, uint(7), c.ShipGroup(0).Number)
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIP", "Drone"))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SHIP", "Drone"))
 	assert.InDelta(t, shipMass*progress.F(), c.MustPlanet(R0_Planet_0_num).Material.F(), 0.00001) // 99.(0099) material build
 
 	c.MustPlanet(R0_Planet_0_num).Material = 0
@@ -184,15 +184,15 @@ func TestProduceShips(t *testing.T) {
 	// groups is upgrade state
 	//
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, int(R0_Planet_0_num), "MAT", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, int(R0_Planet_0_num), "MAT", ""))
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, int(R0_Planet_2_num), "CAP", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, int(R0_Planet_2_num), "CAP", ""))
 	assert.NoError(t, c.CreateShips(Race_0_idx, "Drone", R0_Planet_2_num, 5))
 	c.MustPlanet(R0_Planet_2_num).Resources = 5
 	c.MustPlanet(R0_Planet_2_num).Population = 100
 	c.MustPlanet(R0_Planet_2_num).Industry = 100
 	c.RaceTechLevel(Race_0_idx, game.TechDrive, 1.5)
-	assert.NoError(t, g.UpgradeGroup(Race_0.Name, 2, "Drive", 0, 0))
+	assert.NoError(t, g.ShipGroupUpgrade(Race_0.Name, 2, "Drive", 0, 0))
-	assert.NoError(t, g.UpgradeGroup(Race_0.Name, 1, "Drive", 0, 0))
+	assert.NoError(t, g.ShipGroupUpgrade(Race_0.Name, 1, "Drive", 0, 0))
 	assert.Equal(t, game.StateUpgrade, c.ShipGroup(0).State())
 	assert.Equal(t, game.StateUpgrade, c.ShipGroup(1).State())
 
@@ -350,12 +350,12 @@ func TestListProducingPlanets(t *testing.T) {
 	planets := slices.Collect(c.ListProducingPlanets())
 	assert.Len(t, planets, 0)
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, int(R0_Planet_0_num), "CAP", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, int(R0_Planet_0_num), "CAP", ""))
 	planets = slices.Collect(c.ListProducingPlanets())
 	assert.Len(t, planets, 1)
 	assert.Equal(t, R0_Planet_0_num, c.MustPlanet(planets[0]).Number)
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, int(R0_Planet_2_num), "SHIP", Race_0_Gunship))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, int(R0_Planet_2_num), "SHIP", Race_0_Gunship))
 	planets = slices.Collect(c.ListProducingPlanets())
 	assert.Len(t, planets, 2)
 	assert.Equal(t, R0_Planet_2_num, c.MustPlanet(planets[0]).Number)
@@ -365,7 +365,7 @@ func TestListProducingPlanets(t *testing.T) {
 func TestTurnPlanetProductions(t *testing.T) {
 	c, g := newCache()
 	assert.NoError(t, c.ShipClassCreate(Race_0_idx, "Drone", 1, 0, 0, 0, 0))
-	assert.NoError(t, g.CreateScience(Race_0.Name, "Equality", 0.25, 0.25, 0.25, 0.25))
+	assert.NoError(t, g.ScienceCreate(Race_0.Name, "Equality", 0.25, 0.25, 0.25, 0.25))
 	c.MustPlanet(R0_Planet_0_num).Resources = 10.
 	c.MustPlanet(R0_Planet_0_num).Size = 1000.
 	c.MustPlanet(R0_Planet_0_num).Population = 1000.
@@ -373,47 +373,47 @@ func TestTurnPlanetProductions(t *testing.T) {
 
 	pn := int(R0_Planet_0_num)
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "CAP", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "CAP", ""))
 	assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Capital.F())
 	assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Colonists.F())
 	c.TurnPlanetProductions()
 	assert.InDelta(t, 196., c.MustPlanet(R0_Planet_0_num).Capital.F(), 0.1)
 	assert.Equal(t, 10.0, c.MustPlanet(R0_Planet_0_num).Colonists.F())
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "MAT", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "MAT", ""))
 	assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Material.F())
 	c.TurnPlanetProductions()
 	assert.Equal(t, 10000., c.MustPlanet(R0_Planet_0_num).Material.F())
 	assert.InDelta(t, 20.0, c.MustPlanet(R0_Planet_0_num).Colonists.F(), 0.000001)
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "DRIVE", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "DRIVE", ""))
 	assert.Equal(t, 1.1, c.Race(Race_0_idx).TechLevel(game.TechDrive))
 	c.TurnPlanetProductions()
 	assert.Equal(t, 1.3, c.Race(Race_0_idx).TechLevel(game.TechDrive))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "WEAPONS", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "WEAPONS", ""))
 	assert.Equal(t, 1.2, c.Race(Race_0_idx).TechLevel(game.TechWeapons))
 	c.TurnPlanetProductions()
 	assert.Equal(t, 1.4, c.Race(Race_0_idx).TechLevel(game.TechWeapons))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIELDS", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SHIELDS", ""))
 	assert.Equal(t, 1.3, c.Race(Race_0_idx).TechLevel(game.TechShields))
 	c.TurnPlanetProductions()
 	assert.Equal(t, 1.5, c.Race(Race_0_idx).TechLevel(game.TechShields))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "CARGO", ""))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "CARGO", ""))
 	assert.Equal(t, 1.4, c.Race(Race_0_idx).TechLevel(game.TechCargo))
 	c.TurnPlanetProductions()
 	assert.Equal(t, 1.6, c.Race(Race_0_idx).TechLevel(game.TechCargo))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SCIENCE", "Equality"))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SCIENCE", "Equality"))
 	c.TurnPlanetProductions()
 	assert.Equal(t, 1.35, c.Race(Race_0_idx).TechLevel(game.TechDrive))
 	assert.Equal(t, 1.45, c.Race(Race_0_idx).TechLevel(game.TechWeapons))
 	assert.Equal(t, 1.55, c.Race(Race_0_idx).TechLevel(game.TechShields))
 	assert.Equal(t, 1.65, c.Race(Race_0_idx).TechLevel(game.TechCargo))
 
-	assert.NoError(t, g.PlanetProduction(Race_0.Name, pn, "SHIP", "Drone"))
+	assert.NoError(t, g.PlanetProduce(Race_0.Name, pn, "SHIP", "Drone"))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 0)
 	c.TurnPlanetProductions()
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 1)

internal/controller/race_test.go

@@ -8,68 +8,68 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestGiveVotes(t *testing.T) {
+func TestRaceVote(t *testing.T) {
 	c, g := newCache()
 
 	assert.Equal(t, c.Voted(Race_0_idx), Race_0_idx)
 	assert.Equal(t, c.Voted(Race_1_idx), Race_1_idx)
 
-	assert.NoError(t, g.GiveVotes(Race_0.Name, Race_1.Name))
+	assert.NoError(t, g.RaceVote(Race_0.Name, Race_1.Name))
 	assert.Equal(t, Race_1_idx, c.Voted(Race_0_idx))
 	assert.Equal(t, Race_1_idx, c.Voted(Race_1_idx))
 
 	assert.ErrorContains(t,
-		g.GiveVotes(UnknownRace, Race_1.Name),
+		g.RaceVote(UnknownRace, Race_1.Name),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.GiveVotes(Race_0.Name, UnknownRace),
+		g.RaceVote(Race_0.Name, UnknownRace),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.GiveVotes(Race_0.Name, Race_Extinct.Name),
+		g.RaceVote(Race_0.Name, Race_Extinct.Name),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.GiveVotes(Race_Extinct.Name, Race_1.Name),
+		g.RaceVote(Race_Extinct.Name, Race_1.Name),
 		e.GenericErrorText(e.ErrRaceExinct))
 }
 
-func TestRelation(t *testing.T) {
+func TestRaceRelation(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.UpdateRelation(Race_0.Name, Race_1.Name, "war"))
+	assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.Name, "war"))
-	assert.NoError(t, g.UpdateRelation(Race_1.Name, Race_0.Name, "PEACE"))
+	assert.NoError(t, g.RaceRelation(Race_1.Name, Race_0.Name, "PEACE"))
 
 	assert.Equal(t, game.RelationWar, c.Relation(Race_0_idx, Race_1_idx))
 	assert.Equal(t, game.RelationPeace, c.Relation(Race_1_idx, Race_0_idx))
 
 	assert.ErrorContains(t,
-		g.UpdateRelation(Race_0.Name, Race_1.Name, "Wojna"),
+		g.RaceRelation(Race_0.Name, Race_1.Name, "Wojna"),
 		e.GenericErrorText(e.ErrInputUnknownRelation))
 	assert.ErrorContains(t,
-		g.UpdateRelation(Race_0.Name, UnknownRace, "War"),
+		g.RaceRelation(Race_0.Name, UnknownRace, "War"),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.UpdateRelation(UnknownRace, Race_0.Name, "Peace"),
+		g.RaceRelation(UnknownRace, Race_0.Name, "Peace"),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.UpdateRelation(Race_0.Name, Race_Extinct.Name, "War"),
+		g.RaceRelation(Race_0.Name, Race_Extinct.Name, "War"),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.UpdateRelation(Race_Extinct.Name, Race_0.Name, "War"),
+		g.RaceRelation(Race_Extinct.Name, Race_0.Name, "War"),
 		e.GenericErrorText(e.ErrRaceExinct))
 }
 
-func TestQuitGame(t *testing.T) {
+func TestRaceQuit(t *testing.T) {
 	c, g := newCache()
 
 	assert.ErrorContains(t,
-		g.QuitGame(UnknownRace),
+		g.RaceQuit(UnknownRace),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 
 	assert.ErrorContains(t,
-		g.QuitGame(Race_Extinct.Name),
+		g.RaceQuit(Race_Extinct.Name),
 		e.GenericErrorText(e.ErrRaceExinct))
 
-	assert.NoError(t, g.QuitGame(Race_0.Name))
+	assert.NoError(t, g.RaceQuit(Race_0.Name))
 	assert.Equal(t, 3, int(c.Race(Race_0_idx).TTL))
 }
 

internal/controller/route_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSetRoute(t *testing.T) {
+func TestPlanetRouteSet(t *testing.T) {
 	c, g := newCache()
 
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteMaterial)
@@ -19,82 +19,82 @@ func TestSetRoute(t *testing.T) {
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteEmpty)
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", 0, 2))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", 0, 2))
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteMaterial)
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteCapital)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteEmpty)
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "MAT", 0, 2))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "MAT", 0, 2))
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteMaterial)
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteCapital)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteEmpty)
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "CAP", 0, 2))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", 0, 2))
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteMaterial)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteCapital)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteEmpty)
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "EMP", 0, 2))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "EMP", 0, 2))
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteMaterial)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteCapital)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteEmpty)
 
 	assert.ErrorContains(t,
-		g.SetRoute(UnknownRace, "COL", 0, 2),
+		g.PlanetRouteSet(UnknownRace, "COL", 0, 2),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.SetRoute(Race_Extinct.Name, "COL", 0, 2),
+		g.PlanetRouteSet(Race_Extinct.Name, "COL", 0, 2),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.SetRoute(Race_0.Name, "IND", 0, 2),
+		g.PlanetRouteSet(Race_0.Name, "IND", 0, 2),
 		e.GenericErrorText(e.ErrInputCargoTypeInvalid))
 	assert.ErrorContains(t,
-		g.SetRoute(Race_0.Name, "COL", 500, 2),
+		g.PlanetRouteSet(Race_0.Name, "COL", 500, 2),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.SetRoute(Race_0.Name, "COL", 1, 2),
+		g.PlanetRouteSet(Race_0.Name, "COL", 1, 2),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 	assert.ErrorContains(t,
-		g.SetRoute(Race_0.Name, "COL", 0, 3),
+		g.PlanetRouteSet(Race_0.Name, "COL", 0, 3),
 		e.GenericErrorText(e.ErrSendUnreachableDestination))
 }
 
-func TestRemoveRoute(t *testing.T) {
+func TestPlanetRouteRemove(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", 0, 2))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", 0, 2))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "CAP", 0, 2))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", 0, 2))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "EMP", 2, 0))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "EMP", 2, 0))
 
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteCapital)
 	assert.Contains(t, c.MustPlanet(2).Route, game.RouteEmpty)
 
-	assert.NoError(t, g.RemoveRoute(Race_0.Name, "COL", 0))
+	assert.NoError(t, g.PlanetRouteRemove(Race_0.Name, "COL", 0))
 	assert.NotContains(t, c.MustPlanet(0).Route, game.RouteColonist)
 	assert.Contains(t, c.MustPlanet(0).Route, game.RouteCapital)
 
-	assert.NoError(t, g.RemoveRoute(Race_0.Name, "EMP", 2))
+	assert.NoError(t, g.PlanetRouteRemove(Race_0.Name, "EMP", 2))
 	assert.NotContains(t, c.MustPlanet(2).Route, game.RouteEmpty)
 
 	assert.ErrorContains(t,
-		g.RemoveRoute(UnknownRace, "COL", 0),
+		g.PlanetRouteRemove(UnknownRace, "COL", 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.RemoveRoute(Race_Extinct.Name, "COL", 0),
+		g.PlanetRouteRemove(Race_Extinct.Name, "COL", 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.RemoveRoute(Race_0.Name, "IND", 0),
+		g.PlanetRouteRemove(Race_0.Name, "IND", 0),
 		e.GenericErrorText(e.ErrInputCargoTypeInvalid))
 	assert.ErrorContains(t,
-		g.RemoveRoute(Race_0.Name, "COL", 500),
+		g.PlanetRouteRemove(Race_0.Name, "COL", 500),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.RemoveRoute(Race_0.Name, "COL", 1),
+		g.PlanetRouteRemove(Race_0.Name, "COL", 1),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 }
 
@@ -118,11 +118,11 @@ func TestListRoutedSendGroupIds(t *testing.T) {
 
 	// Foreign group -> idx 1
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
-	assert.NoError(t, g.TransferGroup(Race_0.Name, Race_1.Name, 5, 0))
+	assert.NoError(t, g.ShipGroupTransfer(Race_0.Name, Race_1.Name, 5, 0))
 
 	// 5: idx = 4 / Part of the Fleet
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, "Fleet", 5, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, "Fleet", 5, 0))
 
 	planet_0_groups := slices.Collect(c.ListRoutedSendGroupIds(0))
 	assert.Len(t, planet_0_groups, 1)
@@ -140,7 +140,7 @@ func TestListRoutedSendGroupIds(t *testing.T) {
 func TestEnrouteGroups_SplitGroup(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
 
 	c.MustPlanet(R0_Planet_0_num).Colonists = 65
 
@@ -162,7 +162,7 @@ func TestEnrouteGroups_SplitGroup(t *testing.T) {
 func TestEnrouteGroups_GroupSorting(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
 
 	c.MustPlanet(R0_Planet_0_num).Colonists = 100
 
@@ -187,10 +187,10 @@ func TestEnrouteGroups_GroupSorting(t *testing.T) {
 func TestEnrouteGroups_LaunchOrder(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "CAP", R0_Planet_0_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", R0_Planet_0_num, R0_Planet_2_num))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "MAT", R0_Planet_0_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "MAT", R0_Planet_0_num, R0_Planet_2_num))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "EMP", R0_Planet_0_num, R1_Planet_1_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "EMP", R0_Planet_0_num, R1_Planet_1_num))
 
 	c.MustPlanet(R0_Planet_0_num).Colonists = 150
 	c.MustPlanet(R0_Planet_0_num).Capital = 100
@@ -281,9 +281,9 @@ func TestListRoutedUnloadShipGroupIds(t *testing.T) {
 
 	// 5: idx = 4 / Part of the Fleet
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, "Fleet", 5, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, "Fleet", 5, 0))
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_0_num, R0_Planet_2_num))
 	for _, rt := range game.RouteTypeSet {
 		groups := slices.Collect(c.ListRoutedUnloadShipGroupIds(R0_Planet_2_num, rt))
 		assert.Len(t, groups, 0, "route: %v", rt)
@@ -292,8 +292,8 @@ func TestListRoutedUnloadShipGroupIds(t *testing.T) {
 	}
 
 	// double route from different planets - must not double group ids
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_2_num, R0_Planet_0_num))
-	assert.NoError(t, g.SetRoute(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
 
 	// 6: idx = 5 / loaded with CAP
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 11))
@@ -343,8 +343,8 @@ func TestMaxOrRandomLoadId(t *testing.T) {
 func TestSelectColUnloadGroup(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_2_num, R0_Planet_0_num))
-	assert.NoError(t, g.SetRoute(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
 
 	// 1: idx = 0 / Loaded COL
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
@@ -376,11 +376,11 @@ func TestSelectColUnloadGroup(t *testing.T) {
 func TestTurnUnloadEnroutedGroups(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "MAT", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "MAT", R0_Planet_2_num, R0_Planet_0_num))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "CAP", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", R0_Planet_2_num, R0_Planet_0_num))
 
-	assert.NoError(t, g.SetRoute(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
-	assert.NoError(t, g.SetRoute(Race_1.Name, "COL", R1_Planet_1_num, Uninhabited_Planet_4_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "COL", R1_Planet_1_num, Uninhabited_Planet_4_num))
 
 	// 1: idx = 0 / Loaded MAT
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
@@ -420,13 +420,13 @@ func TestTurnUnloadEnroutedGroups(t *testing.T) {
 func TestRemoveUnreachableRoutes(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.SetRoute(Race_0.Name, "MAT", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "MAT", R0_Planet_2_num, R0_Planet_0_num))
-	assert.NoError(t, g.SetRoute(Race_0.Name, "CAP", R0_Planet_2_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", R0_Planet_2_num, R0_Planet_0_num))
 
-	assert.NoError(t, g.SetRoute(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_num))
-	assert.NoError(t, g.SetRoute(Race_1.Name, "CAP", R1_Planet_1_num, Uninhabited_Planet_4_num))
+	assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "CAP", R1_Planet_1_num, Uninhabited_Planet_4_num))
 
-	assert.Error(t, g.SetRoute(Race_0.Name, "COL", R0_Planet_2_num, Uninhabited_Planet_3_num))
+	assert.Error(t, g.PlanetRouteSet(Race_0.Name, "COL", R0_Planet_2_num, Uninhabited_Planet_3_num))
 	c.MustPlanet(R0_Planet_2_num).Route[game.RouteColonist] = Uninhabited_Planet_3_num
 
 	c.RemoveUnreachableRoutes()

internal/controller/science_test.go

@@ -10,13 +10,13 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCreateScience(t *testing.T) {
+func TestScienceCreate(t *testing.T) {
 	c, g := newCache()
 	first := "Drive_Shields"
 	second := "Hyperdrive"
 
 	assert.Len(t, c.RaceScience(Race_0_idx), 0)
-	assert.NoError(t, g.CreateScience(Race_0.Name, first, 0.4, 0, 0.6, 0))
+	assert.NoError(t, g.ScienceCreate(Race_0.Name, first, 0.4, 0, 0.6, 0))
 	assert.Len(t, c.RaceScience(Race_0_idx), 1)
 	sc := c.RaceScience(Race_0_idx)[0]
 	assert.NoError(t, uuid.Validate(sc.ID.String()))
@@ -27,43 +27,43 @@ func TestCreateScience(t *testing.T) {
 	assert.Equal(t, 0., sc.Cargo.F())
 
 	assert.ErrorContains(t,
-		g.CreateScience(UnknownRace, second, 0.4, 0, 0.6, 0),
+		g.ScienceCreate(UnknownRace, second, 0.4, 0, 0.6, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_Extinct.Name, second, 0.4, 0, 0.6, 0),
+		g.ScienceCreate(Race_Extinct.Name, second, 0.4, 0, 0.6, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, BadEntityName, 0.4, 0, 0.6, 0),
+		g.ScienceCreate(Race_0.Name, BadEntityName, 0.4, 0, 0.6, 0),
 		e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, first, 0.4, 0, 0.6, 0),
+		g.ScienceCreate(Race_0.Name, first, 0.4, 0, 0.6, 0),
 		e.GenericErrorText(e.ErrInputEntityTypeNameDuplicate))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, -0.1, 0, 1.1, 0),
+		g.ScienceCreate(Race_0.Name, second, -0.1, 0, 1.1, 0),
 		e.GenericErrorText(e.ErrInputDriveValue))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 1.5, -0.5, 0, 0),
+		g.ScienceCreate(Race_0.Name, second, 1.5, -0.5, 0, 0),
 		e.GenericErrorText(e.ErrInputWeaponsValue))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 1.3, 0, -0.3, 0),
+		g.ScienceCreate(Race_0.Name, second, 1.3, 0, -0.3, 0),
 		e.GenericErrorText(e.ErrInputShieldsValue))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 0, 1.07, 0, -0.07),
+		g.ScienceCreate(Race_0.Name, second, 0, 1.07, 0, -0.07),
 		e.GenericErrorText(e.ErrInputCargoValue))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 0.26, 0.25, 0.25, 0.25),
+		g.ScienceCreate(Race_0.Name, second, 0.26, 0.25, 0.25, 0.25),
 		e.GenericErrorText(e.ErrInputScienceSumValues))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 0.25, 0.26, 0.25, 0.25),
+		g.ScienceCreate(Race_0.Name, second, 0.25, 0.26, 0.25, 0.25),
 		e.GenericErrorText(e.ErrInputScienceSumValues))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 0.25, 0.25, 0.26, 0.25),
+		g.ScienceCreate(Race_0.Name, second, 0.25, 0.25, 0.26, 0.25),
 		e.GenericErrorText(e.ErrInputScienceSumValues))
 	assert.ErrorContains(t,
-		g.CreateScience(Race_0.Name, second, 0.25, 0.25, 0.25, 0.26),
+		g.ScienceCreate(Race_0.Name, second, 0.25, 0.25, 0.25, 0.26),
 		e.GenericErrorText(e.ErrInputScienceSumValues))
 
-	assert.NoError(t, g.CreateScience(Race_0.Name, second, 0.25, 0.25, 0.25, 0.25))
+	assert.NoError(t, g.ScienceCreate(Race_0.Name, second, 0.25, 0.25, 0.25, 0.25))
 	assert.Len(t, c.RaceScience(Race_0_idx), 2)
 	sc = c.RaceScience(Race_0_idx)[1]
 	assert.NoError(t, uuid.Validate(sc.ID.String()))
@@ -74,31 +74,31 @@ func TestCreateScience(t *testing.T) {
 	assert.Equal(t, 0.25, sc.Cargo.F())
 }
 
-func TestDeleteScience(t *testing.T) {
+func TestScienceRemove(t *testing.T) {
 	c, g := newCache()
 	first := "Drive_Shields"
 	second := "Hyperdrive"
 	assert.Len(t, c.RaceScience(Race_0_idx), 0)
-	assert.NoError(t, g.CreateScience(Race_0.Name, first, 0.4, 0, 0.6, 0))
+	assert.NoError(t, g.ScienceCreate(Race_0.Name, first, 0.4, 0, 0.6, 0))
-	assert.NoError(t, g.CreateScience(Race_0.Name, second, 0.25, 0.25, 0.25, 0.25))
+	assert.NoError(t, g.ScienceCreate(Race_0.Name, second, 0.25, 0.25, 0.25, 0.25))
 	assert.Len(t, c.RaceScience(Race_0_idx), 2)
 
-	assert.NoError(t, g.DeleteScience(Race_0.Name, first))
+	assert.NoError(t, g.ScienceRemove(Race_0.Name, first))
 	assert.Len(t, c.RaceScience(Race_0_idx), 1)
 
-	g.PlanetProduction(Race_0.Name, int(R0_Planet_0_num), "SCIENCE", second)
+	g.PlanetProduce(Race_0.Name, int(R0_Planet_0_num), "SCIENCE", second)
 
 	assert.ErrorContains(t,
-		g.DeleteScience(UnknownRace, second),
+		g.ScienceRemove(UnknownRace, second),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.DeleteScience(Race_Extinct.Name, second),
+		g.ScienceRemove(Race_Extinct.Name, second),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.DeleteScience(Race_0.Name, first),
+		g.ScienceRemove(Race_0.Name, first),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.DeleteScience(Race_0.Name, second),
+		g.ScienceRemove(Race_0.Name, second),
 		e.GenericErrorText(e.ErrDeleteSciencePlanetProduction))
 }
 

internal/controller/ship_class_test.go

@@ -9,10 +9,10 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCreateShipClass(t *testing.T) {
+func TestShipClassCreate(t *testing.T) {
 	c, g := newCache()
 
-	assert.NoError(t, g.CreateShipType(Race_0.Name, "Random", 1, 3, 5, 4, 2))
+	assert.NoError(t, g.ShipClassCreate(Race_0.Name, "Random", 1, 3, 5, 4, 2))
 	ships := slices.Collect(c.ListShipTypes(Race_0_idx))
 	assert.Len(t, ships, 4)
 	st := ships[3]
@@ -23,16 +23,16 @@ func TestCreateShipClass(t *testing.T) {
 	assert.Equal(t, 2., float64(st.Cargo))
 
 	assert.ErrorContains(t,
-		g.CreateShipType(Race_0.Name, Race_0_Gunship, 1, 0, 0, 0, 0),
+		g.ShipClassCreate(Race_0.Name, Race_0_Gunship, 1, 0, 0, 0, 0),
 		e.GenericErrorText(e.ErrInputEntityTypeNameDuplicate))
 	assert.ErrorContains(t,
-		g.CreateShipType(UnknownRace, "Drone", 1, 0, 0, 0, 0),
+		g.ShipClassCreate(UnknownRace, "Drone", 1, 0, 0, 0, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.CreateShipType(Race_Extinct.Name, "Drone", 1, 0, 0, 0, 0),
+		g.ShipClassCreate(Race_Extinct.Name, "Drone", 1, 0, 0, 0, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.CreateShipType(Race_0.Name, BadEntityName, 1, 0, 0, 0, 0),
+		g.ShipClassCreate(Race_0.Name, BadEntityName, 1, 0, 0, 0, 0),
 		e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
 }
 
@@ -77,73 +77,73 @@ func TestCreateShipTypeValidation(t *testing.T) {
 		_, g := newCache()
 
 		if tc.err == "" {
-			err := g.CreateShipType(race, tc.name+strconv.Itoa(i), tc.d, tc.a, tc.w, tc.s, tc.c)
+			err := g.ShipClassCreate(race, tc.name+strconv.Itoa(i), tc.d, tc.a, tc.w, tc.s, tc.c)
 			assert.NoError(t, err)
-			err = g.CreateShipType(race, tc.name+strconv.Itoa(i), tc.d, tc.a, tc.w, tc.s, tc.c)
+			err = g.ShipClassCreate(race, tc.name+strconv.Itoa(i), tc.d, tc.a, tc.w, tc.s, tc.c)
 			assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityTypeNameDuplicate))
 		} else {
-			err := g.CreateShipType(race, tc.name, tc.d, tc.a, tc.w, tc.s, tc.c)
+			err := g.ShipClassCreate(race, tc.name, tc.d, tc.a, tc.w, tc.s, tc.c)
 			assert.ErrorContains(t, err, tc.err)
 		}
 	}
 }
 
-func TestMergeShipClass(t *testing.T) {
+func TestShipClassMerge(t *testing.T) {
 	c, g := newCache()
 
 	assert.Len(t, c.ShipTypes(Race_0_idx), 3)
 
-	assert.NoError(t, g.CreateShipType(Race_0.Name, "Drone", 1, 0, 0, 0, 0))
+	assert.NoError(t, g.ShipClassCreate(Race_0.Name, "Drone", 1, 0, 0, 0, 0))
 	assert.Len(t, c.ShipTypes(Race_0_idx), 4)
-	assert.NoError(t, g.CreateShipType(Race_0.Name, "Spy", 1, 0, 0, 0, 0))
+	assert.NoError(t, g.ShipClassCreate(Race_0.Name, "Spy", 1, 0, 0, 0, 0))
 	assert.Len(t, c.ShipTypes(Race_0_idx), 5)
-	assert.NoError(t, g.CreateShipType(Race_0.Name, "Surfer", 15, 15, 15, 0, 1))
+	assert.NoError(t, g.ShipClassCreate(Race_0.Name, "Surfer", 15, 15, 15, 0, 1))
 	assert.Len(t, c.ShipTypes(Race_0_idx), 6)
 
 	assert.ErrorContains(t,
-		g.MergeShipType(Race_0.Name, "Sky", "Drone"),
+		g.ShipClassMerge(Race_0.Name, "Sky", "Drone"),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.MergeShipType(Race_0.Name, "Spy", "Elephant"),
+		g.ShipClassMerge(Race_0.Name, "Spy", "Elephant"),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.MergeShipType(Race_Extinct.Name, "Spy", "Drone"),
+		g.ShipClassMerge(Race_Extinct.Name, "Spy", "Drone"),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.MergeShipType(Race_0.Name, "Spy", "Spy"),
+		g.ShipClassMerge(Race_0.Name, "Spy", "Spy"),
 		e.GenericErrorText(e.ErrInputEntityTypeNameEquality))
 
-	assert.NoError(t, g.MergeShipType(Race_0.Name, "Spy", "Drone"))
+	assert.NoError(t, g.ShipClassMerge(Race_0.Name, "Spy", "Drone"))
 	assert.Len(t, c.ShipTypes(Race_0_idx), 5)
 
 	assert.ErrorContains(t,
-		g.MergeShipType(Race_0.Name, "Drone", "Surfer"),
+		g.ShipClassMerge(Race_0.Name, "Drone", "Surfer"),
 		e.GenericErrorText(e.ErrMergeShipTypeNotEqual))
 }
 
-func TestDeleteShipClass(t *testing.T) {
+func TestShipClassRemove(t *testing.T) {
 	c, g := newCache()
 
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 1))
-	assert.NoError(t, g.CreateShipType(Race_0.Name, "Drone", 1, 0, 0, 0, 0))
+	assert.NoError(t, g.ShipClassCreate(Race_0.Name, "Drone", 1, 0, 0, 0, 0))
-	g.PlanetProduction(Race_0.Name, int(R0_Planet_0_num), "SHIP", "Drone")
+	g.PlanetProduce(Race_0.Name, int(R0_Planet_0_num), "SHIP", "Drone")
 
 	assert.ErrorContains(t,
-		g.DeleteShipType(UnknownRace, Race_0_Freighter),
+		g.ShipClassRemove(UnknownRace, Race_0_Freighter),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.DeleteShipType(Race_Extinct.Name, Race_0_Freighter),
+		g.ShipClassRemove(Race_Extinct.Name, Race_0_Freighter),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.DeleteShipType(Race_0.Name, "Elephant"),
+		g.ShipClassRemove(Race_0.Name, "Elephant"),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.DeleteShipType(Race_0.Name, "Drone"),
+		g.ShipClassRemove(Race_0.Name, "Drone"),
 		e.GenericErrorText(e.ErrDeleteShipTypePlanetProduction))
 
-	assert.NoError(t, g.DeleteShipType(Race_0.Name, Race_0_Freighter))
+	assert.NoError(t, g.ShipClassRemove(Race_0.Name, Race_0_Freighter))
 
 	assert.ErrorContains(t,
-		g.DeleteShipType(Race_0.Name, Race_0_Gunship),
+		g.ShipClassRemove(Race_0.Name, Race_0_Gunship),
 		e.GenericErrorText(e.ErrDeleteShipTypeExistingGroup))
 }

internal/controller/ship_group_move_test.go

@@ -19,8 +19,8 @@ func TestListMoveableGroupIds(t *testing.T) {
 	// 3: idx = 2 / [v] In-Fleet group
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
 
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, "Fleet", 2, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, "Fleet", 2, 0))
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, "Fleet", 3, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, "Fleet", 3, 0))
 
 	// 4: idx = 3 / [v] In_Space
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 7))
@@ -34,7 +34,7 @@ func TestListMoveableGroupIds(t *testing.T) {
 
 	// 6: idx = 5 / [v] Just launched group
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 10))
-	assert.NoError(t, g.SendGroup(Race_0.Name, 6, R0_Planet_2_num, 0))
+	assert.NoError(t, g.ShipGroupSend(Race_0.Name, 6, R0_Planet_2_num, 0))
 
 	movableGroups := slices.Collect(c.ListMoveableGroupIds())
 	assert.Len(t, movableGroups, 5)

internal/controller/ship_group_send_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSendGroup(t *testing.T) {
+func TestShipGroupSend(t *testing.T) {
 	c, g := newCache()
 	// group #1 - in_orbit, free to upgrade
 	assert.NoError(t, c.CreateShips(Race_0_idx, ShipType_Cruiser, R0_Planet_0_num, 10))
@@ -19,35 +19,35 @@ func TestSendGroup(t *testing.T) {
 	// g.ShipGroups[1].StateInSpace = &game.InSpace{Origin: 2, Range: 1.23}
 	c.ShipGroup(1).StateInSpace = &InSpace
 	// group #3 - in_orbit, unmovable
-	g.CreateShipType(Race_0.Name, "Fortress", 0, 50, 30, 100, 0)
+	g.ShipClassCreate(Race_0.Name, "Fortress", 0, 50, 30, 100, 0)
 	assert.NoError(t, c.CreateShips(Race_0_idx, "Fortress", R0_Planet_0_num, 1))
 
 	assert.ErrorContains(t,
-		g.SendGroup(UnknownRace, 1, 2, 0),
+		g.ShipGroupSend(UnknownRace, 1, 2, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_Extinct.Name, 1, 2, 0),
+		g.ShipGroupSend(Race_Extinct.Name, 1, 2, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_0.Name, 555, 2, 0),
+		g.ShipGroupSend(Race_0.Name, 555, 2, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_0.Name, 1, 222, 0),
+		g.ShipGroupSend(Race_0.Name, 1, 222, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_0.Name, 2, 1, 0),
+		g.ShipGroupSend(Race_0.Name, 2, 1, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_0.Name, 3, 2, 0),
+		g.ShipGroupSend(Race_0.Name, 3, 2, 0),
 		e.GenericErrorText(e.ErrSendShipHasNoDrives))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_0.Name, 1, 2, 100),
+		g.ShipGroupSend(Race_0.Name, 1, 2, 100),
 		e.GenericErrorText(e.ErrBeakGroupNumberNotEnough))
 	assert.ErrorContains(t,
-		g.SendGroup(Race_0.Name, 1, 3, 0),
+		g.ShipGroupSend(Race_0.Name, 1, 3, 0),
 		e.GenericErrorText(e.ErrSendUnreachableDestination))
 
-	assert.NoError(t, g.SendGroup(Race_0.Name, 1, R0_Planet_2_num, 3)) // send 3 of 10
+	assert.NoError(t, g.ShipGroupSend(Race_0.Name, 1, R0_Planet_2_num, 3)) // send 3 of 10
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, uint(7), c.ShipGroup(0).Number)
 	assert.Equal(t, game.StateInOrbit, c.ShipGroup(0).State())
@@ -57,7 +57,7 @@ func TestSendGroup(t *testing.T) {
 	assert.Nil(t, c.ShipGroup(3).StateInSpace.X)
 	assert.Nil(t, c.ShipGroup(3).StateInSpace.Y)
 
-	assert.NoError(t, g.SendGroup(Race_0.Name, 4, R0_Planet_0_num, 2)) // un-send 2 of 3
+	assert.NoError(t, g.ShipGroupSend(Race_0.Name, 4, R0_Planet_0_num, 2)) // un-send 2 of 3
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, uint(9), c.MustShipGroup(Race_0_idx, 1).Number)
 	assert.Equal(t, game.StateInOrbit, c.MustShipGroup(Race_0_idx, 1).State())
@@ -67,12 +67,12 @@ func TestSendGroup(t *testing.T) {
 	assert.Nil(t, c.MustShipGroup(Race_0_idx, 4).StateInSpace.X)
 	assert.Nil(t, c.MustShipGroup(Race_0_idx, 4).StateInSpace.Y)
 
-	assert.NoError(t, g.SendGroup(Race_0.Name, 4, R0_Planet_0_num, 0)) // un-send the rest 1
+	assert.NoError(t, g.ShipGroupSend(Race_0.Name, 4, R0_Planet_0_num, 0)) // un-send the rest 1
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
 	assert.Equal(t, uint(10), c.MustShipGroup(Race_0_idx, 1).Number)
 	assert.Equal(t, game.StateInOrbit, c.MustShipGroup(Race_0_idx, 1).State())
 
-	assert.NoError(t, g.SendGroup(Race_0.Name, 1, R0_Planet_2_num, 0))
+	assert.NoError(t, g.ShipGroupSend(Race_0.Name, 1, R0_Planet_2_num, 0))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
 	assert.Equal(t, uint(10), c.MustShipGroup(Race_0_idx, 1).Number)
 	assert.Equal(t, game.StateLaunched, c.MustShipGroup(Race_0_idx, 1).State())

internal/controller/ship_group_test.go

@@ -35,7 +35,7 @@ func TestCreateShips(t *testing.T) {
 	assert.Len(t, slices.Collect(c.RaceShipGroups(1)), 2)
 }
 
-func TestJoinEqualGroups(t *testing.T) {
+func TestShipGroupMerge(t *testing.T) {
 	c, g := newCache()
 
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 1)) // 1 -> 2
@@ -58,13 +58,13 @@ func TestJoinEqualGroups(t *testing.T) {
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_1_idx)), 3)
 
 	assert.ErrorContains(t,
-		g.JoinEqualGroups(UnknownRace),
+		g.ShipGroupMerge(UnknownRace),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.JoinEqualGroups(Race_Extinct.Name),
+		g.ShipGroupMerge(Race_Extinct.Name),
 		e.GenericErrorText(e.ErrRaceExinct))
 
-	assert.NoError(t, g.JoinEqualGroups(Race_0.Name))
+	assert.NoError(t, g.ShipGroupMerge(Race_0.Name))
 
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_1_idx)), 3)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
@@ -98,29 +98,29 @@ func TestJoinEqualGroups(t *testing.T) {
 	}
 }
 
-func TestBreakGroup(t *testing.T) {
+func TestShipGroupBreak(t *testing.T) {
 	c, g := newCache()
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Freighter, R0_Planet_0_num, 13)) // group #1 (0)
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 7))    // group #2 (1) - In_Space
 	c.ShipGroup(1).StateInSpace = &InSpace
 
 	fleet := "R0_Fleet"
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleet, 1, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleet, 1, 0))
 
 	assert.ErrorContains(t,
-		g.BreakGroup(UnknownRace, 1, 0),
+		g.ShipGroupBreak(UnknownRace, 1, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.BreakGroup(Race_Extinct.Name, 1, 0),
+		g.ShipGroupBreak(Race_Extinct.Name, 1, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.BreakGroup(Race_0.Name, 555, 0),
+		g.ShipGroupBreak(Race_0.Name, 555, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.BreakGroup(Race_0.Name, 1, 17),
+		g.ShipGroupBreak(Race_0.Name, 1, 17),
 		e.GenericErrorText(e.ErrBeakGroupNumberNotEnough))
 	assert.ErrorContains(t,
-		g.BreakGroup(Race_0.Name, 2, 0),
+		g.ShipGroupBreak(Race_0.Name, 2, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 2)
@@ -155,25 +155,25 @@ func TestBreakGroup(t *testing.T) {
 	assert.Equal(t, 8.2, number.Fixed3(c.ShipGroup(3).Load.F()))
 
 	// group #1 -> MAX 6 off the fleet
-	assert.NoError(t, g.BreakGroup(Race_0.Name, 1, 6)) // group #1 (0)
+	assert.NoError(t, g.ShipGroupBreak(Race_0.Name, 1, 6)) // group #1 (0)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, uint(6), c.ShipGroup(0).Number)
 	assert.Nil(t, c.ShipGroup(0).FleetID)
 
 	// group #4 -> ALL off the fleet
-	assert.NoError(t, g.BreakGroup(Race_0.Name, 4, 0)) // group #1 (0)
+	assert.NoError(t, g.ShipGroupBreak(Race_0.Name, 4, 0)) // group #1 (0)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, uint(2), c.ShipGroup(3).Number)
 	assert.Nil(t, c.ShipGroup(3).FleetID)
 }
 
-func TestTransferGroup(t *testing.T) {
+func TestShipGroupTransfer(t *testing.T) {
 	c, g := newCache()
 	assert.NoError(t, c.CreateShips(Race_0_idx, ShipType_Cruiser, R0_Planet_0_num, 11)) // group #1 (0)
 	assert.NoError(t, c.CreateShips(Race_1_idx, ShipType_Cruiser, R1_Planet_1_num, 23)) // group #1 (1)
 
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 17)) // group #2 (2) - In_Space
-	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, "R0_Fleet", 2, 0))
+	assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, "R0_Fleet", 2, 0))
 	assert.NotNil(t, c.ShipGroup(2).FleetID)
 	c.ShipGroup(2).StateInSpace = &InSpace
 	c.ShipGroup(2).CargoType = game.CargoMaterial.Ref()
@@ -183,31 +183,31 @@ func TestTransferGroup(t *testing.T) {
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_1_idx)), 1)
 
 	assert.ErrorContains(t,
-		g.TransferGroup(UnknownRace, Race_1.Name, 2, 0),
+		g.ShipGroupTransfer(UnknownRace, Race_1.Name, 2, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_0.Name, UnknownRace, 2, 0),
+		g.ShipGroupTransfer(Race_0.Name, UnknownRace, 2, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_0.Name, Race_Extinct.Name, 2, 0),
+		g.ShipGroupTransfer(Race_0.Name, Race_Extinct.Name, 2, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_Extinct.Name, Race_1.Name, 2, 0),
+		g.ShipGroupTransfer(Race_Extinct.Name, Race_1.Name, 2, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_0.Name, Race_0.Name, 2, 0),
+		g.ShipGroupTransfer(Race_0.Name, Race_0.Name, 2, 0),
 		e.GenericErrorText(e.ErrInputSameRace))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_0.Name, Race_1.Name, 555, 0),
+		g.ShipGroupTransfer(Race_0.Name, Race_1.Name, 555, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_0.Name, Race_1.Name, 2, 18),
+		g.ShipGroupTransfer(Race_0.Name, Race_1.Name, 2, 18),
 		e.GenericErrorText(e.ErrBeakGroupNumberNotEnough))
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_0.Name, Race_1.Name, 1, 0),
+		g.ShipGroupTransfer(Race_0.Name, Race_1.Name, 1, 0),
 		e.GenericErrorText(e.ErrGiveawayGroupShipsTypeNotEqual))
 
-	assert.NoError(t, g.TransferGroup(Race_0.Name, Race_1.Name, 2, 11)) // group #2 (3)
+	assert.NoError(t, g.ShipGroupTransfer(Race_0.Name, Race_1.Name, 2, 11)) // group #2 (3)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 2)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_1_idx)), 2)
 
@@ -233,28 +233,28 @@ func TestTransferGroup(t *testing.T) {
 	assert.Equal(t, c.ShipGroup(3).Number, uint(11))
 	assert.Nil(t, c.ShipGroup(3).FleetID)
 
-	assert.NoError(t, g.TransferGroup(Race_1.Name, Race_0.Name, 2, 11))
+	assert.NoError(t, g.ShipGroupTransfer(Race_1.Name, Race_0.Name, 2, 11))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_1_idx)), 1)
 
 	assert.NoError(t, c.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 1))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, game.StateInOrbit, c.ShipGroup(4).State())
-	assert.NoError(t, g.SendGroup(Race_0.Name, c.ShipGroup(4).Index, R0_Planet_2_num, 0))
+	assert.NoError(t, g.ShipGroupSend(Race_0.Name, c.ShipGroup(4).Index, R0_Planet_2_num, 0))
 	assert.Equal(t, game.StateLaunched, c.ShipGroup(4).State())
 	assert.Equal(t, c.ShipGroup(4).OwnerID, Race_0_ID)
 
-	assert.NoError(t, g.TransferGroup(Race_0.Name, Race_1.Name, c.ShipGroup(4).Index, 0))
+	assert.NoError(t, g.ShipGroupTransfer(Race_0.Name, Race_1.Name, c.ShipGroup(4).Index, 0))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_1_idx)), 2)
 	assert.Equal(t, game.StateTransfer, c.ShipGroup(4).State())
 	assert.Equal(t, c.ShipGroup(4).OwnerID, Race_1_ID)
 	assert.ErrorContains(t,
-		g.TransferGroup(Race_1.Name, Race_0.Name, c.ShipGroup(4).Index, 0),
+		g.ShipGroupTransfer(Race_1.Name, Race_0.Name, c.ShipGroup(4).Index, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 }
 
-func TestLoadCargo(t *testing.T) {
+func TestShipGroupLoad(t *testing.T) {
 	c, g := newCache()
 
 	// 1: idx = 0 / Ready to load
@@ -280,49 +280,49 @@ func TestLoadCargo(t *testing.T) {
 
 	// tests
 	assert.ErrorContains(t,
-		g.LoadCargo(UnknownRace, 1, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(UnknownRace, 1, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_Extinct.Name, 1, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_Extinct.Name, 1, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 1, "GOLD", 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 1, "GOLD", 0, 0),
 		e.GenericErrorText(e.ErrInputCargoTypeInvalid))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 555, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 555, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 3, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 3, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 5, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 5, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 2, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 2, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputNoCargoBay))
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 4, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 4, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputCargoLoadNotEqual))
 
 	// initial planet is empty
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputCargoLoadNotEnough))
 	// add cargo to planet
 	c.PutMaterial(R0_Planet_0_num, 100)
 	// not enough on the planet
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 11, 101),
+		g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 11, 101),
 		e.GenericErrorText(e.ErrInputCargoLoadNotEnough))
 	// quantity > ships
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 0, 1),
+		g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 0, 1),
 		e.GenericErrorText(e.ErrInputCargoQuantityWithoutGroupBreak))
 
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 5)
 
 	// break group and load maximum
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 2, 0))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 2, 0))
 	assert.Equal(t, 58.0, c.MustPlanet(R0_Planet_0_num).Material.F())
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 6)
 	assert.Nil(t, c.ShipGroup(0).CargoType)
@@ -333,7 +333,7 @@ func TestLoadCargo(t *testing.T) {
 	assert.Equal(t, 42.0, c.ShipGroup(5).Load.F())
 
 	// break group and load limited
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 2, 18))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 2, 18))
 	assert.Equal(t, 40.0, c.MustPlanet(R0_Planet_0_num).Material.F())
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
 	assert.Nil(t, c.ShipGroup(0).CargoType)
@@ -346,7 +346,7 @@ func TestLoadCargo(t *testing.T) {
 	// add cargo to planet
 	c.PutMaterial(R0_Planet_0_num, 100)
 	// loading all available cargo
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
 	assert.Equal(t, 0.0, c.MustPlanet(R0_Planet_0_num).Material.F())
 	assert.Equal(t, 100.0, c.ShipGroup(0).Load.F()) // free: 131.0
@@ -354,14 +354,14 @@ func TestLoadCargo(t *testing.T) {
 
 	// add cargo to planet
 	c.PutMaterial(R0_Planet_0_num, 200)
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 11, 31))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 11, 31))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
 	assert.Equal(t, 169.0, c.MustPlanet(R0_Planet_0_num).Material.F())
 	assert.Equal(t, 131.0, c.ShipGroup(0).Load.F()) // free: 100.0
 	assert.Equal(t, game.CargoMaterial.Ref(), c.ShipGroup(0).CargoType)
 
 	// load to maximum cargo space left
-	assert.NoError(t, g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 11, 0))
+	assert.NoError(t, g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 11, 0))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
 	assert.Equal(t, 153.0, c.MustPlanet(R0_Planet_0_num).Material.F())
 	assert.Equal(t, 147.0, c.ShipGroup(0).Load.F()) // free: 0.0
@@ -369,12 +369,12 @@ func TestLoadCargo(t *testing.T) {
 
 	// ship group is full
 	assert.ErrorContains(t,
-		g.LoadCargo(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0),
+		g.ShipGroupLoad(Race_0.Name, 1, game.CargoMaterial.String(), 0, 0),
 		e.GenericErrorText(e.ErrInputCargoLoadNoSpaceLeft))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
 }
 
-func TestUnloadCargo(t *testing.T) {
+func TestShipGroupUnload(t *testing.T) {
 	c, g := newCache()
 
 	// 1: idx = 0 / empty
@@ -408,39 +408,39 @@ func TestUnloadCargo(t *testing.T) {
 
 	// tests
 	assert.ErrorContains(t,
-		g.UnloadCargo(UnknownRace, 1, 0, 0),
+		g.ShipGroupUnload(UnknownRace, 1, 0, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_Extinct.Name, 1, 0, 0),
+		g.ShipGroupUnload(Race_Extinct.Name, 1, 0, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 555, 0, 0),
+		g.ShipGroupUnload(Race_0.Name, 555, 0, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 3, 0, 0),
+		g.ShipGroupUnload(Race_0.Name, 3, 0, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 2, 0, 0),
+		g.ShipGroupUnload(Race_0.Name, 2, 0, 0),
 		e.GenericErrorText(e.ErrInputNoCargoBay))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 1, 0, 0),
+		g.ShipGroupUnload(Race_0.Name, 1, 0, 0),
 		e.GenericErrorText(e.ErrInputCargoUnloadEmpty))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 5, 0, 0),
+		g.ShipGroupUnload(Race_0.Name, 5, 0, 0),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 	c.ShipGroup(0).CargoType = game.CargoColonist.Ref()
 	c.ShipGroup(0).Load = 100
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 1, 11, 101),
+		g.ShipGroupUnload(Race_0.Name, 1, 11, 101),
 		e.GenericErrorText(e.ErrInputCargoUnoadNotEnough))
 	assert.ErrorContains(t,
-		g.UnloadCargo(Race_0.Name, 1, 0, 1),
+		g.ShipGroupUnload(Race_0.Name, 1, 0, 1),
 		e.GenericErrorText(e.ErrInputCargoQuantityWithoutGroupBreak))
 
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 6)
 
 	// unload MAT on foreign planet / break group
-	assert.NoError(t, g.UnloadCargo(Race_0.Name, 6, 3, 0))
+	assert.NoError(t, g.ShipGroupUnload(Race_0.Name, 6, 3, 0))
 	assert.Equal(t, 27.273, number.Fixed3(c.MustPlanet(R1_Planet_1_num).Material.F()))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 7)
 	assert.Equal(t, uint(3), c.ShipGroup(6).Number)
@@ -452,7 +452,7 @@ func TestUnloadCargo(t *testing.T) {
 	assert.Equal(t, 72.727, number.Fixed3(c.ShipGroup(5).Load.F()))
 
 	// unload MAT on foreign planet / break group / limited MAT
-	assert.NoError(t, g.UnloadCargo(Race_0.Name, 6, 3, 20.0))
+	assert.NoError(t, g.ShipGroupUnload(Race_0.Name, 6, 3, 20.0))
 	assert.Equal(t, 47.273, number.Fixed3(c.MustPlanet(R1_Planet_1_num).Material.F()))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 8)
 	assert.Equal(t, uint(3), c.ShipGroup(7).Number)
@@ -463,7 +463,7 @@ func TestUnloadCargo(t *testing.T) {
 	assert.Equal(t, 45.455, number.Fixed3(c.ShipGroup(5).Load.F()))
 
 	// unload ALL
-	assert.NoError(t, g.UnloadCargo(Race_0.Name, 1, 0, 0))
+	assert.NoError(t, g.ShipGroupUnload(Race_0.Name, 1, 0, 0))
 	assert.Equal(t, 100.0, number.Fixed3(c.MustPlanet(R0_Planet_0_num).Colonists.F()))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 8)
 	assert.Equal(t, uint(10), c.ShipGroup(0).Number)
@@ -471,7 +471,7 @@ func TestUnloadCargo(t *testing.T) {
 	assert.Equal(t, 0.0, number.Fixed3(c.ShipGroup(0).Load.F()))
 }
 
-func TestDisassembleGroup(t *testing.T) {
+func TestShipGroupDismantle(t *testing.T) {
 	c, g := newCache()
 
 	// 1: idx = 0 / empty
@@ -502,26 +502,26 @@ func TestDisassembleGroup(t *testing.T) {
 
 	// tests
 	assert.ErrorContains(t,
-		g.DisassembleGroup(UnknownRace, 1, 0),
+		g.ShipGroupDismantle(UnknownRace, 1, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.DisassembleGroup(Race_Extinct.Name, 1, 0),
+		g.ShipGroupDismantle(Race_Extinct.Name, 1, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.DisassembleGroup(Race_0.Name, 555, 0),
+		g.ShipGroupDismantle(Race_0.Name, 555, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.DisassembleGroup(Race_0.Name, 2, 0),
+		g.ShipGroupDismantle(Race_0.Name, 2, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 	assert.ErrorContains(t,
-		g.DisassembleGroup(Race_0.Name, 3, 12),
+		g.ShipGroupDismantle(Race_0.Name, 3, 12),
 		e.GenericErrorText(e.ErrBeakGroupNumberNotEnough))
 
 	groupEmptyMass := c.ShipGroup(4).EmptyMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
 	planetMAT := c.MustPlanet(R1_Planet_1_num).Material.F()
 	planetCOL := c.MustPlanet(R1_Planet_1_num).Colonists.F()
 
-	assert.NoError(t, g.DisassembleGroup(Race_0.Name, 5, 0))
+	assert.NoError(t, g.ShipGroupDismantle(Race_0.Name, 5, 0))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, planetMAT+groupEmptyMass, c.MustPlanet(R1_Planet_1_num).Material.F())
 	assert.Equal(t, planetCOL, c.MustPlanet(R1_Planet_1_num).Colonists.F())
@@ -529,7 +529,7 @@ func TestDisassembleGroup(t *testing.T) {
 	groupEmptyMass = c.ShipGroup(3).EmptyMass(c.MustShipClass(Race_0_idx, Race_0_Freighter))
 	groupLoadMAT := c.ShipGroup(3).Load.F()
 	planetMAT = c.MustPlanet(R1_Planet_1_num).Material.F()
-	assert.NoError(t, g.DisassembleGroup(Race_0.Name, 4, 0))
+	assert.NoError(t, g.ShipGroupDismantle(Race_0.Name, 4, 0))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
 	assert.Equal(t, planetMAT+groupEmptyMass+groupLoadMAT, c.MustPlanet(R1_Planet_1_num).Material.F())
 
@@ -547,7 +547,7 @@ func TestDisassembleGroup(t *testing.T) {
 	freePOPLeft := c.MustPlanet(R0_Planet_0_num).Size.F() - c.MustPlanet(R0_Planet_0_num).Population.F()
 	expectAddedCOL := (expectPOPIncrease - freePOPLeft) / 8
 	expectAddedPOP := freePOPLeft
-	assert.NoError(t, g.DisassembleGroup(Race_0.Name, 3, quantity))
+	assert.NoError(t, g.ShipGroupDismantle(Race_0.Name, 3, quantity))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 3)
 	assert.Equal(t, planetCOL+expectAddedCOL, c.MustPlanet(R0_Planet_0_num).Colonists.F())
 	assert.Equal(t, planetPOP+expectAddedPOP, c.MustPlanet(R0_Planet_0_num).Population.F())

internal/controller/ship_group_upgrade_test.go

@@ -113,7 +113,7 @@ func TestUpgradeGroupPreference(t *testing.T) {
 	assert.Equal(t, 900., sg.StateUpgrade.Cost())
 }
 
-func TestUpgradeGroup(t *testing.T) {
+func TestShipGroupUpgrade(t *testing.T) {
 	c, g := newCache()
 	// group #1 - in_orbit, free to upgrade
 	assert.NoError(t, c.CreateShips(Race_0_idx, ShipType_Cruiser, R0_Planet_0_num, 10))
@@ -125,43 +125,43 @@ func TestUpgradeGroup(t *testing.T) {
 	c.ShipGroup(2).Destination = R1_Planet_1_num
 
 	assert.ErrorContains(t,
-		g.UpgradeGroup(UnknownRace, 1, "DRIVE", 0, 0),
+		g.ShipGroupUpgrade(UnknownRace, 1, "DRIVE", 0, 0),
 		e.GenericErrorText(e.ErrInputUnknownRace))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_Extinct.Name, 1, "DRIVE", 0, 0),
+		g.ShipGroupUpgrade(Race_Extinct.Name, 1, "DRIVE", 0, 0),
 		e.GenericErrorText(e.ErrRaceExinct))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 555, "DRIVE", 0, 0),
+		g.ShipGroupUpgrade(Race_0.Name, 555, "DRIVE", 0, 0),
 		e.GenericErrorText(e.ErrInputEntityNotExists))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 2, "DRIVE", 0, 0),
+		g.ShipGroupUpgrade(Race_0.Name, 2, "DRIVE", 0, 0),
 		e.GenericErrorText(e.ErrShipsBusy))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 3, "DRIVE", 0, 0),
+		g.ShipGroupUpgrade(Race_0.Name, 3, "DRIVE", 0, 0),
 		e.GenericErrorText(e.ErrInputEntityNotOwned))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 1, "GUN", 0, 0),
+		g.ShipGroupUpgrade(Race_0.Name, 1, "GUN", 0, 0),
 		e.GenericErrorText(e.ErrInputTechUnknown))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 1, "CARGO", 0, 0),
+		g.ShipGroupUpgrade(Race_0.Name, 1, "CARGO", 0, 0),
 		e.GenericErrorText(e.ErrInputUpgradeShipTechNotUsed))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 1, "ALL", 0, 2.0),
+		g.ShipGroupUpgrade(Race_0.Name, 1, "ALL", 0, 2.0),
 		e.GenericErrorText(e.ErrInputUpgradeParameterNotAllowed))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 1, "DRIVE", 0, 2.0),
+		g.ShipGroupUpgrade(Race_0.Name, 1, "DRIVE", 0, 2.0),
 		e.GenericErrorText(e.ErrInputUpgradeTechLevelInsufficient))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 1, "DRIVE", 0, 1.1),
+		g.ShipGroupUpgrade(Race_0.Name, 1, "DRIVE", 0, 1.1),
 		e.GenericErrorText(e.ErrInputUpgradeShipsAlreadyUpToDate))
 
 	c.RaceTechLevel(Race_0_idx, game.TechDrive, 10.0)
 	assert.Equal(t, 10.0, c.Race(Race_0_idx).TechLevel(game.TechDrive))
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 1, "DRIVE", 0, 10.0),
+		g.ShipGroupUpgrade(Race_0.Name, 1, "DRIVE", 0, 10.0),
 		e.GenericErrorText(e.ErrUpgradeInsufficientResources))
 
-	assert.NoError(t, g.UpgradeGroup(Race_0.Name, 1, "DRIVE", 2, 1.2))
+	assert.NoError(t, g.ShipGroupUpgrade(Race_0.Name, 1, "DRIVE", 2, 1.2))
 	assert.Len(t, slices.Collect(c.RaceShipGroups(Race_0_idx)), 4)
 	assert.Equal(t, uint(8), c.ShipGroup(0).Number)
 	assert.Equal(t, uint(2), c.ShipGroup(3).Number)
@@ -169,6 +169,6 @@ func TestUpgradeGroup(t *testing.T) {
 	assert.Equal(t, game.StateUpgrade, c.ShipGroup(3).State())
 
 	assert.ErrorContains(t,
-		g.UpgradeGroup(Race_0.Name, 4, "DRIVE", 1, 1.3),
+		g.ShipGroupUpgrade(Race_0.Name, 4, "DRIVE", 1, 1.3),
 		e.GenericErrorText(e.ErrShipsBusy))
 }

internal/model/rest/command.go

@@ -10,19 +10,20 @@ type Command struct {
 type CommandType string
 
 const (
-	CommandTypeQuit               CommandType = "quit"
+	CommandTypeRaceQuit           CommandType = "quit"
-	CommandTypeVote               CommandType = "vote"
+	CommandTypeRaceVote           CommandType = "vote"
-	CommandTypeRelation           CommandType = "declarePeace"
+	CommandTypeRaceRelation       CommandType = "declarePeace"
-	CommandShipClassCreate        CommandType = "shipClassCreate"
+	CommandTypeShipClassCreate    CommandType = "shipClassCreate"
-	CommandShipClassMerge         CommandType = "shipClassMerge"
+	CommandTypeShipClassMerge     CommandType = "shipClassMerge"
-	CommandShipClassRemove        CommandType = "shipClassRemove"
+	CommandTypeShipClassRemove    CommandType = "shipClassRemove"
-	CommandShipGroupLoad          CommandType = "shipGroupLoad"
+	CommandTypeShipGroupLoad      CommandType = "shipGroupLoad"
-	CommandShipGroupUnload        CommandType = "shipGroupUnload"
+	CommandTypeShipGroupUnload    CommandType = "shipGroupUnload"
-	CommandShipGroupSend          CommandType = "shipGroupSend"
+	CommandTypeShipGroupSend      CommandType = "shipGroupSend"
-	CommandShipGroupUpgrade       CommandType = "shipGroupUpgrade"
+	CommandTypeShipGroupUpgrade   CommandType = "shipGroupUpgrade"
-	CommandShipGroupMerge         CommandType = "shipGroupMerge"
+	CommandTypeShipGroupBreak     CommandType = "shipGroupBreak"
-	CommandShipGroupDismantle     CommandType = "shipGroupDismantle"
+	CommandTypeShipGroupMerge     CommandType = "shipGroupMerge"
-	CommandShipGroupTransfer      CommandType = "shipGroupTransfer"
+	CommandTypeShipGroupDismantle CommandType = "shipGroupDismantle"
+	CommandTypeShipGroupTransfer  CommandType = "shipGroupTransfer"
 	CommandTypeShipGroupJoinFleet CommandType = "shipGroupJoinFleet"
 	CommandTypeFleetMerge         CommandType = "fleetMerge"
 	CommandTypeFleetSend          CommandType = "fleetSend"

internal/router/command_test.go

@@ -17,7 +17,7 @@ func TestCommand(t *testing.T) {
 		Actor: "SomeRace",
 		Commands: []json.RawMessage{
 			encodeCommand(&rest.CommandVote{
-				CommandMeta: rest.CommandMeta{Type: rest.CommandTypeVote},
+				CommandMeta: rest.CommandMeta{Type: rest.CommandTypeRaceVote},
 				Recipient:   "AnotherRace",
 			}),
 		},

internal/router/handler/command.go

@@ -43,9 +43,9 @@ func parseCommand(actor string, c json.RawMessage) (Command, error) {
 		return nil, err
 	}
 	switch t := meta.Type; t {
-	case rest.CommandTypeVote:
+	case rest.CommandTypeRaceVote:
 		return giveVotes(actor, c)
-	case rest.CommandTypeRelation:
+	case rest.CommandTypeRaceRelation:
 		return updateRelation(actor, c)
 	default:
 		return nil, fmt.Errorf("unknown comman type: %s", t)
@@ -57,7 +57,7 @@ func giveVotes(actor string, c json.RawMessage) (Command, error) {
 	if err := json.Unmarshal(c, &v); err != nil {
 		return nil, err
 	}
-	return func(c controller.Ctrl) error { return c.GiveVotes(actor, v.Recipient) }, nil
+	return func(c controller.Ctrl) error { return c.RaceVote(actor, v.Recipient) }, nil
 }
 
 func updateRelation(actor string, c json.RawMessage) (Command, error) {
@@ -65,5 +65,5 @@ func updateRelation(actor string, c json.RawMessage) (Command, error) {
 	if err := json.Unmarshal(c, &v); err != nil {
 		return nil, err
 	}
-	return func(c controller.Ctrl) error { return c.UpdateRelation(actor, v.Opponent, v.Relation) }, nil
+	return func(c controller.Ctrl) error { return c.RaceRelation(actor, v.Opponent, v.Relation) }, nil
 }