chore: refactor structure

2025-11-21 21:40:15 +03:00
parent 126f381b04
commit 269de2184c
72 changed files with 512 additions and 393 deletions
@@ -0,0 +1,209 @@
+package game
+
+import (
+	"fmt"
+	"slices"
+
+	"github.com/google/uuid"
+	e "github.com/iliadenisov/galaxy/internal/error"
+)
+
+type ShipTypeReport struct {
+	Name     string  `json:"name"`
+	Drive    float64 `json:"drive"`
+	Armament uint    `json:"armament"`
+	Weapons  float64 `json:"weapons"`
+	Shields  float64 `json:"shields"`
+	Cargo    float64 `json:"cargo"`
+}
+
+type ShipType struct {
+	ID uuid.UUID `json:"id"`
+	ShipTypeReport
+}
+
+type ShipTypeReportForeign struct {
+	RaceName string
+	ShipTypeReport
+}
+
+func (st ShipType) Equal(o ShipType) bool {
+	return st.Drive == o.Drive &&
+		st.Weapons == o.Weapons &&
+		st.Armament == o.Armament &&
+		st.Shields == o.Shields &&
+		st.Cargo == o.Cargo
+}
+
+func (st ShipType) EmptyMass() float64 {
+	shipMass := st.Drive + st.Shields + st.Cargo + st.WeaponsMass()
+	return shipMass
+}
+
+func (st ShipType) WeaponsMass() float64 {
+	if st.Armament == 0 || st.Weapons == 0 {
+		return 0
+	}
+	return float64(st.Armament+1) * (st.Weapons / 2)
+}
+
+// ProductionCost returns Material (MAT) and Population (POP) to produce this [ShipType]
+func (st ShipType) ProductionCost() (mat float64, pop float64) {
+	mat = st.EmptyMass()
+	pop = mat * 10
+	return
+}
+
+func (g Game) mustShipType(id uuid.UUID) *ShipType {
+	for ri := range g.Race {
+		if st := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.ID == id }); st >= 0 {
+			return &g.Race[ri].ShipTypes[st]
+		}
+	}
+	panic(fmt.Sprintf("mustShipType: ShipType not found: %v", id))
+}
+
+func (g Game) ShipTypes(raceName string) ([]ShipType, error) {
+	ri, err := g.raceIndex(raceName)
+	if err != nil {
+		return nil, err
+	}
+	return g.shipTypesInternal(ri), nil
+}
+
+func (g Game) shipTypesInternal(ri int) []ShipType {
+	return g.Race[ri].ShipTypes
+}
+
+func (g Game) DeleteShipType(raceName, typeName string) error {
+	ri, err := g.raceIndex(raceName)
+	if err != nil {
+		return err
+	}
+	return g.deleteShipTypeInternal(ri, typeName)
+}
+
+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)
+	}
+	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 {
+	ri, err := g.raceIndex(raceName)
+	if err != nil {
+		return err
+	}
+	return g.createShipTypeInternal(ri, typeName, d, w, s, c, a)
+}
+
+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
+	}
+	n, ok := validateTypeName(name)
+	if !ok {
+		return e.NewEntityTypeNameValidationError("%q", n)
+	}
+	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)
+	}
+	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 (g Game) MergeShipType(race, name, targetName string) error {
+	ri, err := g.raceIndex(race)
+	if err != nil {
+		return err
+	}
+	return g.mergeShipTypeInternal(ri, name, targetName)
+}
+
+func (g Game) mergeShipTypeInternal(ri int, name, targetName string) error {
+	st := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.Name == name })
+	if st < 0 {
+		return e.NewEntityNotExistsError("source ship type %w", name)
+	}
+	if name == targetName {
+		return e.NewEntityTypeNameEqualityError("ship type %q", targetName)
+	}
+	tt := slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.Name == targetName })
+	if tt < 0 {
+		return e.NewEntityNotExistsError("target ship type %w", name)
+	}
+	if !g.Race[ri].ShipTypes[st].Equal(g.Race[ri].ShipTypes[tt]) {
+		return e.NewMergeShipTypeNotEqualError()
+	}
+
+	// switch planet productions to the new type
+	for pl := range g.Map.Planet {
+		if g.Map.Planet[pl].Owner == g.Race[ri].ID &&
+			g.Map.Planet[pl].Production.Production == ProductionShip &&
+			g.Map.Planet[pl].Production.SubjectID != nil &&
+			*g.Map.Planet[pl].Production.SubjectID == g.Race[ri].ShipTypes[st].ID {
+			g.Map.Planet[pl].Production.SubjectID = &g.Race[ri].ShipTypes[tt].ID
+		}
+	}
+
+	// switch ship groups to the new type
+	for sg := range g.ShipGroups {
+		if g.ShipGroups[sg].OwnerID == g.Race[ri].ID && g.ShipGroups[sg].TypeID == g.Race[ri].ShipTypes[st].ID {
+			g.ShipGroups[sg].TypeID = g.Race[ri].ShipTypes[tt].ID
+		}
+	}
+
+	// remove the source type
+	g.Race[ri].ShipTypes = append(g.Race[ri].ShipTypes[:st], g.Race[ri].ShipTypes[st+1:]...)
+
+	return nil
+}
+
+func checkShipTypeValues(d, w, s, c float64, a int) error {
+	if !checkShipTypeValueDWSC(d) {
+		return e.NewDriveValueError(d)
+	}
+	if !checkShipTypeValueDWSC(w) {
+		return e.NewWeaponsValueError(w)
+	}
+	if !checkShipTypeValueDWSC(s) {
+		return e.NewShieldsValueError(s)
+	}
+	if !checkShipTypeValueDWSC(c) {
+		return e.NewCargoValueError(s)
+	}
+	if a < 0 {
+		return e.NewShipTypeArmamentValueError(a)
+	}
+	if (w == 0 && a > 0) || (a == 0 && w > 0) {
+		return e.NewShipTypeArmamentAndWeaponsValueError("A=%d W=%.0f", a, w)
+	}
+	if d == 0 && w == 0 && s == 0 && c == 0 && a == 0 {
+		return e.NewShipTypeShipTypeZeroValuesError()
+	}
+	return nil
+}
+
+func checkShipTypeValueDWSC(v float64) bool {
+	return v == 0 || v >= 1
+}