bl/logic/controller/pet_fusion.go

package controller

import (
	"blazing/common/data/xmlres"
	"blazing/common/socket/errorcode"
	"blazing/logic/service/pet"
	"blazing/logic/service/player"
	"blazing/modules/config/service"
	"blazing/modules/player/model"

	"github.com/alpacahq/alpacadecimal"
	"github.com/gogf/gf/v2/util/grand"
)

const (
	petFusionCost          = 1000
	petFusionKeepAuxItemID = 300043
	petFusionFailureItemID = 300044
	petFusionSoulID        = 1000017
)

func (h Controller) PetFusion(data *C2S_PetFusion, c *player.Player) (result *pet.PetFusionInfo, err errorcode.ErrorCode) {
	result = &pet.PetFusionInfo{
		SoulID: petFusionSoulID,
	}

	if data.Mcatchtime == data.Auxcatchtime {
		return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady
	}

	_, masterPet, ok := c.FindPet(data.Mcatchtime)
	if !ok {
		return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady2
	}
	masterCfg, ok := xmlres.PetMAP[int(masterPet.ID)]
	if !ok || masterCfg.FuseMaster == 0 {
		return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady3
	}

	_, auxPet, ok := c.FindPet(data.Auxcatchtime)
	if !ok {
		return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady2
	}
	auxCfg, ok := xmlres.PetMAP[int(auxPet.ID)]
	if !ok || auxCfg.FuseSub == 0 {
		return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady3
	}

	materialCounts := collectItemCounts(data.Item1[:])
	if !hasEnoughItems(c, materialCounts) {
		return result, errorcode.ErrorCodes.ErrInsufficientItems
	}

	materialService := service.NewPetFusionMaterialService()
	effect := int(materialService.Data(data.Item1))
	if effect == 0 {
		return result, errorcode.ErrorCodes.ErrSpiritOrbNotExists
	}

	fusionService := service.NewPetFusionService()
	resultPetID := int(fusionService.Data(masterPet.ID, auxPet.ID, masterPet.Level+auxPet.Level))

	if !c.GetCoins(petFusionCost) {
		return result, errorcode.ErrorCodes.ErrSunDouInsufficient10016
	}

	consumeItems(c, materialCounts)
	c.Info.Coins -= petFusionCost

	if resultPetID == 0 {
		if useOptionalItem(c, data.GoldItem1[:], petFusionFailureItemID) {
			result.CostItemFlag = 1
		} else if auxPet.Level > 5 {
			auxPet.Downgrade(auxPet.Level - 5)
		} else {
			auxPet.Downgrade(1)
		}
		return &pet.PetFusionInfo{}, 0
	}

	natureID := int32(-1)
	if auxPet.Nature == masterPet.Nature {
		natureID = int32(auxPet.Nature)
	}

	dv1 := alpacadecimal.NewFromInt(2).Div(alpacadecimal.NewFromInt(3)).Mul(alpacadecimal.NewFromInt(int64(masterPet.Dv)))
	dv2 := alpacadecimal.NewFromInt(1).Div(alpacadecimal.NewFromInt(3)).Mul(alpacadecimal.NewFromInt(int64(auxPet.Dv)))
	dv := dv1.Add(dv2).Add(alpacadecimal.NewFromInt(1)).IntPart()
	newPet := model.GenPetInfo(resultPetID, int(dv), int(natureID), effect, 1, nil, -1)
	newPet.OldCatchTime = masterPet.CatchTime

	shinyChance := 1
	if masterPet.IsShiny() || auxPet.IsShiny() {
		shinyChance = 50
	}
	if masterPet.IsShiny() && auxPet.IsShiny() {
		shinyChance = 100
	}
	if grand.Meet(shinyChance, 100) {
		newPet.RandomByWeightShiny()
	}

	c.Service.Pet.PetAdd(newPet, 0)
	//println(c.Info.UserID, "进行融合", len(c.Info.PetList), masterPet.ID, auxPet.ID, newPet.ID)

	c.PetDel(data.Mcatchtime)
	if useOptionalItem(c, data.GoldItem1[:], petFusionKeepAuxItemID) {
		result.CostItemFlag = 1
	} else {
		c.PetDel(data.Auxcatchtime)
	}

	result.ObtainTime = newPet.CatchTime
	result.StarterCpTm = newPet.ID
	return result, 0
}

func collectItemCounts(itemIDs []uint32) map[uint32]int {
	counts := make(map[uint32]int, len(itemIDs))
	for _, itemID := range itemIDs {
		counts[itemID]++
	}
	return counts
}

func hasEnoughItems(c *player.Player, itemCounts map[uint32]int) bool {
	if len(itemCounts) == 0 {
		return true
	}

	itemIDs := make([]uint32, 0, len(itemCounts))
	for itemID := range itemCounts {
		itemIDs = append(itemIDs, itemID)
	}

	hadItems := c.Service.Item.CheakItemM(itemIDs...)
	ownedCounts := make(map[uint32]int64, len(hadItems))
	for _, item := range hadItems {
		ownedCounts[item.ItemId] = item.ItemCnt
	}

	for itemID, need := range itemCounts {
		if ownedCounts[itemID] < int64(need) {
			return false
		}
	}

	return true
}

func consumeItems(c *player.Player, itemCounts map[uint32]int) {
	for itemID, count := range itemCounts {
		_ = c.Service.Item.UPDATE(itemID, -count)
	}
}

func useOptionalItem(c *player.Player, itemIDs []uint32, target uint32) bool {
	if c.Service.Item.CheakItem(target) <= 0 {
		return false
	}
	for _, itemID := range itemIDs {
		if itemID == target {
			_ = c.Service.Item.UPDATE(target, -1)
			return true
		}
	}
	return false
}