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

refactor: race index by name

Browse Source
This commit is contained in:
Ilia Denisov
2025-10-02 22:41:04 +03:00
parent 0890bf3009
commit cafdd10bab
10 changed files with 129 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/error/generic.go
+3 -6
View File
@@ -16,8 +16,7 @@ const (
)
const (
ErrInputUnknownHostRace int = 3000 + iota
ErrInputUnknownOpponentRace
ErrInputUnknownRace int = 3000 + iota
ErrInputEntityTypeNameInvalid
ErrInputEntityTypeNameDuplicate
ErrInputEntityNotExists
@@ -42,10 +41,8 @@ func GenericErrorText(code int) string {
return "Storage failure"
case ErrGameStateInvalid:
return "Invalid game state"
case ErrInputUnknownHostRace:
return "Host race name is unknown to this game"
case ErrInputUnknownOpponentRace:
return "Opponent race name is unknown to this game"
case ErrInputUnknownRace:
return "Race name is unknown to this game"
case ErrInputEntityTypeNameInvalid:
return "Name has invalid length or symbols"
case ErrInputEntityTypeNameDuplicate:
pkg/error/input.go
+2 -6
View File
@@ -1,11 +1,7 @@
package error
func NewHostRaceUnknownError(arg ...any) error {
return newGenericError(ErrInputUnknownHostRace, arg...)
}
func NewOpponentRaceUnknownError(arg ...any) error {
return newGenericError(ErrInputUnknownOpponentRace, arg...)
func NewRaceUnknownError(arg ...any) error {
return newGenericError(ErrInputUnknownRace, arg...)
}
func NewEntityTypeNameValidationError(arg ...any) error {
pkg/game/cmd_planet_test.go
+1 -1
View File
@@ -44,7 +44,7 @@ func TestRenamePlanet(t *testing.T) {
otherRace := cg.Race[ri].Name
err = game.RenamePlanet(p, unknownRaceName, number, newName) // TODO: test actual rip race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownHostRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
err = game.RenamePlanet(p, race, number, "")
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityTypeNameInvalid))
err = game.RenamePlanet(p, race, -1, newName)
pkg/game/cmd_science_test.go
+4 -3
View File
@@ -17,7 +17,7 @@ func TestCreateScience(t *testing.T) {
err := game.DeleteScience(p, race, typeName)
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
err = game.CreateScience(p, unknownRaceName, " "+typeName+" ", 1, 0, 0, 0) // TODO: test on dead race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownHostRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
err = game.CreateScience(p, race, " "+typeName+" ", 1, 0, 0, 0)
assert.NoError(t, err)
sc, err := g().Sciences(race)
@@ -28,9 +28,10 @@ func TestCreateScience(t *testing.T) {
assert.Equal(t, sc[0].Weapons, 0.)
assert.Equal(t, sc[0].Shields, 0.)
assert.Equal(t, sc[0].Cargo, 0.)
// TODO: test with existing ship group
// TODO: test delete with existing ship group
// TODO: test delete with planet production busy with science
err = game.DeleteScience(p, unknownRaceName, typeName) // TODO: test with actial rip race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownHostRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
err = game.DeleteScience(p, race, typeName)
assert.NoError(t, err)
sc, err = g().Sciences(race)
pkg/game/cmd_ship_type_test.go
+2 -2
View File
@@ -17,7 +17,7 @@ func TestCreateShipType(t *testing.T) {
err := game.DeleteShipType(p, race, typeName)
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputEntityNotExists))
err = game.CreateShipType(p, unknownRaceName, " "+typeName+" ", 1, 0, 0, 0, 0) // TODO: test on dead race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownHostRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
err = game.CreateShipType(p, race, " "+typeName+" ", 1, 0, 0, 0, 0)
assert.NoError(t, err)
st, err := g().ShipTypes(race)
@@ -31,7 +31,7 @@ func TestCreateShipType(t *testing.T) {
assert.Equal(t, st[0].Armament, uint(0))
// TODO: test with existing ship group
err = game.DeleteShipType(p, unknownRaceName, typeName) // TODO: test on dead race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownHostRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
err = game.DeleteShipType(p, race, typeName)
assert.NoError(t, err)
st, err = g().ShipTypes(race)
pkg/game/cmd_war_peace_test.go
+2 -2
View File
@@ -20,9 +20,9 @@ func TestDeclarePeaceAndWarSingle(t *testing.T) {
assert.Equal(t, mg.RelationWar, r.Relation)
r, err = g().Relation(unknownRaceName, opponentRace) // TODO: test on dead race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownHostRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
r, err = g().Relation(hostRace, unknownRaceName) // TODO: test on dead race
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownOpponentRace))
assert.ErrorContains(t, err, e.GenericErrorText(e.ErrInputUnknownRace))
assert.NoError(t, game.DeclarePeace(f, hostRace, opponentRace))
r, err = g().Relation(hostRace, opponentRace)
pkg/model/game/game.go
+25 -58
View File
@@ -27,98 +27,65 @@ func (g Game) Votes(raceID uuid.UUID) float64 {
return pop / 1000.
}
func (g Game) hostRaceID(name string) (uuid.UUID, error) {
if v, ok := g.raceID(name); ok {
return v, nil
}
return uuid.Nil, e.NewHostRaceUnknownError(name)
}
func (g Game) raceIndex(name string) (int, error) {
i := slices.IndexFunc(g.Race, func(r Race) bool { return r.Name == name })
if i < 0 {
return i, e.NewHostRaceUnknownError(name)
return i, e.NewRaceUnknownError(name)
}
return i, nil
}
func (g Game) opponentRaceID(name string) (uuid.UUID, error) {
if v, ok := g.raceID(name); ok {
return v, nil
}
return uuid.Nil, e.NewOpponentRaceUnknownError(name)
}
func (g Game) raceID(raceName string) (uuid.UUID, bool) {
for i := range g.Race {
if g.Race[i].Name == raceName {
return g.Race[i].ID, true
}
}
return uuid.Nil, false
}
func (g Game) UpdateRelation(hostRace, opponentRace string, rel Relation) error {
hostID, err := g.hostRaceID(hostRace)
func (g Game) UpdateRelation(race, opponent string, rel Relation) error {
ri, err := g.raceIndex(race)
if err != nil {
return err
}
var opponentID uuid.UUID
if hostRace == opponentRace {
opponentID = hostID
} else if opponentID, err = g.opponentRaceID(opponentRace); err != nil {
var other int
if race == opponent {
other = ri
} else if other, err = g.raceIndex(opponent); err != nil {
return err
}
return g.updateRelationInternal(hostID, opponentID, rel)
if err != nil {
return err
}
return g.updateRelationInternal(ri, other, rel)
}
func (g Game) updateRelationInternal(hostID, opponentID uuid.UUID, rel Relation) error {
for r := range g.Race {
if g.Race[r].ID == hostID {
for o := range g.Race[r].Relations {
func (g Game) updateRelationInternal(ri, other int, rel Relation) error {
for o := range g.Race[ri].Relations {
switch {
case hostID == opponentID:
g.Race[r].Relations[o].Relation = rel
case g.Race[r].Relations[o].RaceID == opponentID:
g.Race[r].Relations[o].Relation = rel
case ri == other:
g.Race[ri].Relations[o].Relation = rel
case g.Race[ri].Relations[o].RaceID == g.Race[other].ID:
g.Race[ri].Relations[o].Relation = rel
return nil
}
}
if hostID != opponentID {
if ri != other {
return e.NewGameStateError("UpdateRelation: opponent not found")
}
}
}
if hostID != opponentID {
return e.NewGameStateError("UpdateRelation: host %v not found", hostID)
}
return nil
}
func (g Game) Relation(hostRace, opponentRace string) (RaceRelation, error) {
hostID, err := g.hostRaceID(hostRace)
ri, err := g.raceIndex(hostRace)
if err != nil {
return RaceRelation{}, err
}
opponentID, err := g.opponentRaceID(opponentRace)
other, err := g.raceIndex(opponentRace)
if err != nil {
return RaceRelation{}, err
}
return g.relationInternal(hostID, opponentID)
return g.relationInternal(ri, other)
}
func (g Game) relationInternal(hostID, opponentID uuid.UUID) (RaceRelation, error) {
for r := range g.Race {
if g.Race[r].ID == hostID {
for o := range g.Race[r].Relations {
if g.Race[r].Relations[o].RaceID == opponentID {
return g.Race[r].Relations[o], nil
}
}
func (g Game) relationInternal(ri, other int) (RaceRelation, error) {
rel := slices.IndexFunc(g.Race[ri].Relations, func(r RaceRelation) bool { return r.RaceID == g.Race[other].ID })
if rel < 0 {
return RaceRelation{}, e.NewGameStateError("Relation: opponent not found")
}
}
return RaceRelation{}, e.NewGameStateError("Relation: host %v not found", hostID)
return g.Race[ri].Relations[rel], nil
}
// -----------------------------------------------------------------------------
pkg/model/game/planet.go
+10 -11
View File
@@ -2,6 +2,7 @@ package game
import (
"math"
"slices"
"github.com/google/uuid"
e "github.com/iliadenisov/galaxy/pkg/error"
@@ -77,14 +78,14 @@ func (p *Planet) IncreasePopulation() {
}
func (g Game) RenamePlanet(raceName string, planetNumber int, typeName string) error {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return err
}
return g.renamePlanetInternal(raceID, planetNumber, typeName)
return g.renamePlanetInternal(ri, planetNumber, typeName)
}
func (g Game) renamePlanetInternal(race uuid.UUID, number int, name string) error {
func (g Game) renamePlanetInternal(ri int, number int, name string) error {
n, ok := validateTypeName(name)
if !ok {
return e.NewEntityTypeNameValidationError("%q", n)
@@ -92,15 +93,13 @@ func (g Game) renamePlanetInternal(race uuid.UUID, number int, name string) erro
if number < 0 {
return e.NewPlanetNumberError(number)
}
num := uint(number)
for pl := range g.Map.Planet {
if g.Map.Planet[pl].Number == num {
if g.Map.Planet[pl].Owner != race {
return e.NewEntityNotOwnedError("planet %#d", num)
pl := slices.IndexFunc(g.Map.Planet, func(p Planet) bool { return p.Number == uint(number) })
if pl < 0 {
return e.NewEntityNotExistsError("planet #%d", number)
}
if g.Map.Planet[pl].Owner != g.Race[ri].ID {
return e.NewEntityNotOwnedError("planet %#d", number)
}
g.Map.Planet[pl].Name = n
return nil
}
}
return e.NewEntityNotExistsError("planet #%d", number)
}
pkg/model/game/science.go
+26 -43
View File
@@ -1,6 +1,8 @@
package game
import (
"slices"
"github.com/google/uuid"
e "github.com/iliadenisov/galaxy/pkg/error"
)
@@ -24,61 +26,50 @@ type ScienceReport struct {
}
func (g Game) Sciences(raceName string) ([]Science, error) {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return nil, err
}
return g.sciencesInternal(raceID)
return g.sciencesInternal(ri), nil
}
func (g Game) sciencesInternal(race uuid.UUID) ([]Science, error) {
for r := range g.Race {
if g.Race[r].ID == race {
return g.Race[r].Sciences, nil
}
}
return nil, e.NewGameStateError("Sciences: race %v not found", race)
func (g Game) sciencesInternal(ri int) []Science {
return g.Race[ri].Sciences
}
func (g Game) DeleteScience(raceName, typeName string) error {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return err
}
return g.deleteScienceInternal(raceID, typeName)
return g.deleteScienceInternal(ri, typeName)
}
func (g Game) deleteScienceInternal(race uuid.UUID, name string) error {
for r := range g.Race {
if g.Race[r].ID == race {
for sc := range g.Race[r].Sciences {
if g.Race[r].Sciences[sc].Name == name {
for pl := range g.Map.Planet {
if g.Map.Planet[pl].Production.Production == ResearchScience &&
g.Map.Planet[pl].Production.SubjectID != nil &&
*g.Map.Planet[pl].Production.SubjectID == g.Race[r].Sciences[sc].ID {
return e.NewDeleteSciencePlanetProductionError(g.Map.Planet[pl].Name)
}
}
g.Race[r].Sciences = append(g.Race[r].Sciences[:sc], g.Race[r].Sciences[sc+1:]...)
return nil
}
}
func (g Game) deleteScienceInternal(ri int, name string) error {
sc := slices.IndexFunc(g.Race[ri].Sciences, func(s Science) bool { return s.Name == name })
if sc < 0 {
return e.NewEntityNotExistsError("science %w", name)
}
if pl := slices.IndexFunc(g.Map.Planet, func(p Planet) bool {
return p.Production.Production == ResearchScience &&
p.Production.SubjectID != nil &&
*p.Production.SubjectID == g.Race[ri].Sciences[sc].ID
}); pl >= 0 {
return e.NewDeleteSciencePlanetProductionError(g.Map.Planet[pl].Name)
}
return e.NewGameStateError("DeleteScience: race %v not found", race)
g.Race[ri].Sciences = append(g.Race[ri].Sciences[:sc], g.Race[ri].Sciences[sc+1:]...)
return nil
}
func (g Game) CreateScience(raceName, typeName string, d, w, s, c float64) error {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return err
}
return g.createScienceInternal(raceID, typeName, d, w, s, c)
return g.createScienceInternal(ri, typeName, d, w, s, c)
}
func (g Game) createScienceInternal(race uuid.UUID, name string, d, w, s, c float64) error {
func (g Game) createScienceInternal(ri int, name string, d, w, s, c float64) error {
n, ok := validateTypeName(name)
if !ok {
return e.NewEntityTypeNameValidationError("%q", n)
@@ -99,16 +90,11 @@ func (g Game) createScienceInternal(race uuid.UUID, name string, d, w, s, c floa
if sum != 1 {
return e.NewScienceSumValuesError("D=%f W=%f S=%f C=%f sum=%f", d, w, s, c, sum)
}
for r := range g.Race {
if g.Race[r].ID == race {
for sc := range g.Race[r].Sciences {
if g.Race[r].Sciences[sc].Name == n {
return e.NewEntityTypeNameDuplicateError("science %w", g.Race[r].Sciences[sc].Name)
if sc := slices.IndexFunc(g.Race[ri].Sciences, func(s Science) bool { return s.Name == n }); sc >= 0 {
return e.NewEntityTypeNameDuplicateError("science %w", g.Race[ri].Sciences[sc].Name)
}
}
id := uuid.New()
g.Race[r].Sciences = append(g.Race[r].Sciences, Science{
ID: id,
g.Race[ri].Sciences = append(g.Race[ri].Sciences, Science{
ID: uuid.New(),
ScienceReport: ScienceReport{
Name: n,
Drive: d,
@@ -119,6 +105,3 @@ func (g Game) createScienceInternal(race uuid.UUID, name string, d, w, s, c floa
})
return nil
}
}
return e.NewGameStateError("CreateScience: race %v not found", race)
}
pkg/model/game/ship.go
+25 -49
View File
@@ -2,6 +2,7 @@ package game
import (
"math"
"slices"
"github.com/google/uuid"
e "github.com/iliadenisov/galaxy/pkg/error"
@@ -128,67 +129,50 @@ func (fl Fleet) Speed() float64 {
}
func (g Game) ShipTypes(raceName string) ([]ShipType, error) {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return nil, err
}
return g.shipTypesInternal(raceID)
return g.shipTypesInternal(ri), nil
}
func (g Game) shipTypesInternal(race uuid.UUID) ([]ShipType, error) {
for r := range g.Race {
if g.Race[r].ID == race {
return g.Race[r].ShipTypes, nil
}
}
return nil, e.NewGameStateError("ShipTypes: race %v not found", race)
func (g Game) shipTypesInternal(ri int) []ShipType {
return g.Race[ri].ShipTypes
}
func (g Game) DeleteShipType(raceName, typeName string) error {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return err
}
return g.deleteShipTypeInternal(raceID, typeName)
return g.deleteShipTypeInternal(ri, typeName)
}
func (g Game) deleteShipTypeInternal(race uuid.UUID, name string) error {
for r := range g.Race {
if g.Race[r].ID == race {
for st := range g.Race[r].ShipTypes {
if g.Race[r].ShipTypes[st].Name == name {
for sg := range g.Race[r].ShipGroups {
if g.Race[r].ShipGroups[sg].TypeID == g.Race[r].ShipTypes[st].ID {
return e.NewDeleteShipTypeExistingGroupError(g.Race[r].ShipGroups[sg].Number)
}
}
for pl := range g.Map.Planet {
if g.Map.Planet[pl].Owner == race &&
g.Map.Planet[pl].Production.Production == ProductionShip &&
g.Map.Planet[pl].Production.SubjectID != nil &&
g.Race[r].ShipTypes[st].ID == *g.Map.Planet[pl].Production.SubjectID {
return e.NewDeleteShipTypePlanetProductionError(g.Map.Planet[pl].Name)
}
}
g.Race[r].ShipTypes = append(g.Race[r].ShipTypes[:st], g.Race[r].ShipTypes[st+1:]...)
return nil
}
}
func (g Game) deleteShipTypeInternal(ri int, name string) error {
st := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.Name == name })
if st < 0 {
return e.NewEntityNotExistsError("ship type %w", name)
}
if pl := slices.IndexFunc(g.Map.Planet, func(p Planet) bool {
return p.Production.Production == ProductionShip &&
p.Production.SubjectID != nil &&
g.Race[ri].ShipTypes[st].ID == *p.Production.SubjectID
}); pl >= 0 {
return e.NewDeleteShipTypePlanetProductionError(g.Map.Planet[pl].Name)
}
return e.NewGameStateError("DeleteShipType: race %v not found", race)
g.Race[ri].ShipTypes = append(g.Race[ri].ShipTypes[:st], g.Race[ri].ShipTypes[st+1:]...)
return nil
}
func (g Game) CreateShipType(raceName, typeName string, d, w, s, c float64, a int) error {
raceID, err := g.hostRaceID(raceName)
ri, err := g.raceIndex(raceName)
if err != nil {
return err
}
return g.createShipTypeInternal(raceID, typeName, d, w, s, c, a)
return g.createShipTypeInternal(ri, typeName, d, w, s, c, a)
}
func (g Game) createShipTypeInternal(race uuid.UUID, name string, d, w, s, c float64, a int) error {
func (g Game) createShipTypeInternal(ri int, name string, d, w, s, c float64, a int) error {
if err := checkShipTypeValues(d, w, s, c, a); err != nil {
return err
}
@@ -196,16 +180,11 @@ func (g Game) createShipTypeInternal(race uuid.UUID, name string, d, w, s, c flo
if !ok {
return e.NewEntityTypeNameValidationError("%q", n)
}
for r := range g.Race {
if g.Race[r].ID == race {
for st := range g.Race[r].ShipTypes {
if g.Race[r].ShipTypes[st].Name == n {
return e.NewEntityTypeNameDuplicateError("ship type %w", g.Race[r].ShipTypes[st].Name)
if st := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.Name == name }); st >= 0 {
return e.NewEntityTypeNameDuplicateError("ship type %w", g.Race[ri].ShipTypes[st].Name)
}
}
id := uuid.New()
g.Race[r].ShipTypes = append(g.Race[r].ShipTypes, ShipType{
ID: id,
g.Race[ri].ShipTypes = append(g.Race[ri].ShipTypes, ShipType{
ID: uuid.New(),
ShipTypeReport: ShipTypeReport{
Name: n,
Drive: d,
@@ -217,9 +196,6 @@ func (g Game) createShipTypeInternal(race uuid.UUID, name string, d, w, s, c flo
})
return nil
}
}
return e.NewGameStateError("CreateShipType: race %v not found", race)
}
func checkShipTypeValues(d, w, s, c float64, a int) error {
if !checkShipTypeValueDWSC(d) {