ro-webgl-server/server/roserver/fruit/msg/room_msg.go

package msg

import (
	"log"
	"rocommon"
	"rocommon/util"
	"roserver/baseserver/model"
	model2 "roserver/fruit/model"
	"roserver/serverproto"
)

func init() {
	log.Println("fruit msg init ..")
	serverproto.Handle_FRUIT_SSPlayerOnlineNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPlayerOnlineNtf)
		util.InfoF("receive SSPlayerOnlineNtf msg:%v", msg)
		player := model2.RoomMgr.AddPlayer(msg.BriefInfo.Uid, msg.BriefInfo.NickName)
		player.Online = true
	})

	serverproto.Handle_FRUIT_SSPlayerOfflineNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPlayerOfflineNtf)
		util.InfoF("receive SSPlayerOfflineNtf msg:%v", msg)
		player := model2.RoomMgr.GetPlayer(msg.Uid)
		if player != nil {
			player.Online = false
		}
	})

	serverproto.Handle_FRUIT_CSFruitJoinReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFruitJoinReq)
		util.InfoF("receive CSFruitJoinReq msg:%v", msg)
		player := model2.RoomMgr.GetPlayer(msg.Uid)
		player.Name = msg.Nickname
		player.HeadId = msg.HeadId
		player.Level = uint32(msg.Level)
		player.CoinNum = uint32(msg.ChipNum)
		fruitGameRoom := model2.RoomMgr.GetFruitGameRoom(msg.Uid)
		fruitGameRoom.Join(msg.Uid)
		totalBetInfo := make([]*serverproto.FruitSlotInfo, 0)
		for slot := 1; slot <= 8; slot++ {
			betNum := fruitGameRoom.TotalBetInfo[int32(slot)]
			totalBetInfo = append(totalBetInfo, &serverproto.FruitSlotInfo{
				Slot: int32(slot),
				Num:  betNum,
			})
		}
		myBetInfo := make([]*serverproto.FruitSlotInfo, 0)
		for slot := 1; slot <= 8; slot++ {
			betNum := player.CurrBetInfo[int32(slot)]
			myBetInfo = append(myBetInfo, &serverproto.FruitSlotInfo{
				Slot: int32(slot),
				Num:  betNum,
			})
		}
		ackMsg := &serverproto.SCFruitJoinAck{
			Uid:             msg.Uid,
			Error:           0,
			Stage:           fruitGameRoom.Stage,
			Sec:             fruitGameRoom.Sec,
			MyChipNum:       int32(player.CoinNum),
			PoolChipNum:     fruitGameRoom.PoolChipNum,
			TotalBetInfo:    totalBetInfo,
			MyBetInfo:       myBetInfo,
			SettleHistory:   fruitGameRoom.SettleHistory,
			CurrAwardSlots:  fruitGameRoom.CurrAwardSlots,
			CurrTargetSlot:  fruitGameRoom.CurrTargetSlot,
			PlayerAwardRank: fruitGameRoom.CurrPlayerAwardRank,
		}
		model.ServiceReplay(ev, ackMsg)
	})

	serverproto.Handle_FRUIT_CSFruitLeaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFruitLeaveReq)
		util.InfoF("receive CSFruitLeaveReq msg:%v", msg)
		fruitGameRoom := model2.RoomMgr.GetFruitGameRoom(msg.Uid)
		fruitGameRoom.Leave(msg.Uid)
		ackMsg := &serverproto.SCFruitLeaveAck{
			Uid:   msg.Uid,
			Error: 0,
		}
		model.ServiceReplay(ev, ackMsg)
	})

	serverproto.Handle_FRUIT_CSFruitBetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFruitBetReq)
		util.InfoF("receive CSFruitBetReq msg:%v", msg)
		uid := msg.Uid
		fruitGameRoom := model2.RoomMgr.GetFruitGameRoom(msg.Uid)
		errCode := fruitGameRoom.Bet(msg.Uid, msg.GetBetInfo())
		player := model2.RoomMgr.GetPlayer(uid)
		totalBetInfo := make([]*serverproto.FruitSlotInfo, 0)
		myBetInfo := make([]*serverproto.FruitSlotInfo, 0)
		var i int32
		for i = 1; i <= 8; i++ {
			slotTotalBetNum := fruitGameRoom.TotalBetInfo[i]
			myBetNum := player.CurrBetInfo[i]
			totalBetInfo = append(totalBetInfo, &serverproto.FruitSlotInfo{
				Slot: i,
				Num:  slotTotalBetNum,
			})
			myBetInfo = append(myBetInfo, &serverproto.FruitSlotInfo{
				Slot: i,
				Num:  myBetNum,
			})
		}
		ackMsg := &serverproto.SCFruitBetAck{
			Uid:          msg.Uid,
			Error:        int32(errCode),
			MyChipNum:    int32(player.CoinNum),
			PoolChipNum:  uint32(fruitGameRoom.PoolChipNum),
			TotalBetInfo: totalBetInfo,
			MyBetInfo:    myBetInfo,
		}
		model.ServiceReplay(ev, ackMsg)
	})

	serverproto.Handle_FRUIT_CSFruitChatReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSFruitChatReq)
		util.InfoF("receive CSFruitChatReq msg:%v", msg)
		fruitGameRoom := model2.RoomMgr.GetFruitGameRoom(msg.Uid)
		fruitGameRoom.SendChat(msg.Uid, msg.ChatContent)
	})

	serverproto.Handle_FRUIT_CSLiveRoomJoinReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSLiveRoomJoinReq)
		util.InfoF("receive CSLiveRoomJoinReq msg:%v", msg)
		player := model2.RoomMgr.GetPlayer(msg.Uid)
		player.Name = msg.PlayerInfo.Nickname
		player.HeadId = msg.PlayerInfo.HeadId
		player.Level = msg.PlayerInfo.Level
		player.CoinNum = msg.CoinNum
		player.GameChipNum = msg.GameChipNum
		liveRoom, err := model2.RoomMgr.FindLiveRoom(msg.Uid, msg.RoomType)
		if err != nil {
			ackMsg := &serverproto.SCLiveRoomJoinAck{
				Uid:   msg.Uid,
				Error: int32(serverproto.ErrorCode_ERROR_LIVEROOM_NOT_FIND_ROOM),
			}
			model.ServiceReplay(ev, ackMsg)
			return
		}

		liveRoom.Join(msg.Uid)
		ackMsg := &serverproto.SCLiveRoomJoinAck{
			Uid:           msg.Uid,
			Error:         int32(serverproto.ErrorCode_ERROR_OK),
			RoomId:        liveRoom.RoomId(),
			StageSec:      liveRoom.StageSec(),
			StageTimerSec: liveRoom.StageTimerSec(),
			Stage:         liveRoom.Stage(),
			Rank:          liveRoom.Rank(),
			ChatDatas:     liveRoom.ChatRecords(),
		}
		model.ServiceReplay(ev, ackMsg)
	})

	serverproto.Handle_FRUIT_CSLiveRoomLeaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSLiveRoomLeaveReq)
		util.InfoF("receive CSLiveRoomLeaveReq msg:%v", msg)
		liveRoom, _ := model2.RoomMgr.GetLiveRoomByRoomId(msg.RoomId)
		if liveRoom != nil {
			liveRoom.Leave(msg.Uid)
			ackMsg := &serverproto.SCLiveRoomLeaveAck{
				Uid:    msg.Uid,
				RoomId: liveRoom.RoomId(),
				Error:  0,
			}
			model.ServiceReplay(ev, ackMsg)
		}
	})

	serverproto.Handle_FRUIT_CSLiveRoomChatReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSLiveRoomChatReq)
		util.InfoF("receive CSLiveRoomChatReq msg:%v", msg)
		liveRoom, _ := model2.RoomMgr.GetLiveRoomByRoomId(msg.RoomId)
		if liveRoom != nil {
			liveRoom.SendChat(msg.Uid, msg.ChatContent)
		}
	})

	serverproto.Handle_FRUIT_CSLiveRoomGetReadyReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSLiveRoomGetReadyReq)
		util.InfoF("receive CSLiveRoomGetReadyReq msg:%v", msg)
		liveRoom, _ := model2.RoomMgr.GetLiveRoomByRoomId(msg.RoomId)
		if liveRoom != nil {
			errCode := int32(serverproto.ErrorCode_ERROR_OK)
			if liveRoom.GetReady(msg.Uid) == false {
				errCode = int32(serverproto.ErrorCode_ERROR_FAIL)
			}
			ackMsg := &serverproto.SCLiveRoomGetReadyAck{
				Uid:   msg.Uid,
				Error: errCode,
			}
			model.ServiceReplay(ev, ackMsg)
		}
	})

	serverproto.Handle_FRUIT_CSLiveRoomSubmitReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSLiveRoomSubmitReq)
		util.InfoF("receive CSLiveRoomSubmitReq msg:%v", msg)
		liveRoom, _ := model2.RoomMgr.GetLiveRoomByRoomId(msg.RoomId)
		if liveRoom != nil {
			//liveRoom.SendChat(msg.Uid, msg.ChatContent)
			errCode := int32(serverproto.ErrorCode_ERROR_OK)
			ackMsg := &serverproto.SCLiveRoomSubmitAck{
				Uid:   msg.Uid,
				Error: errCode,
			}
			model.ServiceReplay(ev, ackMsg)
		}
	})
}