578 lines
21 KiB
Go
578 lines
21 KiB
Go
package action
|
|
|
|
import (
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/netlib"
|
|
"mongo.games.com/goserver/srvlib"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/gamesrv/base"
|
|
"mongo.games.com/game/model"
|
|
"mongo.games.com/game/proto"
|
|
"mongo.games.com/game/protocol/server"
|
|
"mongo.games.com/game/protocol/webapi"
|
|
)
|
|
|
|
func init() {
|
|
//创建场景
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_CREATESCENE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGCreateScene{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_CREATESCENE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGCreateScene:", pack)
|
|
if msg, ok := pack.(*server.WGCreateScene); ok {
|
|
sceneId := int(msg.GetSceneId())
|
|
gameMode := int(msg.GetGameMode())
|
|
sceneMode := int(msg.GetSceneMode())
|
|
gameId := int(msg.GetGameId())
|
|
paramsEx := msg.GetParamsEx()
|
|
hallId := msg.GetHallId()
|
|
groupId := msg.GetGroupId()
|
|
dbGameFree := msg.GetDBGameFree()
|
|
bEnterAfterStart := msg.GetEnterAfterStart()
|
|
totalOfGames := msg.GetTotalOfGames()
|
|
baseScore := msg.GetBaseScore()
|
|
playerNum := int(msg.GetPlayerNum())
|
|
scene := base.SceneMgrSington.CreateScene(s, sceneId, gameMode, sceneMode, gameId, msg.GetPlatform(), msg.GetParams(),
|
|
msg.GetAgentor(), msg.GetCreator(), msg.GetReplayCode(), hallId, groupId, totalOfGames, dbGameFree,
|
|
bEnterAfterStart, baseScore, playerNum, msg.GetChessRank(), paramsEx...)
|
|
if scene != nil {
|
|
if scene.IsMatchScene() {
|
|
if len(scene.Params) > 0 {
|
|
scene.MatchId = scene.Params[0]
|
|
}
|
|
if len(scene.Params) > 1 {
|
|
scene.MatchFinals = scene.Params[1] == 1
|
|
}
|
|
if len(scene.Params) > 2 {
|
|
scene.MatchRound = scene.Params[2]
|
|
}
|
|
if len(scene.Params) > 3 {
|
|
scene.MatchCurPlayerNum = scene.Params[3]
|
|
}
|
|
if len(scene.Params) > 4 {
|
|
scene.MatchNextNeed = scene.Params[4]
|
|
}
|
|
if len(scene.Params) > 5 {
|
|
scene.MatchType = scene.Params[5]
|
|
}
|
|
}
|
|
scene.ClubId = msg.GetClub()
|
|
scene.RoomId = msg.GetClubRoomId()
|
|
scene.RoomPos = msg.GetClubRoomPos()
|
|
scene.PumpCoin = msg.GetClubRate()
|
|
scene.RealCtrl = msg.RealCtrl
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//删除场景
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_DESTROYSCENE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGDestroyScene{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_DESTROYSCENE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGDestroyScene:", pack)
|
|
if msg, ok := pack.(*server.WGDestroyScene); ok {
|
|
sceneId := int(msg.GetSceneId())
|
|
s := base.SceneMgrSington.GetScene(sceneId)
|
|
if s != nil {
|
|
if gameScene, ok := s.ExtraData.(base.GameScene); ok {
|
|
gameScene.SceneDestroy(true)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//删除场景
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_GRACE_DESTROYSCENE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGGraceDestroyScene{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_GRACE_DESTROYSCENE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGGraceDestroyScene:", pack)
|
|
if msg, ok := pack.(*server.WGGraceDestroyScene); ok {
|
|
ids := msg.GetIds()
|
|
for _, id := range ids {
|
|
s := base.SceneMgrSington.GetScene(int(id))
|
|
if s != nil {
|
|
if s.IsHundredScene() || s.Gaming {
|
|
s.SetGraceDestroy(true)
|
|
} else {
|
|
if s.IsMatchScene() {
|
|
s.SetGraceDestroy(true)
|
|
}
|
|
if gameScene, ok := s.ExtraData.(base.GameScene); ok {
|
|
gameScene.SceneDestroy(true)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家进入
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERENTER), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGPlayerEnter{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERENTER), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGPlayerEnter")
|
|
if msg, ok := pack.(*server.WGPlayerEnter); ok {
|
|
sceneId := int(msg.GetSceneId())
|
|
sid := msg.GetSid()
|
|
data := msg.GetPlayerData()
|
|
gateSid := msg.GetGateSid()
|
|
isload := msg.GetIsLoaded()
|
|
IsQM := msg.GetIsQM()
|
|
sendLeave := func(reason int) {
|
|
pack := &server.GWPlayerLeave{
|
|
RoomId: msg.SceneId,
|
|
PlayerId: msg.SnId,
|
|
ReturnCoin: msg.TakeCoin,
|
|
Reason: proto.Int(reason),
|
|
}
|
|
proto.SetDefaults(pack)
|
|
s.Send(int(server.SSPacketID_PACKET_GW_PLAYERLEAVE), pack)
|
|
}
|
|
scene := base.SceneMgrSington.GetScene(sceneId)
|
|
p := base.NewPlayer(sid, data, nil, nil)
|
|
if p == nil && !scene.IsMatchScene() {
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
p.UnmarshalIParam(msg.GetIParams())
|
|
p.UnmarshalSParam(msg.GetSParams())
|
|
p.UnmarshalCParam(msg.GetCParams())
|
|
p.AgentCode = msg.GetAgentCode()
|
|
p.Coin = msg.GetTakeCoin()
|
|
p.Pos = int(msg.GetPos())
|
|
p.MatchParams = msg.GetMatchParams()
|
|
for id, num := range msg.Items {
|
|
p.Items[id] = num
|
|
}
|
|
for k, v := range msg.RankScore {
|
|
p.RankScore[k] = v
|
|
}
|
|
p.SetTakeCoin(msg.GetTakeCoin())
|
|
//p.StartCoin = msg.GetTakeCoin()
|
|
//机器人用
|
|
p.ExpectGameTime = msg.GetExpectGameTimes()
|
|
p.ExpectLeaveCoin = msg.GetExpectLeaveCoin()
|
|
//当局游戏结束后剩余金额 起始设置
|
|
p.SetCurrentCoin(msg.GetTakeCoin())
|
|
|
|
p.LastSyncCoin = p.Coin
|
|
p.IsQM = IsQM
|
|
p.AppChannel = msg.GetAppChannel()
|
|
|
|
if sid == 0 && (scene != nil && !scene.IsMatchScene()) {
|
|
logger.Logger.Warnf("when WGPlayerEnter (sid == 0)")
|
|
//进入房间失败
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
|
|
if scene == nil {
|
|
logger.Logger.Warn("when WGPlayerEnter (scene == nil)")
|
|
//进入房间失败
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
|
|
isQuit := p.GetIParam(common.PlayerIParam_IsQuit)
|
|
logger.Logger.Tracef("WGPlayerEnter scene.IsMatchScene()=%v p.GetIParam(common.PlayerIParam_IsQuit)=%v", scene.IsMatchScene(), isQuit)
|
|
if scene.IsMatchScene() && isQuit == 1 { //比赛场退赛
|
|
p.MarkFlag(base.PlayerState_MatchQuit)
|
|
p.MarkFlag(base.PlayerState_Auto)
|
|
p.MarkFlag(base.PlayerState_Leave)
|
|
}
|
|
|
|
var sessionId srvlib.SessionId
|
|
sessionId.Set(gateSid)
|
|
gateSess := srvlib.ServerSessionMgrSington.GetSession(int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
|
|
logger.Logger.Tracef("WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=%v", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()), gateSess)
|
|
if gateSess == nil && !scene.IsMatchScene() {
|
|
logger.Logger.Warnf("WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=<nil>", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
|
|
//进入房间失败
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
|
|
p.SetGateSess(gateSess)
|
|
p.SetWorldSess(s)
|
|
|
|
if gateSess != nil {
|
|
pack := &server.GGPlayerSessionBind{
|
|
Sid: proto.Int64(sid),
|
|
}
|
|
if !p.IsRob {
|
|
pack.SnId = proto.Int32(p.SnId)
|
|
pack.Vip = proto.Int32(p.VIP)
|
|
pack.CoinPayTotal = proto.Int64(p.CoinPayTotal)
|
|
pack.Ip = proto.String(p.Ip)
|
|
pack.Platform = proto.String(p.Platform)
|
|
}
|
|
proto.SetDefaults(pack)
|
|
gateSess.Send(int(server.SSPacketID_PACKET_GG_PLAYERSESSIONBIND), pack)
|
|
}
|
|
|
|
if scene.Testing {
|
|
p.Coin = int64(scene.DbGameFree.GetTestTakeCoin())
|
|
}
|
|
base.PlayerMgrSington.ManagePlayer(p)
|
|
scene.PlayerEnter(p, isload)
|
|
//进场失败
|
|
if p.IsMarkFlag(base.PlayerState_EnterSceneFailed) {
|
|
scene.PlayerLeave(p, common.PlayerLeaveReason_Normal, true)
|
|
} else {
|
|
// 进入成功
|
|
if !p.IsRobot() && !scene.Testing && !scene.IsMatchScene() {
|
|
//base.LogChannelSingleton.WriteMQData(model.GenerateEnterEvent(scene.GetRecordId(), p.SnId, p.Platform,
|
|
// p.DeviceOS, scene.GameId, scene.GameMode, scene.GetGameFreeId()))
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//观众进入
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_AUDIENCEENTER), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGPlayerEnter{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_AUDIENCEENTER), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive PACKET_WG_AUDIENCEENTER WGPlayerEnter")
|
|
if msg, ok := pack.(*server.WGPlayerEnter); ok {
|
|
sceneId := int(msg.GetSceneId())
|
|
sid := msg.GetSid()
|
|
data := msg.GetPlayerData()
|
|
gateSid := msg.GetGateSid()
|
|
isload := msg.GetIsLoaded()
|
|
IsQM := msg.GetIsQM()
|
|
var sessionId srvlib.SessionId
|
|
sessionId.Set(gateSid)
|
|
sendLeave := func(reason int) {
|
|
pack := &server.GWPlayerLeave{
|
|
RoomId: msg.SceneId,
|
|
PlayerId: msg.SnId,
|
|
ReturnCoin: msg.TakeCoin,
|
|
Reason: proto.Int(reason),
|
|
}
|
|
proto.SetDefaults(pack)
|
|
s.Send(int(server.SSPacketID_PACKET_GW_AUDIENCELEAVE), pack)
|
|
}
|
|
scene := base.SceneMgrSington.GetScene(sceneId)
|
|
if scene == nil || sid == 0 {
|
|
if sid == 0 {
|
|
logger.Logger.Warnf("when WGAUPlayerEnter (sid == 0)")
|
|
}
|
|
|
|
//进入房间失败
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
|
|
gateSess := srvlib.ServerSessionMgrSington.GetSession(int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
|
|
logger.Logger.Tracef("PACKET_WG_AUDIENCEENTER WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=%v", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()), gateSess)
|
|
if gateSess != nil {
|
|
pack := &server.GGPlayerSessionBind{
|
|
Sid: proto.Int64(sid),
|
|
}
|
|
proto.SetDefaults(pack)
|
|
gateSess.Send(int(server.SSPacketID_PACKET_GG_PLAYERSESSIONBIND), pack)
|
|
} else {
|
|
//进入房间失败
|
|
logger.Logger.Warnf("PACKET_WG_AUDIENCEENTER WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=<nil>", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
|
|
// 自建房检查观众人数上限
|
|
if scene.IsPreCreateScene() {
|
|
if len(scene.GetAudiences()) >= model.GameParamData.MaxAudienceNum {
|
|
sendLeave(common.PlayerLeaveReason_RoomFull)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
p := base.PlayerMgrSington.AddPlayer(sid, data, s, gateSess)
|
|
if p == nil {
|
|
//进入房间失败
|
|
sendLeave(common.PlayerLeaveReason_OnDestroy)
|
|
return nil
|
|
}
|
|
p.UnmarshalIParam(msg.GetIParams())
|
|
p.UnmarshalSParam(msg.GetSParams())
|
|
p.UnmarshalCParam(msg.GetCParams())
|
|
p.Coin = msg.GetTakeCoin()
|
|
p.SetTakeCoin(msg.GetTakeCoin())
|
|
p.LastSyncCoin = p.Coin
|
|
p.IsQM = IsQM
|
|
p.AppChannel = msg.GetAppChannel()
|
|
if scene != nil {
|
|
scene.AudienceEnter(p, isload)
|
|
if !p.IsRobot() && !scene.Testing {
|
|
//base.LogChannelSingleton.WriteMQData(model.GenerateEnterEvent(scene.GetRecordId(), p.SnId, p.Platform,
|
|
// p.DeviceOS, scene.GameId, scene.GameMode, scene.GetGameFreeId()))
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//观众坐下
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_AUDIENCESIT), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGAudienceSit{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_AUDIENCESIT), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive PACKET_WG_AUDIENCESIT WGAudienceSit", pack)
|
|
if msg, ok := pack.(*server.WGAudienceSit); ok {
|
|
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p != nil {
|
|
scene := p.GetScene()
|
|
if scene != nil {
|
|
p.Pos = int(msg.GetPos())
|
|
//p.coin = msg.GetTakeCoin()
|
|
//p.takeCoin = msg.GetTakeCoin()
|
|
if scene.Testing {
|
|
p.Coin = int64(scene.DbGameFree.GetTestTakeCoin())
|
|
}
|
|
p.LastSyncCoin = p.Coin
|
|
scene.AudienceSit(p)
|
|
}
|
|
} else {
|
|
leavePack := &server.GWPlayerLeave{
|
|
RoomId: msg.SceneId,
|
|
PlayerId: msg.SnId,
|
|
Reason: proto.Int(common.PlayerLeaveReason_Bekickout),
|
|
ReturnCoin: msg.TakeCoin,
|
|
}
|
|
proto.SetDefaults(leavePack)
|
|
s.Send(int(server.SSPacketID_PACKET_GW_AUDIENCELEAVE), leavePack)
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家返回房间
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERRETURN), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGPlayerReturn{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERRETURN), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGPlayerReturn")
|
|
if msg, ok := pack.(*server.WGPlayerReturn); ok {
|
|
playerId := msg.GetPlayerId()
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(playerId)
|
|
if p != nil {
|
|
oldFlag := p.GetFlag()
|
|
if !p.IsOnLine() {
|
|
p.MarkFlag(base.PlayerState_Online)
|
|
}
|
|
if p.IsMarkFlag(base.PlayerState_Leave) {
|
|
p.UnmarkFlag(base.PlayerState_Leave)
|
|
}
|
|
if p.GetFlag() != oldFlag {
|
|
p.SyncFlag()
|
|
}
|
|
if p.GetScene() != nil {
|
|
p.GetScene().PlayerReturn(p, msg.GetIsLoaded())
|
|
} else {
|
|
logger.Logger.Warnf("whern (%v) WGPlayerReturn p.scene == nil", playerId)
|
|
}
|
|
} else {
|
|
logger.Logger.Warnf("WGPlayerReturn found player:%v not exist", playerId)
|
|
scene := base.SceneMgrSington.GetScene(int(msg.GetRoomId()))
|
|
if scene != nil {
|
|
p := scene.GetPlayer(msg.GetPlayerId())
|
|
if p != nil {
|
|
logger.Logger.Warnf("WGPlayerReturn found player:%v not exist but in scene:%v gameid:%v", playerId, scene.SceneId, scene.GameId)
|
|
}
|
|
}
|
|
//TODO try leave from room
|
|
pack := &server.GWPlayerForceLeave{
|
|
RoomId: msg.RoomId,
|
|
PlayerId: msg.PlayerId,
|
|
Reason: proto.Int(common.PlayerLeaveReason_Bekickout),
|
|
EnterTs: msg.EnterTs,
|
|
}
|
|
proto.SetDefaults(pack)
|
|
s.Send(int(server.SSPacketID_PACKET_GW_PLAYERFORCELEAVE), pack)
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家掉线
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERDROPLINE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGPlayerDropLine{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERDROPLINE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGPlayerDropLine:", pack)
|
|
if msg, ok := pack.(*server.WGPlayerDropLine); ok {
|
|
sceneId := int(msg.GetSceneId())
|
|
scene := base.SceneMgrSington.GetScene(sceneId)
|
|
if scene != nil {
|
|
scene.PlayerDropLine(msg.GetId())
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家重连
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERREHOLD), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGPlayerRehold{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERREHOLD), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGPlayerRehold")
|
|
if msg, ok := pack.(*server.WGPlayerRehold); ok {
|
|
sceneId := int(msg.GetSceneId())
|
|
scene := base.SceneMgrSington.GetScene(sceneId)
|
|
if scene != nil {
|
|
var sessionId srvlib.SessionId
|
|
sessionId.Set(msg.GetGateSid())
|
|
gateSess := srvlib.ServerSessionMgrSington.GetSession(int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
|
|
logger.Logger.Tracef("WGPlayerRehold, AreaId=%v, SrvType=%v, SrvId=%v, SessionId=%v", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()), int64(sessionId))
|
|
if gateSess != nil {
|
|
pack := &server.GGPlayerSessionBind{
|
|
Sid: msg.Sid,
|
|
}
|
|
proto.SetDefaults(pack)
|
|
gateSess.Send(int(server.SSPacketID_PACKET_GG_PLAYERSESSIONBIND), pack)
|
|
}
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetId())
|
|
if p != nil {
|
|
base.PlayerMgrSington.ReholdPlayer(p.GetSid(), msg.GetSid(), gateSess)
|
|
scene.PlayerRehold(msg.GetId(), msg.GetSid(), gateSess)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//同步水池设置
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_COINPOOLSETTING), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &webapi.CoinPoolSetting{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_COINPOOLSETTING), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("CoinPoolSetting Process recv ", pack)
|
|
if wgCoinPoolSetting, ok := pack.(*webapi.CoinPoolSetting); ok {
|
|
base.CoinPoolMgr.UpdateCoinPoolSetting(wgCoinPoolSetting)
|
|
return nil
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 重置或修改水池水位
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_RESETCOINPOOL), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGResetCoinPool{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_RESETCOINPOOL), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("WGResetCoinPool Process recv ", pack)
|
|
if wgResetCoinPool, ok := pack.(*server.WGResetCoinPool); ok {
|
|
base.CoinPoolMgr.ResetCoinPool(wgResetCoinPool)
|
|
return nil
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//设置玩家黑白名单
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_SETPLAYERBLACKLEVEL), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGSetPlayerBlackLevel{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_SETPLAYERBLACKLEVEL), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("WGSetPlayerBlackLevel Process recv ", pack)
|
|
if wgSetPlayerBlackLevel, ok := pack.(*server.WGSetPlayerBlackLevel); ok {
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(wgSetPlayerBlackLevel.GetSnId())
|
|
if p != nil {
|
|
p.WBLevel = wgSetPlayerBlackLevel.GetWBLevel()
|
|
p.WBCoinLimit = wgSetPlayerBlackLevel.GetWBCoinLimit()
|
|
p.WBMaxNum = wgSetPlayerBlackLevel.GetMaxNum()
|
|
p.WBState = wgSetPlayerBlackLevel.GetState()
|
|
if wgSetPlayerBlackLevel.GetResetTotalCoin() {
|
|
p.WBCoinTotalIn = 0
|
|
p.WBCoinTotalOut = 0
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 修改服务状态
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_SERVER_STATE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.ServerState{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_SERVER_STATE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("PACKET_WG_SERVER_STATE Process recv ", pack)
|
|
if srvState, ok := pack.(*server.ServerState); ok {
|
|
base.ServerStateMgr.SetState(common.GameSessState(srvState.GetSrvState()))
|
|
return nil
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//邀请机器人进比赛
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_INVITEMATCHROB), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGInviteMatchRob{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_INVITEMATCHROB), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGInviteMatchRob:", pack)
|
|
if msg, ok := pack.(*server.WGInviteMatchRob); ok {
|
|
base.NpcServerAgentSingleton.MatchInvite(msg.GetRoomId(), msg.GetMatchId(), msg.GetPlatform(), msg.GetRobNum(), msg.GetNeedAwait())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家中转消息
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_SS_REDIRECTTOPLAYER), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.SSRedirectToPlayer{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_SS_REDIRECTTOPLAYER), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("SSRedirectToPlayer Process recv ", pack)
|
|
if msg, ok := pack.(*server.SSRedirectToPlayer); ok {
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p == nil {
|
|
logger.Logger.Trace("SSRedirectToPlayer Process recv p == nil ", msg.GetSnId())
|
|
return nil
|
|
}
|
|
p.SendToClient(int(msg.GetPacketId()), msg.GetData())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家离开
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PlayerLEAVE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGPlayerLeave{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PlayerLEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGPlayerLeaveGame")
|
|
if msg, ok := pack.(*server.WGPlayerLeave); ok {
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p != nil {
|
|
scene := p.GetScene()
|
|
if scene != nil {
|
|
scene.PlayerLeave(p, common.PlayerLeaveReason_DropLine, false)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//同步记牌器过期时间
|
|
netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_BUYRECTIMEITEM), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &server.WGBuyRecTimeItem{}
|
|
}))
|
|
netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_BUYRECTIMEITEM), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive WGBuyRecTimeItem")
|
|
if msg, ok := pack.(*server.WGBuyRecTimeItem); ok {
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p != nil {
|
|
p.UpdateBuyRecTimeItem(msg.ExpireTime, msg.Diamond)
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
}
|