Ilia Denisov
249 lines
7.9 KiB
Go
249 lines
7.9 KiB
Go
package game
|
|
|
|
import "github.com/google/uuid"
|
|
|
|
// import (
|
|
// "fmt"
|
|
// "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"`
|
|
}
|
|
|
|
// func FleetState(g *Game, fleetID uuid.UUID) (ShipGroupState, *uint, *InSpace) {
|
|
// fi := slices.IndexFunc(g.Fleets, func(f Fleet) bool { return f.ID == fleetID })
|
|
// if fi < 0 {
|
|
// panic("FleetState: fleet id not found: " + fleetID.String())
|
|
// }
|
|
// ri := slices.IndexFunc(g.Race, func(r Race) bool { return r.ID == g.Fleets[fi].OwnerID })
|
|
// if ri < 0 {
|
|
// panic("FleetState: race id not found: " + g.Fleets[fi].OwnerID.String())
|
|
// }
|
|
// var state *ShipGroupState
|
|
// var onPlanet *uint
|
|
// var is *InSpace
|
|
// for sg := range FleetGroups(g, ri, fi) {
|
|
// if state == nil {
|
|
// s := sg.State()
|
|
// state = &s
|
|
// if planet, ok := sg.OnPlanet(); ok {
|
|
// onPlanet = &planet
|
|
// }
|
|
// is = sg.StateInSpace
|
|
// continue
|
|
// }
|
|
// if *state != sg.State() {
|
|
// panic(fmt.Sprintf("FleetState: one or more ships in race's %q fleet %q has different states", g.Race[ri].Name, g.Fleets[fi].Name))
|
|
// }
|
|
// if planet, ok := sg.OnPlanet(); ok && onPlanet != nil && *onPlanet != planet {
|
|
// for sg := range FleetGroups(g, ri, fi) {
|
|
// fmt.Println("group", sg.Index, "fleet", sg.FleetID, g.Fleets[fi].Name, "state", sg.State(), "on", sg.Destination)
|
|
// }
|
|
// panic(fmt.Sprintf("FleetState: one or more ships in race's %q fleet %q are on different planets: %d <> %d", g.Race[ri].Name, g.Fleets[fi].Name, *onPlanet, planet))
|
|
// }
|
|
// if (is == nil && sg.StateInSpace != nil) || (is != nil && sg.StateInSpace == nil) {
|
|
// panic(fmt.Sprintf("FleetState: one or more ships in race's %q fleet %q on_planet and in_space at the same time", g.Race[ri].Name, g.Fleets[fi].Name))
|
|
// }
|
|
// if is != nil && sg.StateInSpace != nil && !is.Equal(*sg.StateInSpace) {
|
|
// panic(fmt.Sprintf("FleetState: one or more ships in race's %q fleet %q has different is_space states", g.Race[ri].Name, g.Fleets[fi].Name))
|
|
// }
|
|
// }
|
|
// if state == nil {
|
|
// panic(fmt.Sprintf("FleetState: race's %q fleet %q has no ships", g.Race[ri].Name, g.Fleets[fi].Name))
|
|
// }
|
|
// return *state, onPlanet, is
|
|
// }
|
|
|
|
// // 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) JoinFleets(raceName, fleetSourceName, fleetTargetName string) error {
|
|
// ri, err := g.raceIndex(raceName)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// return g.joinFleetsInternal(ri, fleetSourceName, fleetTargetName)
|
|
// }
|
|
|
|
// func (g *Game) joinShipGroupToFleetInternal(ri int, fleetName string, groupIndex, quantity 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 == groupIndex {
|
|
// sgi = i
|
|
// }
|
|
// if sg.Index > maxIndex {
|
|
// maxIndex = sg.Index
|
|
// }
|
|
// }
|
|
// if sgi < 0 {
|
|
// return e.NewEntityNotExistsError("group #%d", groupIndex)
|
|
// }
|
|
|
|
// if g.ShipGroups[sgi].State() != StateInOrbit {
|
|
// return e.NewShipsBusyError()
|
|
// }
|
|
|
|
// if g.ShipGroups[sgi].Number < quantity {
|
|
// return e.NewJoinFleetGroupNumberNotEnoughError("%d<%d", g.ShipGroups[sgi].Number, quantity)
|
|
// }
|
|
|
|
// fi := g.fleetIndex(ri, name)
|
|
// if fi < 0 {
|
|
// fi, err = g.createFleet(ri, name)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// } else {
|
|
// state, onPlanet, _ := FleetState(g, g.Fleets[fi].ID)
|
|
// if state != StateInOrbit || *onPlanet != g.ShipGroups[sgi].Destination {
|
|
// return e.NewShipsNotOnSamePlanetError("fleet: %s", fleetName)
|
|
// }
|
|
// }
|
|
|
|
// // FIXME: if g.ShipGroups[sgi].FleetID != nil { // delete old fleet if empty, ALSO mind breaking group }
|
|
// if quantity > 0 && quantity < g.ShipGroups[sgi].Number {
|
|
// // nsgi, err := g.breakGroupSafe(ri, groupIndex, quantity)
|
|
// // if err != nil {
|
|
// // return err
|
|
// // }
|
|
// // sgi = nsgi
|
|
// newGroup := g.ShipGroups[sgi]
|
|
// newGroup.Number -= quantity
|
|
// g.ShipGroups[sgi].Number = quantity
|
|
// newGroup.Index = maxIndex + 1
|
|
// g.ShipGroups = append(g.ShipGroups, newGroup)
|
|
// }
|
|
|
|
// g.ShipGroups[sgi].FleetID = &g.Fleets[fi].ID
|
|
// return nil
|
|
// }
|
|
|
|
// 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)
|
|
// }
|
|
// fleets := slices.Clone(g.Fleets)
|
|
// fleets = append(fleets, Fleet{
|
|
// ID: uuid.New(),
|
|
// OwnerID: g.Race[ri].ID,
|
|
// Name: n,
|
|
// })
|
|
// g.Fleets = fleets
|
|
// return len(g.Fleets) - 1, nil
|
|
// }
|
|
|
|
// func (g *Game) joinFleetsInternal(ri int, fleetSourceName, fleetTargetName string) (err error) {
|
|
// fiSource := g.fleetIndex(ri, fleetSourceName)
|
|
// if fiSource < 0 {
|
|
// return e.NewEntityNotExistsError("source fleet %s", fleetSourceName)
|
|
// }
|
|
// fiTarget := g.fleetIndex(ri, fleetTargetName)
|
|
// if fiTarget < 0 {
|
|
// return e.NewEntityNotExistsError("target fleet %s", fleetTargetName)
|
|
// }
|
|
// srcState, planet1, _ := FleetState(g, g.Fleets[fiSource].ID)
|
|
// tgtState, planet2, _ := FleetState(g, g.Fleets[fiTarget].ID)
|
|
// if srcState != StateInOrbit || srcState != tgtState || *planet1 != *planet2 {
|
|
// return e.NewShipsNotOnSamePlanetError()
|
|
// }
|
|
// for sgi, sg := range g.listIndexShipGroups(ri) {
|
|
// if sg.FleetID != nil && *sg.FleetID == g.Fleets[fiSource].ID {
|
|
// g.ShipGroups[sgi].FleetID = &g.Fleets[fiTarget].ID
|
|
// }
|
|
// }
|
|
// return g.deleteFleetSafe(ri, fleetSourceName)
|
|
// }
|
|
|
|
// func (g *Game) deleteFleetSafe(ri int, name string) error {
|
|
// fi := g.fleetIndex(ri, name)
|
|
// if fi < 0 {
|
|
// return e.NewEntityNotExistsError("fleet %s", name)
|
|
// }
|
|
// for sgi := range g.ShipGroups {
|
|
// if g.ShipGroups[sgi].FleetID != nil && *g.ShipGroups[sgi].FleetID == g.Fleets[fi].ID {
|
|
// return e.NewEntityInUseError("fleet %s: race %s, group #%d", name, g.Race[ri].Name, g.ShipGroups[sgi].Number)
|
|
// }
|
|
// }
|
|
// g.Fleets = append(g.Fleets[:fi], g.Fleets[fi+1:]...)
|
|
// 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) 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
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// func FleetGroups(g *Game, ri, fi int) iter.Seq[ShipGroup] {
|
|
// if len(g.Fleets) < fi+1 {
|
|
// panic(fmt.Sprintf("FleetGroups: game fleets index %d invalid: len=%d", fi, len(g.Fleets)))
|
|
// }
|
|
// return func(yield func(ShipGroup) bool) {
|
|
// for sg := range g.listShipGroups(ri) {
|
|
// if sg.FleetID != nil && *sg.FleetID == g.Fleets[fi].ID {
|
|
// if !yield(sg) {
|
|
// break
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|