game_sync/gamesrv/clawdoll/action_clawdoll.go

package clawdoll

import (
	"mongo.games.com/game/common"
	rule "mongo.games.com/game/gamerule/clawdoll"
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/protocol/clawdoll"
	"mongo.games.com/game/protocol/machine"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
)

type CSPlayerOpPacketFactory struct {
}

type CSPlayerOpHandler struct {
}

func (f *CSPlayerOpPacketFactory) CreatePacket() interface{} {
	pack := &clawdoll.CSCLAWDOLLOp{}
	return pack
}

func (h *CSPlayerOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerOpHandler Process recv ", data)
	if msg, ok := data.(*clawdoll.CSCLAWDOLLOp); ok {
		p := base.PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerOpHandler p == nil")
			return nil
		}
		scene := p.GetScene()
		if scene == nil {
			logger.Logger.Warn("CSPlayerOpHandler p.scene == nil")
			return nil
		}

		if scene.KeyGameDif != common.GameDifClawdoll {
			logger.Logger.Error("CSPlayerOpHandler gameId Error ", scene.GameId)
			return nil
		}
		if !scene.HasPlayer(p) {
			return nil
		}
		sp := scene.GetScenePolicy()
		if sp != nil {
			sp.OnPlayerOp(scene, p, int(msg.GetOpCode()), msg.GetParams())
		}
		return nil
	}
	return nil
}
func MSDollMachineoCoinResultHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("收到返回上分结果！！！！！！！！！！")
	if msg, ok := data.(*machine.MSDollMachineoPerateResult); ok {

		p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnid())
		if p == nil {
			logger.Logger.Warn("CSGetTokenHandler p == nil")
			return nil
		}

		scene := p.GetScene()
		if scene == nil {
			return nil
		}
		sceneEx, ok := scene.ExtraData.(*SceneEx)
		if !ok {
			return nil
		}

		switch msg.TypeId {
		case 1:
			if msg.Result == 1 {
				logger.Logger.Tracef("上分成功！！！！！！！！！！！！snid = ", msg.Snid)
			} else {
				logger.Logger.Tracef("上分失败！！！！！！！！！！！！snid = ", msg.Snid)
			}
		case 2:
			if msg.Result == 1 {

			} else {
				logger.Logger.Tracef("下抓失败！！！！！！！！！！！！snid = ", msg.Snid)
			}

			scene.ChangeSceneState(rule.ClawDollSceneStateBilled)

			sceneEx.SetPlayingState(int32(rule.ClawDollSceneStateBilled))

			ClawdollBroadcastRoomState(scene)
			ClawdollSendPlayerInfo(scene)
		}
	}
	return nil
}

type CSGetTokenPacketFactory struct {
}

type CSGetTokenHandler struct {
}

func (f *CSGetTokenPacketFactory) CreatePacket() interface{} {
	pack := &clawdoll.CSCLAWDOLLGetToken{}
	return pack
}

func (h *CSGetTokenHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	//转发到娃娃机主机
	logger.Logger.Tracef("CSGetTokenHandler")
	if _, ok := data.(*clawdoll.CSCLAWDOLLGetToken); ok {
		p := base.PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSGetTokenHandler p == nil")
			return nil
		}
		pack := &machine.SMGetToken{}
		pack.Snid = p.SnId

		scene := p.GetScene()
		if scene == nil {
			return nil
		}
		sceneEx, ok := scene.ExtraData.(*SceneEx)
		if !ok {
			return nil
		}

		machineId := scene.GetDBGameFree().GetId() % 6080000
		appId, serverSecret := sceneEx.GetMachineServerSecret(machineId, p.Platform)
		logger.Logger.Tracef("获取娃娃机 appId = %v, serverSecret = %v", appId, serverSecret)
		if serverSecret == "" || appId == 0 {
			return nil
		}

		pack.ServerSecret = serverSecret
		pack.AppId = appId
		sceneEx.SendToMachine(int(machine.DollMachinePacketID_PACKET_SMGetToken), pack)
	}
	return nil
}

// 娃娃机返回token 通知客户端
func MSSendTokenHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("MSSendTokenHandler")
	if msg, ok := data.(*machine.MSSendToken); ok {
		//给客户端返回token
		token := msg.Token
		p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnid())
		if p == nil {
			logger.Logger.Warn("MSSendTokenHandler p == nil")
			return nil
		}

		scene := p.GetScene()
		if scene == nil {
			return nil
		}

		pack := &clawdoll.SCCLAWDOLLSendToken{
			LogicId: scene.DBGameFree.GetId(),
			Appid:   msg.Appid,
			Token:   token,
		}
		p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_SENDTOKEN), pack)
	}
	return nil
}
func init() {
	common.RegisterHandler(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_PLAYEROP), &CSPlayerOpHandler{})
	netlib.RegisterFactory(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_PLAYEROP), &CSPlayerOpPacketFactory{})
	netlib.Register(int(machine.DollMachinePacketID_PACKET_MSDollMachineoPerateResult), &machine.MSDollMachineoPerateResult{}, MSDollMachineoCoinResultHandler)
	//客户端请求token
	common.RegisterHandler(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_GETTOKEN), &CSGetTokenHandler{})
	netlib.RegisterFactory(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_GETTOKEN), &CSGetTokenPacketFactory{})
	//获取token返回
	netlib.Register(int(machine.DollMachinePacketID_PACKET_MSSendToken), &machine.MSSendToken{}, MSSendTokenHandler)
}