joybuywork/internal/service/queue/consumer/campaignnotice/dice_map.go

package campaignnotice

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"fmt"
)

type DiceMap struct {
	logic.Logic

	Req *types.CampaignDiceMap
}

func (s *DiceMap) Exec() (err error) {
	cpn, can, err := s.check()
	if err != nil || !can {
		return
	}

	err = s.buildMap(cpn)
	if err != nil {
		return
	}

	return
}

func (s *DiceMap) check() (cpn *model.FissionCampaign, can bool, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.CampaignId)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil || cpn.FissionID != consts.IdDice || !cpn.IsPub() {
		return
	}

	can = true
	return
}

func (s *DiceMap) buildMap(cpn *model.FissionCampaign) (err error) {
	rewardM := s.GetDao().FissionCampaignReward
	rewards, err := rewardM.WithContext(s.Ctx).Where(
		rewardM.CampaignID.Eq(cpn.ID),
		rewardM.RewardType.Eq(mtype.FissionCampaignRewardTypeApp),
		rewardM.IsDel.Eq(mtype.No),
	).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var groupMap = make(map[string]int64)
	var groups []*model.FissionDiceMapGroup
	var rewardGroup = make(map[int64][]*model.FissionCampaignReward)
	for _, reward := range rewards {
		key := fmt.Sprintf("%s_%d_%s", reward.LangMark, reward.LevelID, reward.CountryMark)
		id, ok := groupMap[key]

		if !ok {
			group := withdefault.FissionDiceMapGroup(&model.FissionDiceMapGroup{
				CampaignID:  cpn.ID,
				LevelID:     reward.LevelID,
				LangMark:    reward.LangMark,
				CountryMark: reward.CountryMark,
			})
			groups = append(groups, group)

			id = group.ID
			groupMap[key] = id
		}

		rewardGroup[id] = append(rewardGroup[id], reward)
	}

	m := s.GetDao().FissionDiceMapGroup
	err = m.WithContext(s.Ctx).Create(groups...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	confM := s.GetDao().FissionCampaignDice
	conf, err := confM.WithContext(s.Ctx).Where(confM.CampaignID.Eq(cpn.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for dmgId, v := range rewardGroup {
		err = s._buildMap(conf, dmgId, v)
		if err != nil {
			return
		}
	}

	return
}

// 生成地图
func (s *DiceMap) _buildMap(conf *model.FissionCampaignDice, dmgId int64, rewards []*model.FissionCampaignReward) (err error) {

	nl := len(rewards)
	nm := utils.Ternary[int](nl%4 == 0, 1, 4)

	var rewardIds = make([]int64, 0, nl)
	for i := 0; i < nm; i++ {
		for _, reward := range rewards {
			rewardIds = append(rewardIds, reward.ID)
		}
	}

	groupMap := s._group(rewardIds, conf)

	var list = make([]*model.FissionDiceMap, 0, 30)
	for {
		if len(list) >= 120 {
			break
		}

		for _, m := range groupMap {
			var maps = make([]*model.FissionDiceMap, 0, 6)
			maps = append(maps, withdefault.FissionDiceMap(&model.FissionDiceMap{
				CampaignID: conf.CampaignID,
				MarkType:   mtype.FissionDiceMapMarkTypeNone,
				DmgID:      dmgId,
			}))
			for _, v := range m {
				maps = append(maps, withdefault.FissionDiceMap(&model.FissionDiceMap{
					CampaignID: conf.CampaignID,
					MarkType:   v.markType,
					RewardID:   v.rewardId,
					DmgID:      dmgId,
				}))
			}

			if len(maps) == 6 {
				list = append(list, maps...)
			}
		}
	}

	dmm := s.GetDao().FissionDiceMap
	if err = dmm.WithContext(s.Ctx).Create(list...); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

type gm struct {
	markType int8
	rewardId int64
}

// 把奖品分成一组一组的
func (s *DiceMap) _group(rewardIds []int64, conf *model.FissionCampaignDice) []map[int]gm {
	var idx int
	var groupMap = make([]map[int]gm, len(rewardIds)/4)
	var done = func() {
		var one = map[int]gm{}

		for i := 1; i <= 4; i++ {
			one[i] = gm{markType: mtype.FissionDiceMapMarkTypeNormal, rewardId: rewardIds[idx]}
			idx++
		}

		one[5] = gm{markType: utils.Ternary[int8](conf.RollAgain == mtype.Yes, mtype.FissionDiceMapMarkTypeChance, mtype.FissionDiceMapMarkTypeNone)}

		groupMap = append(groupMap, one)
	}

	for {
		if len(rewardIds) <= idx {
			break
		}
		done()
	}

	return groupMap
}