ro-webgl-server/server/roserver/fruit/model/live_card_room.go

package model

import (
	"fmt"
	"math/rand"
	"rocommon/util"
	"roserver/baseserver/model"
	model2 "roserver/game/model"
	"roserver/serverproto"
	"strings"
)

const (
	ROLL_CARD_X5          = 5
	ROLL_CARD_TYPE_NORMAL = 1
	ROLL_CARD_TYPE_MINI   = 2
	ROLL_CARD_TYPE_MVP    = 3
)

type RollCardCfg struct {
	cardId     int32
	cardType   int32
	cardLevel  int32
	weight     int
	rangeStart int
	rangeEnd   int
}

type LiveCardRoom struct {
	LiveRoom
	rollCardCfgList []*RollCardCfg
	rollCards       []*serverproto.KeyValueType64
	showRewards     []*serverproto.KeyValueType64
}

func newLiveCardRoom(roomId uint32, tickInterval uint32) *LiveCardRoom {
	room := &LiveCardRoom{
		LiveRoom:    newLiveRoom(roomId, LIVEROOM_TYPE_CARD, tickInterval),
		rollCards:   make([]*serverproto.KeyValueType64, 0),
		showRewards: make([]*serverproto.KeyValueType64, 0),
	}
	room.SetVF()
	room.Init()
	return room
}

func (self *LiveCardRoom) SetVF() {
	self.VF_GetMaxReadyNum = self.GetMaxReadyNum
	self.VF_GetCMDPlayDataList = self.GetCMDPlayDataList
	self.VF_GetShowResultList = self.GetShowResultList
	self.VF_GetShowRewardList = self.GetShowRewardList
	self.VF_HasShowData = self.HasShowData
	self.VF_GetShowData = self.GetShowData
	self.VF_HandleShowSubmit = self.HandleShowSubmit
	self.VF_GetStageEnterParams = self.GetStageEnterParams
	self.VF_ReadyStart = self.ReadyStart
	self.VF_ShowStart = self.ShowStart
	self.VF_CheckIfShowEnd = self.CheckIfShowEnd
	self.VF_ShowEnd = self.ShowEnd
	self.VF_HandlePlayCMD = self.HandlePlayCMD
}

func (self *LiveCardRoom) Init() {
	cardCfg := serverproto.CardCfgLoader
	for _, v := range cardCfg {
		if v.CardId < 20000 {
			switch v.CardType {
			case ROLL_CARD_TYPE_NORMAL:
				self.rollCardCfgList = append(self.rollCardCfgList, &RollCardCfg{
					cardId:     v.CardId,
					cardType:   v.CardType,
					cardLevel:  v.CardLevel,
					weight:     5 * (6 - int(v.CardLevel)),
					rangeStart: 0,
					rangeEnd:   0,
				})
			case ROLL_CARD_TYPE_MINI:
				self.rollCardCfgList = append(self.rollCardCfgList, &RollCardCfg{
					cardId:     v.CardId,
					cardType:   v.CardType,
					cardLevel:  v.CardLevel,
					weight:     5 * (6 - int(v.CardLevel)),
					rangeStart: 0,
					rangeEnd:   0,
				})
			case ROLL_CARD_TYPE_MVP:
				self.rollCardCfgList = append(self.rollCardCfgList, &RollCardCfg{
					cardId:     v.CardId,
					cardType:   v.CardType,
					cardLevel:  v.CardLevel,
					weight:     5 * (6 - int(v.CardLevel)),
					rangeStart: 0,
					rangeEnd:   0,
				})
			}
		}
	}
	var offset int = 0
	for _, v := range self.rollCardCfgList {
		if v.cardType == ROLL_CARD_TYPE_NORMAL {
			v.rangeStart += offset
			v.rangeEnd = v.rangeStart + v.weight - 1
			offset += v.weight
		}
	}
	offset = 0
	for _, v := range self.rollCardCfgList {
		if v.cardType == ROLL_CARD_TYPE_MINI {
			v.rangeStart += offset
			v.rangeEnd = v.rangeStart + v.weight - 1
			offset += v.weight
		}
	}
	offset = 0
	for _, v := range self.rollCardCfgList {
		if v.cardType == ROLL_CARD_TYPE_MVP {
			v.rangeStart += offset
			v.rangeEnd = v.rangeStart + v.weight - 1
			offset += v.weight
		}
	}

	//Test RollCards
	result1 := self.RollCards(1, 1)
	result2 := self.RollCards(2, 3)
	result3 := self.RollCards(3, 5)
	//addItems := make([]*serverproto.KeyValueType, 0)
	//for _, v := range result3 {
	//	itemId, itemNum := model.Str2Res(v)
	//	addItems = append(addItems, &serverproto.KeyValueType{Key: itemId, Value: itemNum})
	//}
	//self.AddItemList(self.LiveRoom.uidList[0], addItems, int32(model2.AddFrom_LiveRoom_Card), false)
	util.InfoF("result: ", strings.Join(result1, ";"), strings.Join(result2, ";"), strings.Join(result3, ";"))
	//for _, v := range self.rollCardCfgList {
	//	if v.cardType == ROLL_CARD_TYPE_NORMAL {
	//		util.InfoF("rollCfg-ROLL_CARD_TYPE_NORMAL: cardId-%d cardLv-%d [%d, %d]", v.cardId, v.cardLevel, v.rangeStart, v.rangeEnd)
	//	}
	//}
	//for _, v := range self.rollCardCfgList {
	//	if v.cardType == ROLL_CARD_TYPE_MINI {
	//		util.InfoF("rollCfg-ROLL_CARD_TYPE_MINI: cardId-%d cardLv-%d [%d, %d]", v.cardId, v.cardLevel, v.rangeStart, v.rangeEnd)
	//	}
	//}
	//for _, v := range self.rollCardCfgList {
	//	if v.cardType == ROLL_CARD_TYPE_MVP {
	//		util.InfoF("rollCfg-ROLL_CARD_TYPE_MVP: cardId-%d cardLv-%d [%d, %d]", v.cardId, v.cardLevel, v.rangeStart, v.rangeEnd)
	//	}
	//}
}

