refactor: race index by name

pkg/error/generic.go

@@ -16,8 +16,7 @@ const (
 )
 
 const (
-	ErrInputUnknownHostRace int = 3000 + iota
+	ErrInputUnknownRace int = 3000 + iota
-	ErrInputUnknownOpponentRace
 	ErrInputEntityTypeNameInvalid
 	ErrInputEntityTypeNameDuplicate
 	ErrInputEntityNotExists
@@ -42,10 +41,8 @@ func GenericErrorText(code int) string {
 		return "Storage failure"
 	case ErrGameStateInvalid:
 		return "Invalid game state"
-	case ErrInputUnknownHostRace:
+	case ErrInputUnknownRace:
-		return "Host race name is unknown to this game"
+		return "Race name is unknown to this game"
-	case ErrInputUnknownOpponentRace:
-		return "Opponent race name is unknown to this game"
 	case ErrInputEntityTypeNameInvalid:
 		return "Name has invalid length or symbols"
 	case ErrInputEntityTypeNameDuplicate:

pkg/error/input.go

@@ -1,11 +1,7 @@
 package error
 
-func NewHostRaceUnknownError(arg ...any) error {
+func NewRaceUnknownError(arg ...any) error {
-	return newGenericError(ErrInputUnknownHostRace, arg...)
+	return newGenericError(ErrInputUnknownRace, arg...)
-}
-
-func NewOpponentRaceUnknownError(arg ...any) error {
-	return newGenericError(ErrInputUnknownOpponentRace, arg...)
 }
 
 func NewEntityTypeNameValidationError(arg ...any) error {

pkg/game/cmd_planet_test.go

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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) {
+func (g Game) UpdateRelation(race, opponent string, rel Relation) error {
-	if v, ok := g.raceID(name); ok {
+	ri, err := g.raceIndex(race)
-		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)
 	if err != nil {
 		return err
 	}
-	var opponentID uuid.UUID
+	var other int
-	if hostRace == opponentRace {
+	if race == opponent {
-		opponentID = hostID
+		other = ri
-	} else if opponentID, err = g.opponentRaceID(opponentRace); err != nil {
+	} 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 {
+func (g Game) updateRelationInternal(ri, other int, rel Relation) error {
-	for r := range g.Race {
+	for o := range g.Race[ri].Relations {
-		if g.Race[r].ID == hostID {
-			for o := range g.Race[r].Relations {
 		switch {
-				case hostID == opponentID:
+		case ri == other:
-					g.Race[r].Relations[o].Relation = rel
+			g.Race[ri].Relations[o].Relation = rel
-				case g.Race[r].Relations[o].RaceID == opponentID:
+		case g.Race[ri].Relations[o].RaceID == g.Race[other].ID:
-					g.Race[r].Relations[o].Relation = rel
+			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) {
+func (g Game) relationInternal(ri, other int) (RaceRelation, error) {
-	for r := range g.Race {
+	rel := slices.IndexFunc(g.Race[ri].Relations, func(r RaceRelation) bool { return r.RaceID == g.Race[other].ID })
-		if g.Race[r].ID == hostID {
+	if rel < 0 {
-			for o := range g.Race[r].Relations {
-				if g.Race[r].Relations[o].RaceID == opponentID {
-					return g.Race[r].Relations[o], nil
-				}
-			}
 		return RaceRelation{}, e.NewGameStateError("Relation: opponent not found")
 	}
-	}
+	return g.Race[ri].Relations[rel], nil
-	return RaceRelation{}, e.NewGameStateError("Relation: host %v not found", hostID)
 }
 
 // -----------------------------------------------------------------------------

pkg/model/game/planet.go

@@ -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)
+	pl := slices.IndexFunc(g.Map.Planet, func(p Planet) bool { return p.Number == uint(number) })
-	for pl := range g.Map.Planet {
+	if pl < 0 {
-		if g.Map.Planet[pl].Number == num {
+		return e.NewEntityNotExistsError("planet #%d", number)
-			if g.Map.Planet[pl].Owner != race {
+	}
-				return e.NewEntityNotOwnedError("planet %#d", num)
+	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

@@ -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) {
+func (g Game) sciencesInternal(ri int) []Science {
-	for r := range g.Race {
+	return g.Race[ri].Sciences
-		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) 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 {
+func (g Game) deleteScienceInternal(ri int, name string) error {
-	for r := range g.Race {
+	sc := slices.IndexFunc(g.Race[ri].Sciences, func(s Science) bool { return s.Name == name })
-		if g.Race[r].ID == race {
+	if sc < 0 {
-			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
-				}
-			}
 		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 sc := slices.IndexFunc(g.Race[ri].Sciences, func(s Science) bool { return s.Name == n }); sc >= 0 {
-		if g.Race[r].ID == race {
+		return e.NewEntityTypeNameDuplicateError("science %w", g.Race[ri].Sciences[sc].Name)
-			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)
 	}
-			}
+	g.Race[ri].Sciences = append(g.Race[ri].Sciences, Science{
-			id := uuid.New()
+		ID: uuid.New(),
-			g.Race[r].Sciences = append(g.Race[r].Sciences, Science{
-				ID: id,
 		ScienceReport: ScienceReport{
 			Name:    n,
 			Drive:   d,
@@ -118,7 +104,4 @@ 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

@@ -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) {
+func (g Game) shipTypesInternal(ri int) []ShipType {
-	for r := range g.Race {
+	return g.Race[ri].ShipTypes
-		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) 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 {
+func (g Game) deleteShipTypeInternal(ri int, name string) error {
-	for r := range g.Race {
+	st := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.Name == name })
-		if g.Race[r].ID == race {
+	if st < 0 {
-			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
-				}
-			}
 		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 st := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.Name == name }); st >= 0 {
-		if g.Race[r].ID == race {
+		return e.NewEntityTypeNameDuplicateError("ship type %w", g.Race[ri].ShipTypes[st].Name)
-			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)
 	}
-			}
+	g.Race[ri].ShipTypes = append(g.Race[ri].ShipTypes, ShipType{
-			id := uuid.New()
+		ID: uuid.New(),
-			g.Race[r].ShipTypes = append(g.Race[r].ShipTypes, ShipType{
-				ID: id,
 		ShipTypeReport: ShipTypeReport{
 			Name:     n,
 			Drive:    d,
@@ -216,9 +195,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 {