galaxy-game/internal/controller/command.go

package controller

import (
	"strings"

	"github.com/google/uuid"
	e "github.com/iliadenisov/galaxy/internal/error"
	"github.com/iliadenisov/galaxy/internal/model/game"
)

func (c Controller) RaceID(actor string) (uuid.UUID, error) {
	ri, err := c.Cache.validRace(actor)
	if err != nil {
		return uuid.Nil, err
	}
	return c.Cache.g.Race[ri].ID, nil
}

func (c Controller) QuitGame(actor string) error {
	ri, err := c.Cache.validRace(actor)
	if err != nil {
		return err
	}
	c.Cache.g.Race[ri].TTL = 3
	return nil
}

func (c Controller) GiveVotes(actor, acceptor string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	rec, err := c.Cache.validRace(acceptor)
	if err != nil {
		return err
	}
	c.Cache.g.Race[ri].VoteFor = c.Cache.g.Race[rec].ID
	return nil
}

func (c Controller) UpdateRelation(actor, acceptor string, rel game.Relation) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	other, err := c.Cache.validRace(acceptor)
	if err != nil {
		return err
	}
	return c.Cache.UpdateRelation(ri, other, rel)
}

func (c *Controller) JoinShipGroupToFleet(actor, fleetName string, group, count uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.JoinShipGroupToFleet(ri, fleetName, group, count)
}

func (c *Controller) JoinFleets(actor, fleetSourceName, fleetTargetName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.JoinFleets(ri, fleetSourceName, fleetTargetName)
}

func (c *Controller) SendFleet(actor, fleetName string, planetNumber uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	fi, ok := c.Cache.fleetIndex(ri, fleetName)
	if !ok {
		return e.NewEntityNotExistsError("fleet %q", fleetName)
	}
	return c.Cache.SendFleet(ri, fi, planetNumber)
}

func (c *Controller) RenamePlanet(actor string, planetNumber int, typeName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.RenamePlanet(ri, planetNumber, typeName)
}

func (c *Controller) PlanetProduction(actor string, planetNumber int, prodType, subject string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	var prod game.ProductionType
	switch game.ProductionType(strings.ToUpper(prodType)) {
	case game.ProductionMaterial:
		prod = game.ProductionMaterial
	case game.ProductionCapital:
		prod = game.ProductionCapital
	case game.ResearchDrive:
		prod = game.ResearchDrive
	case game.ResearchWeapons:
		prod = game.ResearchWeapons
	case game.ResearchShields:
		prod = game.ResearchShields
	case game.ResearchCargo:
		prod = game.ResearchCargo
	case game.ResearchScience:
		prod = game.ResearchScience
	case game.ProductionShip:
		prod = game.ProductionShip
	default:
		return e.NewProductionInvalidError(prodType)
	}
	return c.Cache.PlanetProduction(ri, planetNumber, prod, subject)
}

func (c *Controller) SetRoute(actor, loadType string, origin, destination uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	rt, ok := game.RouteTypeSet[loadType]
	if !ok {
		return e.NewCargoTypeInvalidError(loadType)
	}
	return c.Cache.SetRoute(ri, rt, origin, destination)
}

func (c *Controller) RemoveRoute(actor, loadType string, origin uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	rt, ok := game.RouteTypeSet[loadType]
	if !ok {
		return e.NewCargoTypeInvalidError(loadType)
	}
	return c.Cache.RemoveRoute(ri, rt, origin)
}

func (c *Controller) CreateScience(actor, typeName string, drive, weapons, shields, cargo float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.CreateScience(ri, typeName, drive, weapons, shields, cargo)
}

func (c *Controller) DeleteScience(actor, typeName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.DeleteScience(ri, typeName)
}

func (c *Controller) CreateShipType(actor, typeName string, drive float64, ammo int, weapons, shileds, cargo float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.CreateShipType(ri, typeName, drive, ammo, weapons, shileds, cargo)
}

func (c *Controller) MergeShipType(actor, name, targetName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.MergeShipType(ri, name, targetName)
}

func (c *Controller) DeleteShipType(actor, typeName string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.DeleteShipType(ri, typeName)
}

func (c *Controller) SendGroup(actor string, groupIndex, planetNumber, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.SendGroup(ri, groupIndex, planetNumber, quantity)
}

func (c *Controller) UpgradeGroup(actor string, groupIndex uint, techInput string, limitShips uint, limitLevel float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.UpgradeGroup(ri, groupIndex, techInput, limitShips, limitLevel)
}

func (c *Controller) JoinEqualGroups(actor string) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	c.Cache.JoinEqualGroups(ri)
	return nil
}

func (c *Controller) BreakGroup(actor string, groupIndex, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.BreakGroup(ri, groupIndex, quantity)
}

func (c *Controller) DisassembleGroup(actor string, groupIndex, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.DisassembleGroup(ri, groupIndex, quantity)
}

func (c *Controller) LoadCargo(actor string, groupIndex uint, cargoType string, ships uint, quantity float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	ct, ok := game.CargoTypeSet[cargoType]
	if !ok {
		return e.NewCargoTypeInvalidError(cargoType)
	}
	return c.Cache.LoadCargo(ri, groupIndex, ct, ships, quantity)
}

func (c *Controller) UnloadCargo(actor string, groupIndex uint, ships uint, quantity float64) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	return c.Cache.UnloadCargo(ri, groupIndex, ships, quantity)
}

func (c *Controller) TransferGroup(actor, acceptor string, groupIndex, quantity uint) error {
	ri, err := c.Cache.validActor(actor)
	if err != nil {
		return err
	}
	riAccept, err := c.Cache.validRace(acceptor)
	if err != nil {
		return err
	}
	return c.Cache.TransferGroup(ri, riAccept, groupIndex, quantity)
}