developer/galaxy-game
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: func naming

Browse Source
This commit is contained in:
Ilia Denisov
2026-02-10 08:22:44 +02:00
parent 83bcdcbc49
commit b5400bd61e
18 changed files with 379 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/controller/battle_test.go
+4 -4
View File
@@ -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.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.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.UpdateRelation(race_D_name, race_C_name, game.RelationWar.String()))
assert.NoError(t, g.RaceRelation(race_C_name, race_D_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
+7 -7
View File
@@ -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.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.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.UpdateRelation(Race_1.Name, Race_0.Name, game.RelationWar.String()))
assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.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
+23 -23
View File
@@ -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
+23 -23
View File
@@ -45,29 +45,29 @@ type Repo interface {
type Ctrl interface {
RaceID(actor string) (uuid.UUID, error)
QuitGame(actor string) error
GiveVotes(actor, acceptor string) error
UpdateRelation(actor, acceptor string, rel string) error
JoinShipGroupToFleet(actor, fleetName string, group, count uint) error
JoinFleets(actor, fleetSourceName, fleetTargetName string) error
SendFleet(actor, fleetName string, planetNumber uint) error
RenamePlanet(actor string, planetNumber int, typeName string) error
PlanetProduction(actor string, planetNumber int, prodType, subject string) error
SetRoute(actor, loadType string, origin, destination uint) error
RemoveRoute(actor, loadType string, origin uint) error
CreateScience(actor, typeName string, drive, weapons, shields, cargo float64) error
DeleteScience(actor, typeName string) error
CreateShipType(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error
MergeShipType(actor, name, targetName string) error
DeleteShipType(actor, typeName string) error
SendGroup(actor string, groupIndex, planetNumber, quantity uint) error
UpgradeGroup(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error
JoinEqualGroups(actor string) error
BreakGroup(actor string, groupIndex, quantity uint) error
DisassembleGroup(actor string, groupIndex, quantity uint) error
LoadCargo(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error
UnloadCargo(actor string, groupIndex uint, ships uint, quantity float64) error
TransferGroup(actor, acceptor string, groupIndex, quantity uint) error
RaceQuit(actor string) error
RaceVote(actor, acceptor string) error
RaceRelation(actor, acceptor string, rel string) error
ShipClassCreate(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error
ShipClassMerge(actor, name, targetName string) error
ShipClassRemove(actor, typeName string) error
ShipGroupLoad(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error
ShipGroupUnload(actor string, groupIndex uint, ships uint, quantity float64) error
ShipGroupSend(actor string, groupIndex, planetNumber, quantity uint) error
ShipGroupUpgrade(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error
ShipGroupBreak(actor string, groupIndex, quantity uint) error
ShipGroupMerge(actor string) error
ShipGroupDismantle(actor string, groupIndex, quantity uint) error
ShipGroupTransfer(actor, acceptor string, groupIndex, quantity uint) error
ShipGroupJoinFleet(actor, fleetName string, group, count uint) error
FleetMerge(actor, fleetSourceName, fleetTargetName string) error
FleetSend(actor, fleetName string, planetNumber uint) error
ScienceCreate(actor, typeName string, drive, weapons, shields, cargo float64) error
ScienceRemove(actor, typeName string) error
PlanetRename(actor string, planetNumber int, typeName string) error
PlanetProduce(actor string, planetNumber int, prodType, subject string) error
PlanetRouteSet(actor, loadType string, origin, destination 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
+17 -17
View File
@@ -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
+28 -28
View File
@@ -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.JoinFleets(Race_0.Name, fleetSourceOne, fleetTargetTwo))
assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, fleetOnPlanet2, 2, 0))
assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, fleetTargetTwo, 3, 0))
assert.NoError(t, g.FleetMerge(Race_0.Name, fleetSourceOne, fleetTargetTwo))
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
+44 -44
View File
@@ -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.PlanetProduction(Race_0.Name, int(R0_Planet_2_num), "CAP", ""))
assert.NoError(t, g.PlanetProduce(Race_0.Name, int(R0_Planet_0_num), "MAT", ""))
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.UpgradeGroup(Race_0.Name, 1, "Drive", 0, 0))
assert.NoError(t, g.ShipGroupUpgrade(Race_0.Name, 2, "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
+18 -18
View File
@@ -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.UpdateRelation(Race_1.Name, Race_0.Name, "PEACE"))
assert.NoError(t, g.RaceRelation(Race_0.Name, Race_1.Name, "war"))
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
+45 -45
View File
@@ -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.SetRoute(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, "COL", 0, 2))
assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "CAP", 0, 2))
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.SetRoute(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.SetRoute(Race_0.Name, "EMP", R0_Planet_0_num, R1_Planet_1_num))
assert.NoError(t, g.PlanetRouteSet(Race_0.Name, "COL", 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.PlanetRouteSet(Race_0.Name, "MAT", R0_Planet_0_num, R0_Planet_2_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.SetRoute(Race_1.Name, "COL", R1_Planet_1_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.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.SetRoute(Race_1.Name, "COL", R1_Planet_1_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.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.SetRoute(Race_0.Name, "CAP", 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.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.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, R0_Planet_0_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.SetRoute(Race_0.Name, "CAP", 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.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.SetRoute(Race_1.Name, "CAP", R1_Planet_1_num, Uninhabited_Planet_4_num))
assert.NoError(t, g.PlanetRouteSet(Race_1.Name, "COL", R1_Planet_1_num, R0_Planet_0_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
+24 -24
View File
@@ -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.CreateScience(Race_0.Name, second, 0.25, 0.25, 0.25, 0.25))
assert.NoError(t, g.ScienceCreate(Race_0.Name, first, 0.4, 0, 0.6, 0))
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
+28 -28
View File
@@ -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))
g.PlanetProduction(Race_0.Name, int(R0_Planet_0_num), "SHIP", "Drone")
assert.NoError(t, g.ShipClassCreate(Race_0.Name, "Drone", 1, 0, 0, 0, 0))
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
+3 -3
View File
@@ -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.JoinShipGroupToFleet(Race_0.Name, "Fleet", 3, 0))
assert.NoError(t, g.ShipGroupJoinFleet(Race_0.Name, "Fleet", 2, 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
+14 -14
View File
@@ -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
+68 -68
View File
@@ -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
+14 -14
View File
@@ -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
+14 -13
View File
@@ -10,19 +10,20 @@ type Command struct {
type CommandType string
const (
CommandTypeQuit CommandType = "quit"
CommandTypeVote CommandType = "vote"
CommandTypeRelation CommandType = "declarePeace"
CommandShipClassCreate CommandType = "shipClassCreate"
CommandShipClassMerge CommandType = "shipClassMerge"
CommandShipClassRemove CommandType = "shipClassRemove"
CommandShipGroupLoad CommandType = "shipGroupLoad"
CommandShipGroupUnload CommandType = "shipGroupUnload"
CommandShipGroupSend CommandType = "shipGroupSend"
CommandShipGroupUpgrade CommandType = "shipGroupUpgrade"
CommandShipGroupMerge CommandType = "shipGroupMerge"
CommandShipGroupDismantle CommandType = "shipGroupDismantle"
CommandShipGroupTransfer CommandType = "shipGroupTransfer"
CommandTypeRaceQuit CommandType = "quit"
CommandTypeRaceVote CommandType = "vote"
CommandTypeRaceRelation CommandType = "declarePeace"
CommandTypeShipClassCreate CommandType = "shipClassCreate"
CommandTypeShipClassMerge CommandType = "shipClassMerge"
CommandTypeShipClassRemove CommandType = "shipClassRemove"
CommandTypeShipGroupLoad CommandType = "shipGroupLoad"
CommandTypeShipGroupUnload CommandType = "shipGroupUnload"
CommandTypeShipGroupSend CommandType = "shipGroupSend"
CommandTypeShipGroupUpgrade CommandType = "shipGroupUpgrade"
CommandTypeShipGroupBreak CommandType = "shipGroupBreak"
CommandTypeShipGroupMerge CommandType = "shipGroupMerge"
CommandTypeShipGroupDismantle CommandType = "shipGroupDismantle"
CommandTypeShipGroupTransfer CommandType = "shipGroupTransfer"
CommandTypeShipGroupJoinFleet CommandType = "shipGroupJoinFleet"
CommandTypeFleetMerge CommandType = "fleetMerge"
CommandTypeFleetSend CommandType = "fleetSend"
internal/router/command_test.go
+1 -1
View File
@@ -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
+4 -4
View File
@@ -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
}