func (self *LiveCardRoom) RollCards(cardType int32, cardCount int) []string {
	var sumWeight int = 0
	for _, v := range self.rollCardCfgList {
		if v.cardType == cardType {
			sumWeight += v.weight
		}
	}
	rollCardIds := make([]string, 0)
	for i := 0; i < cardCount; i++ {
		var rollCardId int32 = 0
		randNum := rand.Intn(sumWeight)
		for _, v := range self.rollCardCfgList {
			if v.cardType == cardType && randNum >= v.rangeStart && randNum <= v.rangeEnd {
				rollCardId = v.cardId
				break
			}
		}
		rollCardIds = append(rollCardIds, fmt.Sprintf("%d:%d", rollCardId, 1))
	}
	return rollCardIds
}

func (self *LiveCardRoom) ShowStart() {
	// 为准备的玩家抽卡
	weightCfg := map[string]int{"NORMAL": 50, "MINI": 30, "MVP": 20}
	self.rollCards = make([]*serverproto.KeyValueType64, 0)
	self.showRewards = make([]*serverproto.KeyValueType64, 0)
	for _, uid := range self.LiveRoom.readyUidList {
		cards := make([]string, 0)
		// 1. 保底抽一张MINI卡
		firstCard := self.RollCards(ROLL_CARD_TYPE_MINI, 1)
		cards = append(cards, firstCard...)
		// 2. 抽其他4张卡
		for i := 1; i <= 4; i++ {
			quality := WeightedRandomChoice(weightCfg)
			switch quality {
			case "NORMAL":
				normalCard := self.RollCards(ROLL_CARD_TYPE_NORMAL, 1)
				cards = append(cards, normalCard...)
			case "MINI":
				miniCard := self.RollCards(ROLL_CARD_TYPE_MINI, 1)
				cards = append(cards, miniCard...)
			case "MVP":
				mvpCard := self.RollCards(ROLL_CARD_TYPE_MVP, 1)
				cards = append(cards, mvpCard...)
			}
		}
		rand.Shuffle(len(cards), func(i, j int) {
			cards[i], cards[j] = cards[j], cards[i]
		})
		self.rollCards = append(self.rollCards, &serverproto.KeyValueType64{
			Key:    uid,
			StrVal: strings.Join(cards, ";"),
		})
		self.showRewards = append(self.showRewards, &serverproto.KeyValueType64{
			Key:    uid,
			StrVal: strings.Join(cards, ";"),
		})
		addItems := make([]*serverproto.KeyValueType, 0)
		for _, v := range cards {
			itemId, itemNum := model.Str2Res(v)
			addItems = append(addItems, &serverproto.KeyValueType{Key: itemId, Value: itemNum})
		}
		self.AddItemList(uid, addItems, int32(model2.AddFrom_LiveRoom_Card), false)
	}
}

func (self *LiveCardRoom) ShowEnd() {}

func (self *LiveCardRoom) GetMaxReadyNum(roomType uint32) int {
	util.InfoF("LiveCardRoom: GetMaxReadyNum")
	return LIVEROOM_CARD_MAX_READY_NUM
}

func (self *LiveCardRoom) GetCMDPlayDataList(readyUidList []uint64, uid uint64, cfg *serverproto.LiveRoomTalkCfg) []*serverproto.KeyValueType64 {
	return nil
}

// 抽卡：获取整个抽卡结果数据，在客户端播放抽卡动画
func (self *LiveCardRoom) GetShowResultList(readyUidList []uint64, uid uint64) []*serverproto.LiveRoomPlayerInfo {
	showResultList := make([]*serverproto.LiveRoomPlayerInfo, 0)
	for _, v := range self.rollCards {
		currUid := v.Key
		currPlayerInfo := MakeLiveRoomPlayerInfo(currUid)
		currPlayerInfo.Data = v.StrVal
		showResultList = append(showResultList, currPlayerInfo)
	}
	return showResultList
}

// 抽卡：获取当前玩家获得的物品
func (self *LiveCardRoom) GetShowRewardList(readyUidList []uint64, uid uint64) []*serverproto.KeyValueType64 {
	return self.showRewards
}

func (self *LiveCardRoom) ShowSubmit(uid uint64, data []*serverproto.KeyValueType64) []*serverproto.KeyValueType64 {
	return nil
}