cmd: giveaway group

internal/error/generic.go

@@ -19,10 +19,12 @@ const (
 	ErrEntityInUse                    = 5006
 	ErrShipsBusy                      = 5007
 	ErrShipsNotOnSamePlanet           = 5008
+	ErrGiveawayGroupShipsTypeNotEqual = 5009
 )
 
 const (
 	ErrInputUnknownRace int = 3000 + iota
+	ErrInputSameRace
 	ErrInputEntityTypeNameInvalid
 	ErrInputEntityTypeNameDuplicate
 	ErrInputEntityTypeNameEquality
@@ -50,6 +52,8 @@ func GenericErrorText(code int) string {
 		return "Invalid game state"
 	case ErrInputUnknownRace:
 		return "Race name is unknown to this game"
+	case ErrInputSameRace:
+		return "Race name must be different from your own"
 	case ErrInputEntityTypeNameInvalid:
 		return "Name has invalid length or symbols"
 	case ErrInputEntityTypeNameDuplicate:
@@ -98,6 +102,8 @@ func GenericErrorText(code int) string {
 		return "Ships currently not in orbit or free to use"
 	case ErrShipsNotOnSamePlanet:
 		return "Ships not on the same planet"
+	case ErrGiveawayGroupShipsTypeNotEqual:
+		return "Ship type already defined with different specifications"
 	default:
 		return fmt.Sprintf("Undescribed error with code %d", code)
 	}

internal/error/input.go

@@ -3,6 +3,10 @@ package error
 func NewRaceUnknownError(arg ...any) error {
 	return newGenericError(ErrInputUnknownRace, arg...)
 }
+func NewInputSameRaceError(arg ...any) error {
+	// TODO: check all possible commands
+	return newGenericError(ErrInputSameRace, arg...)
+}
 
 func NewEntityTypeNameValidationError(arg ...any) error {
 	return newGenericError(ErrInputEntityTypeNameInvalid, arg...)
@@ -87,3 +91,7 @@ func NewShipsBusyError(arg ...any) error {
 func NewShipsNotOnSamePlanetError(arg ...any) error {
 	return newGenericError(ErrShipsNotOnSamePlanet, arg...)
 }
+
+func NewGiveawayGroupShipsTypeNotEqualError(arg ...any) error {
+	return newGenericError(ErrGiveawayGroupShipsTypeNotEqual, arg...)
+}

internal/model/game/game_test.go

@@ -51,14 +51,18 @@ var (
 	Race_1_Gunship        = "R1_Gunship"
 	Race_1_Freighter      = "R1_Freighter"
 	R1_Planet_1_num  uint = 1
+
+	ShipType_Cruiser = "Cruiser"
 )
 
 func init() {
 	assertNoError(Game.CreateShipType(Race_0.Name, Race_0_Gunship, 60, 30, 100, 0, 3))
 	assertNoError(Game.CreateShipType(Race_0.Name, Race_0_Freighter, 8, 0, 2, 10, 0))
+	assertNoError(Game.CreateShipType(Race_0.Name, ShipType_Cruiser, 15, 15, 15, 0, 1))
 
 	assertNoError(Game.CreateShipType(Race_1.Name, Race_1_Gunship, 60, 30, 100, 0, 3))
 	assertNoError(Game.CreateShipType(Race_1.Name, Race_1_Freighter, 8, 0, 2, 10, 0))
+	assertNoError(Game.CreateShipType(Race_1.Name, ShipType_Cruiser, 15, 15, 15, 0, 2)) // same name - different type
 }
 
 func assertNoError(err error) {

internal/model/game/group.go

@@ -20,8 +20,12 @@ const (
 	CargoCapital  CargoType = "CAP" // Промышленность
 )
 
+func (ct CargoType) Ref() *CargoType {
+	return &ct
+}
+
 type ShipGroup struct {
-	Index   uint       `json:"index"`             // Group index (ordered)
+	Index   uint       `json:"index"`             // FIXME: use UUID for Group Index (ordered)
 	OwnerID uuid.UUID  `json:"ownerId"`           // Race link
 	TypeID  uuid.UUID  `json:"typeId"`            // ShipType link
 	FleetID *uuid.UUID `json:"fleetId,omitempty"` // Fleet link
@@ -130,6 +134,95 @@ func (g *Game) BreakGroup(raceName string, groupIndex, quantity uint) error {
 	return g.breakGroupInternal(ri, groupIndex, quantity)
 }
 
+func (g *Game) GiveawayGroup(raceName, raceAcceptor string, groupIndex, quantity uint) error {
+	ri, err := g.raceIndex(raceName)
+	if err != nil {
+		return err
+	}
+	riAccept, err := g.raceIndex(raceAcceptor)
+	if err != nil {
+		return err
+	}
+	return g.giveawayGroupInternal(ri, riAccept, groupIndex, quantity)
+}
+
+func (g *Game) giveawayGroupInternal(ri, riAccept int, groupIndex, quantity uint) (err error) {
+	if ri == riAccept {
+		return e.NewInputSameRaceError(g.Race[riAccept].Name)
+	}
+	sgi := -1
+	for i, sg := range g.listIndexShipGroups(ri) {
+		if sgi < 0 && sg.Index == groupIndex {
+			sgi = i
+		}
+	}
+	if sgi < 0 {
+		return e.NewEntityNotExistsError("group #%d", groupIndex)
+	}
+	if g.ShipGroups[sgi].Number < quantity {
+		return e.NewBeakGroupNumberNotEnoughError("%d<%d", g.ShipGroups[sgi].Number, quantity)
+	}
+
+	var sti int
+	if sti = slices.IndexFunc(g.Race[ri].ShipTypes, func(st ShipType) bool { return st.ID == g.ShipGroups[sgi].TypeID }); sti < 0 {
+		// hard to test, need manual game data invalidation
+		return e.NewGameStateError("not found: ShipType ID=%v", g.ShipGroups[sgi].TypeID)
+	}
+
+	var stAcc int
+	if stAcc = slices.IndexFunc(g.Race[riAccept].ShipTypes, func(st ShipType) bool { return st.Name == g.Race[ri].ShipTypes[sti].Name }); stAcc >= 0 &&
+		!g.Race[ri].ShipTypes[sti].Equal(g.Race[riAccept].ShipTypes[stAcc]) {
+		return e.NewGiveawayGroupShipsTypeNotEqualError("race %w, ship type %w", g.Race[riAccept].Name, g.Race[riAccept].ShipTypes[stAcc].Name)
+	}
+	if stAcc < 0 {
+		stAcc, err = g.createShipTypeInternal(riAccept,
+			g.Race[ri].ShipTypes[sti].Name,
+			g.Race[ri].ShipTypes[sti].Drive,
+			g.Race[ri].ShipTypes[sti].Weapons,
+			g.Race[ri].ShipTypes[sti].Shields,
+			g.Race[ri].ShipTypes[sti].Cargo,
+			int(g.Race[ri].ShipTypes[sti].Armament))
+		if err != nil {
+			return err
+		}
+	}
+
+	var maxIndex uint
+	for sg := range g.listShipGroups(riAccept) {
+		if sg.Index > maxIndex {
+			maxIndex = sg.Index
+		}
+	}
+
+	g.ShipGroups = append(g.ShipGroups, ShipGroup{
+		Index:   maxIndex + 1,
+		OwnerID: g.Race[riAccept].ID,
+		TypeID:  g.Race[riAccept].ShipTypes[stAcc].ID,
+		Number:  uint(quantity),
+		State:   g.ShipGroups[sgi].State,
+
+		CargoType: g.ShipGroups[sgi].CargoType,
+		Load:      g.ShipGroups[sgi].Load,
+
+		Drive:   g.ShipGroups[sgi].Drive,
+		Weapons: g.ShipGroups[sgi].Weapons,
+		Shields: g.ShipGroups[sgi].Shields,
+		Cargo:   g.ShipGroups[sgi].Cargo,
+
+		Destination: g.ShipGroups[sgi].Destination,
+		Origin:      g.ShipGroups[sgi].Origin,
+		Range:       g.ShipGroups[sgi].Range,
+	})
+
+	if quantity == 0 || quantity == g.ShipGroups[sgi].Number {
+		g.ShipGroups = append(g.ShipGroups[:sgi], g.ShipGroups[sgi+1:]...)
+	} else {
+		g.ShipGroups[sgi].Number -= quantity
+	}
+
+	return nil
+}
+
 func (g *Game) breakGroupInternal(ri int, groupIndex, quantity uint) error {
 	sgi := -1
 	var maxIndex uint

internal/model/game/group_test.go

@@ -404,3 +404,71 @@ func TestBreakGroup(t *testing.T) {
 	assert.Equal(t, uint(2), g.ShipGroups[3].Number)
 	assert.Nil(t, g.ShipGroups[3].FleetID)
 }
+
+func TestGiveawayGroup(t *testing.T) {
+	g := copyGame()
+	assert.NoError(t, g.CreateShips(Race_0_idx, ShipType_Cruiser, R0_Planet_0_num, 11)) // group #1 (0)
+	assert.NoError(t, g.CreateShips(Race_1_idx, ShipType_Cruiser, R1_Planet_1_num, 23)) // group #1 (1)
+
+	assert.NoError(t, g.CreateShips(Race_0_idx, Race_0_Gunship, R0_Planet_0_num, 17)) // group #2 (2) - In_Space
+	assert.NoError(t, g.JoinShipGroupToFleet(Race_0.Name, "R0_Fleet", 2, 0))
+	assert.NotNil(t, g.ShipGroups[2].FleetID)
+	g.ShipGroups[2].Origin = &R0_Planet_2_num
+	rng := 31.337
+	g.ShipGroups[2].Range = &rng
+	g.ShipGroups[2].State = "In_Space"
+	g.ShipGroups[2].CargoType = game.CargoMaterial.Ref()
+	g.ShipGroups[2].Load = 1.234
+
+	assert.Len(t, slices.Collect(g.ListShipGroups(Race_0_idx)), 2)
+	assert.Len(t, slices.Collect(g.ListShipGroups(Race_1_idx)), 1)
+
+	assert.ErrorContains(t,
+		g.GiveawayGroup("UnknownRace", Race_1.Name, 2, 0),
+		e.GenericErrorText(e.ErrInputUnknownRace))
+	assert.ErrorContains(t,
+		g.GiveawayGroup(Race_0.Name, "UnknownRace", 2, 0),
+		e.GenericErrorText(e.ErrInputUnknownRace))
+	assert.ErrorContains(t,
+		g.GiveawayGroup(Race_0.Name, Race_0.Name, 2, 0),
+		e.GenericErrorText(e.ErrInputSameRace))
+	assert.ErrorContains(t,
+		g.GiveawayGroup(Race_0.Name, Race_1.Name, 555, 0),
+		e.GenericErrorText(e.ErrInputEntityNotExists))
+	assert.ErrorContains(t,
+		g.GiveawayGroup(Race_0.Name, Race_1.Name, 2, 18),
+		e.GenericErrorText(e.ErrBeakGroupNumberNotEnough))
+	assert.ErrorContains(t,
+		g.GiveawayGroup(Race_0.Name, Race_1.Name, 1, 0),
+		e.GenericErrorText(e.ErrGiveawayGroupShipsTypeNotEqual))
+
+	assert.NoError(t, g.GiveawayGroup(Race_0.Name, Race_1.Name, 2, 11)) // group #2 (3)
+	assert.Len(t, slices.Collect(g.ListShipGroups(Race_0_idx)), 2)
+	assert.Len(t, slices.Collect(g.ListShipGroups(Race_1_idx)), 2)
+	sto := slices.IndexFunc(g.Race[Race_0_idx].ShipTypes, func(st game.ShipType) bool { return st.Name == Race_0_Gunship })
+	sti := slices.IndexFunc(g.Race[Race_1_idx].ShipTypes, func(st game.ShipType) bool { return st.Name == Race_0_Gunship })
+	assert.Equal(t, g.Race[Race_1_idx].ShipTypes[sti].Name, g.Race[Race_0_idx].ShipTypes[sto].Name)
+	assert.Equal(t, g.Race[Race_1_idx].ShipTypes[sti].Drive, g.Race[Race_0_idx].ShipTypes[sto].Drive)
+	assert.Equal(t, g.Race[Race_1_idx].ShipTypes[sti].Weapons, g.Race[Race_0_idx].ShipTypes[sto].Weapons)
+	assert.Equal(t, g.Race[Race_1_idx].ShipTypes[sti].Shields, g.Race[Race_0_idx].ShipTypes[sto].Shields)
+	assert.Equal(t, g.Race[Race_1_idx].ShipTypes[sti].Cargo, g.Race[Race_0_idx].ShipTypes[sto].Cargo)
+	assert.Equal(t, g.Race[Race_1_idx].ShipTypes[sti].Armament, g.Race[Race_0_idx].ShipTypes[sto].Armament)
+	assert.Equal(t, g.ShipGroups[2].State, g.ShipGroups[3].State)
+	assert.Equal(t, g.ShipGroups[2].CargoType, g.ShipGroups[3].CargoType)
+	assert.Equal(t, g.ShipGroups[2].Load, g.ShipGroups[3].Load)
+	assert.Equal(t, g.ShipGroups[2].Drive, g.ShipGroups[3].Drive)
+	assert.Equal(t, g.ShipGroups[2].Weapons, g.ShipGroups[3].Weapons)
+	assert.Equal(t, g.ShipGroups[2].Shields, g.ShipGroups[3].Shields)
+	assert.Equal(t, g.ShipGroups[2].Cargo, g.ShipGroups[3].Cargo)
+	assert.Equal(t, g.ShipGroups[2].Destination, g.ShipGroups[3].Destination)
+	assert.Equal(t, g.ShipGroups[2].Origin, g.ShipGroups[3].Origin)
+	assert.Equal(t, g.ShipGroups[2].Range, g.ShipGroups[3].Range)
+	assert.Equal(t, g.ShipGroups[3].OwnerID, g.Race[Race_1_idx].ID)
+	assert.Equal(t, g.ShipGroups[3].TypeID, g.Race[Race_1_idx].ShipTypes[sti].ID)
+	assert.Equal(t, g.ShipGroups[3].Number, uint(11))
+	assert.Nil(t, g.ShipGroups[3].FleetID)
+
+	assert.NoError(t, g.GiveawayGroup(Race_1.Name, Race_0.Name, 2, 11))
+	assert.Len(t, slices.Collect(g.ListShipGroups(Race_0_idx)), 3)
+	assert.Len(t, slices.Collect(g.ListShipGroups(Race_1_idx)), 1)
+}

internal/model/game/ship.go

@@ -104,19 +104,20 @@ func (g Game) CreateShipType(raceName, typeName string, d, w, s, c float64, a in
 	if err != nil {
 		return err
 	}
-	return g.createShipTypeInternal(ri, typeName, d, w, s, c, a)
+	_, err = g.createShipTypeInternal(ri, typeName, d, w, s, c, a)
+	return err
 }
 
-func (g Game) createShipTypeInternal(ri int, 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) (int, error) {
 	if err := checkShipTypeValues(d, w, s, c, a); err != nil {
-		return err
+		return -1, err
 	}
 	n, ok := validateTypeName(name)
 	if !ok {
-		return e.NewEntityTypeNameValidationError("%q", n)
+		return -1, 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)
+		return -1, e.NewEntityTypeNameDuplicateError("ship type %w", g.Race[ri].ShipTypes[st].Name)
 	}
 	g.Race[ri].ShipTypes = append(g.Race[ri].ShipTypes, ShipType{
 		ID: uuid.New(),
@@ -129,7 +130,7 @@ func (g Game) createShipTypeInternal(ri int, name string, d, w, s, c float64, a
 			Armament: uint(a),
 		},
 	})
-	return nil
+	return len(g.Race[ri].ShipTypes) - 1, nil
 }
 
 func (g Game) MergeShipType(race, name, targetName string) error {