refactor: race index by name

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) {
-	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 {
-				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
-					return nil
-				}
-			}
-			if hostID != opponentID {
-				return e.NewGameStateError("UpdateRelation: opponent not found")
-			}
+func (g Game) updateRelationInternal(ri, other int, rel Relation) error {
+	for o := range g.Race[ri].Relations {
+		switch {
+		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 {
-		return e.NewGameStateError("UpdateRelation: host %v not found", hostID)
+	if ri != other {
+		return e.NewGameStateError("UpdateRelation: opponent not found")
 	}
 	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
-				}
-			}
-			return RaceRelation{}, e.NewGameStateError("Relation: opponent not found")
-		}
+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

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

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) {
-	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
-				}
-			}
-			return e.NewEntityNotExistsError("science %w", name)
-		}
+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)
 	}
-	return e.NewGameStateError("DeleteScience: race %v not found", race)
+	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)
+	}
+	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,26 +90,18 @@ 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)
-				}
-			}
-			id := uuid.New()
-			g.Race[r].Sciences = append(g.Race[r].Sciences, Science{
-				ID: id,
-				ScienceReport: ScienceReport{
-					Name:    n,
-					Drive:   d,
-					Weapons: w,
-					Shields: s,
-					Cargo:   c,
-				},
-			})
-			return nil
-		}
+	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)
 	}
-	return e.NewGameStateError("CreateScience: race %v not found", race)
+	g.Race[ri].Sciences = append(g.Race[ri].Sciences, Science{
+		ID: uuid.New(),
+		ScienceReport: ScienceReport{
+			Name:    n,
+			Drive:   d,
+			Weapons: w,
+			Shields: s,
+			Cargo:   c,
+		},
+	})
+	return nil
 }

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) {
-	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
-				}
-			}
-			return e.NewEntityNotExistsError("ship type %w", name)
-		}
+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)
 	}
-	return e.NewGameStateError("DeleteShipType: race %v not found", race)
+	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)
+	}
+	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,29 +180,21 @@ 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)
-				}
-			}
-			id := uuid.New()
-			g.Race[r].ShipTypes = append(g.Race[r].ShipTypes, ShipType{
-				ID: id,
-				ShipTypeReport: ShipTypeReport{
-					Name:     n,
-					Drive:    d,
-					Weapons:  w,
-					Shields:  s,
-					Cargo:    c,
-					Armament: uint(a),
-				},
-			})
-			return nil
-		}
+	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)
 	}
-	return e.NewGameStateError("CreateShipType: race %v not found", race)
+	g.Race[ri].ShipTypes = append(g.Race[ri].ShipTypes, ShipType{
+		ID: uuid.New(),
+		ShipTypeReport: ShipTypeReport{
+			Name:     n,
+			Drive:    d,
+			Weapons:  w,
+			Shields:  s,
+			Cargo:    c,
+			Armament: uint(a),
+		},
+	})
+	return nil
 }
 
 func checkShipTypeValues(d, w, s, c float64, a int) error {