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

package model

import (
	"fmt"
	model2 "roserver/baseserver/model"
	gameModel "roserver/game/model"
	"roserver/serverproto"
)

type LiveAnswerRoom struct {
	LiveRoom
	questions   []*QuestionInfo
	userAnswers map[uint64]*AnswerInfo
}

type QuestionInfo struct {
	questionCfg *serverproto.LiveRoomQuestionCfg
	options     []int32
	answer      int32
}

type AnswerInfo struct {
	uid         uint64
	answers     map[uint64]int32
	rewardItems []*serverproto.KeyValueType
}

func newLiveAnswerRoom(roomId uint32, tickInterval uint32) *LiveAnswerRoom {
	room := &LiveAnswerRoom{
		LiveRoom: newLiveRoom(roomId, LIVEROOM_TYPE_ANSWER, tickInterval),
	}
	room.SetVF()
	return room
}

func (self *LiveAnswerRoom) 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 *LiveAnswerRoom) GetMaxReadyNum(roomType uint32) int {
	return LIVEROOM_ANSWER_MAX_READY_NUM
}

func (self *LiveAnswerRoom) ShowStart() {
	self.userAnswers = make(map[uint64]*AnswerInfo)
	self.questions = make([]*QuestionInfo, 0)
	liveRoomQuestionCfg := serverproto.LiveRoomQuestionCfgLoader
	keys := RandomKeys(liveRoomQuestionCfg, 1)
	for _, key := range keys {
		cfg := liveRoomQuestionCfg[key]
		options := []int32{1, 2, 3, 4}
		answerIdx := cfg.Answer
		ShuffleInPlace(options)
		for i := 0; i < len(options); i++ {
			if options[i] == answerIdx {
				answerIdx = int32(i + 1)
				break
			}
		}
		self.questions = append(self.questions, &QuestionInfo{
			questionCfg: cfg,
			options:     options,
			answer:      answerIdx,
		})
	}
}

func (self *LiveAnswerRoom) CheckAnswer(questionId int32, answer int32) bool {
	for _, v := range self.questions {
		if v.questionCfg.Id == questionId && v.answer == answer {
			return true
		}
	}
	return false
}

// 对游戏进行结算
func (self *LiveAnswerRoom) ShowEnd() {
	for _, v := range self.userAnswers {
		score := 0
		for questionId, answer := range v.answers {
			if self.CheckAnswer(int32(questionId), answer) {
				score += 1
			}
		}
		if score > 0 {
			for _, str := range self.LiveRoom.roomCfg.RewardS {
				itemId, itemNum := model2.Str2Res(str)
				v.rewardItems = append(v.rewardItems, &serverproto.KeyValueType{Key: itemId, Value: itemNum})
			}
		}
		self.LiveRoom.AddItemList(v.uid, v.rewardItems, int32(gameModel.AddFrom_LiveRoom_Answer), false)
	}
}

// Play命令：用于给客户端发送命令，显示题目，这里返回客户端显示题目相关数据
func (self *LiveAnswerRoom) GetCMDPlayDataList(readyUidList []uint64, uid uint64, cfg *serverproto.LiveRoomTalkCfg) []*serverproto.KeyValueType64 {
	return nil
}

// 返回玩家分数排名
func (self *LiveAnswerRoom) GetShowResultList(readyUidList []uint64, uid uint64) []*serverproto.LiveRoomPlayerInfo {
	playerResults := make([]*serverproto.LiveRoomPlayerInfo, 0)
	for _, tmpUid := range self.readyUidList {
		playerInfo := MakeLiveRoomPlayerInfo(tmpUid)
		playerInfo.Data = "0"
		if userAnswerInfo, exist := self.userAnswers[tmpUid]; exist {
			for k, v := range userAnswerInfo.answers {
				questionId := k
				answer := v
				if self.CheckAnswer(int32(questionId), answer) {
					playerInfo.Data = "1"
					break
				}
			}
		}
		playerResults = append(playerResults, playerInfo)
	}
	return playerResults
}

// 返回玩家玩游戏得到的奖励
func (self *LiveAnswerRoom) GetShowRewardList(readyUidList []uint64, uid uint64) []*serverproto.KeyValueType64 {
	rewardList := make([]*serverproto.KeyValueType64, 0)
	if userAnswerInfo, exist := self.userAnswers[uid]; exist {
		for _, v := range userAnswerInfo.rewardItems {
			rewardList = append(rewardList, &serverproto.KeyValueType64{
				Key:   uint64(v.Key),
				Value: v.Value,
			})
		}
	}
	return rewardList
}

func (self *LiveAnswerRoom) HasShowData() bool {
	return true
}

// 返回游戏过程中的状态数据
func (self *LiveAnswerRoom) GetShowData(readyUidList []uint64, uid uint64) []*serverproto.KeyValueType64 {
	showData := make([]*serverproto.KeyValueType64, 0)
	for _, v := range self.userAnswers {
		score := 0
		for questionId, answer := range v.answers {
			if self.CheckAnswer(int32(questionId), answer) {
				score += 1
			}
		}
		showData = append(showData, &serverproto.KeyValueType64{
			Key:   v.uid,
			Value: int32(score),
		})
	}
	return showData
}

// 处理玩家在游戏过程中提交的输入，玩家提交选择
func (self *LiveAnswerRoom) HandleShowSubmit(uid uint64, data []*serverproto.KeyValueType64) []*serverproto.KeyValueType64 {
	submitResult := make([]*serverproto.KeyValueType64, 0)
	if _, exist := self.userAnswers[uid]; exist == false {
		self.userAnswers[uid] = &AnswerInfo{
			uid:         uid,
			answers:     map[uint64]int32{},
			rewardItems: make([]*serverproto.KeyValueType, 0),
		}
	}
	for _, v := range data {
		questionId := v.Key
		answer := v.Value
		self.userAnswers[uid].answers[questionId] = int32(answer)
	}
	return submitResult
}

// 返回进入游戏阶段的一些初始化配置数据，下发题库
func (self *LiveAnswerRoom) GetStageEnterParams(stage uint32) string {
	stageEnterParams := ""
	switch stage {
	case LIVEROOM_STAGE_SHOW:
		optionStr := ArrayJoin(self.questions[0].options, "-")
		stageEnterParams = fmt.Sprintf("question:%d;options:%s", self.questions[0].questionCfg.Id, optionStr)
	}
	return stageEnterParams
}