Ilia Denisov
128 lines
2.9 KiB
Go
128 lines
2.9 KiB
Go
package game
|
|
|
|
import (
|
|
"iter"
|
|
"math"
|
|
"slices"
|
|
|
|
"github.com/google/uuid"
|
|
e "github.com/iliadenisov/galaxy/internal/error"
|
|
)
|
|
|
|
type Fleet struct {
|
|
ID uuid.UUID `json:"id"`
|
|
OwnerID uuid.UUID `json:"ownerId"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
// TODO: Hello! Wanna know fleet's speed? Good. Implement & test this func first.
|
|
func (g Game) FleetSpeed(fl Fleet) float64 {
|
|
result := math.MaxFloat64
|
|
for sg := range g.ShipGroups {
|
|
if g.ShipGroups[sg].FleetID == nil || *g.ShipGroups[sg].FleetID != fl.ID {
|
|
continue
|
|
}
|
|
st := g.mustShipType(g.ShipGroups[sg].TypeID)
|
|
typeSpeed := g.ShipGroups[sg].Speed(st)
|
|
if typeSpeed < result {
|
|
result = typeSpeed
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (g *Game) JoinShipGroupToFleet(raceName, fleetName string, group, count uint) error {
|
|
ri, err := g.raceIndex(raceName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return g.joinShipGroupToFleetInternal(ri, fleetName, group, count)
|
|
}
|
|
|
|
func (g *Game) joinShipGroupToFleetInternal(ri int, fleetName string, group, count uint) (err error) {
|
|
name, ok := validateTypeName(fleetName)
|
|
if !ok {
|
|
return e.NewEntityTypeNameValidationError("%q", name)
|
|
}
|
|
sgi := -1
|
|
var maxIndex uint
|
|
for i, sg := range g.listIndexShipGroups(ri) {
|
|
if sgi < 0 && sg.Index == group {
|
|
sgi = i
|
|
}
|
|
if sg.Index > maxIndex {
|
|
maxIndex = sg.Index
|
|
}
|
|
}
|
|
if sgi < 0 {
|
|
return e.NewEntityNotExistsError("group #%d", group)
|
|
}
|
|
|
|
if g.ShipGroups[sgi].Number < count {
|
|
return e.NewJoinFleetGroupNumberNotEnoughError("%d<%d", g.ShipGroups[sgi].Number, count)
|
|
}
|
|
|
|
fi := g.fleetIndex(ri, name)
|
|
if fi < 0 {
|
|
fi, err = g.createFleet(ri, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if count > 0 &&
|
|
g.ShipGroups[sgi].Number != count {
|
|
|
|
newGroup := g.ShipGroups[sgi]
|
|
newGroup.Number -= count
|
|
g.ShipGroups[sgi].Number = count
|
|
newGroup.Index = maxIndex + 1
|
|
g.ShipGroups = append(g.ShipGroups, newGroup)
|
|
}
|
|
|
|
g.ShipGroups[sgi].FleetID = &g.Fleets[fi].ID
|
|
return nil
|
|
}
|
|
|
|
func (g Game) fleetIndex(ri int, name string) int {
|
|
return slices.IndexFunc(g.Fleets, func(f Fleet) bool { return f.OwnerID == g.Race[ri].ID && f.Name == name })
|
|
}
|
|
|
|
func (g *Game) createFleet(ri int, name string) (int, error) {
|
|
n, ok := validateTypeName(name)
|
|
if !ok {
|
|
return 0, e.NewEntityTypeNameValidationError("%q", n)
|
|
}
|
|
if fl := g.fleetIndex(ri, n); fl >= 0 {
|
|
return 0, e.NewEntityTypeNameDuplicateError("fleet %w", g.Fleets[fl].Name)
|
|
}
|
|
g.Fleets = append(g.Fleets, Fleet{
|
|
ID: uuid.New(),
|
|
OwnerID: g.Race[ri].ID,
|
|
Name: n,
|
|
})
|
|
return len(g.Fleets) - 1, nil
|
|
}
|
|
|
|
func (g Game) listFleets(ri int) iter.Seq[Fleet] {
|
|
return func(yield func(Fleet) bool) {
|
|
for _, fl := range g.listIndexFleets(ri) {
|
|
if !yield(fl) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (g Game) listIndexFleets(ri int) iter.Seq2[int, Fleet] {
|
|
return func(yield func(int, Fleet) bool) {
|
|
for i := range g.Fleets {
|
|
if g.Fleets[i].OwnerID == g.Race[ri].ID {
|
|
if !yield(i, g.Fleets[i]) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|