573 lines
20 KiB
Go
573 lines
20 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 HandleWGUpdateSkin(session *netlib.Session, packetId int, data interface{}) error {
|
|
logger.Logger.Trace("receive WGUpdateSkin")
|
|
msg, ok := data.(*server.WGUpdateSkin)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
p.Skin.ModId = msg.GetId()
|
|
return nil
|
|
}
|
|
|
|
func HandleWGBuyRecTimeItem(session *netlib.Session, packetId int, data interface{}) error {
|
|
logger.Logger.Trace("receive WGBuyRecTimeItem")
|
|
if msg, ok := data.(*server.WGBuyRecTimeItem); ok {
|
|
p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p != nil {
|
|
p.UpdateBuyRecTimeItem(msg.ExpireTime, msg.Diamond)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//func HandleWGPlayerLeave(session *netlib.Session, packetId int, data interface{}) error {
|
|
// logger.Logger.Trace("receive WGPlayerLeaveGame")
|
|
// if msg, ok := data.(*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
|
|
//}
|
|
|
|
//func HandlePlayerChangeItems(session *netlib.Session, packetId int, data interface{}) error {
|
|
// logger.Logger.Tracef("receive PlayerChangeItems %v", data)
|
|
// msg, ok := data.(*server.PlayerChangeItems)
|
|
// if !ok {
|
|
// return nil
|
|
// }
|
|
// p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
// if p == nil {
|
|
// return nil
|
|
// }
|
|
// var items []*model.Item
|
|
// for _, v := range msg.GetItems() {
|
|
// items = append(items, &model.Item{
|
|
// ItemId: v.GetId(),
|
|
// ItemNum: v.GetNum(),
|
|
// })
|
|
// }
|
|
// p.ReceiveAddItems(items)
|
|
// return nil
|
|
//}
|
|
|
|
func CreateScene(session *netlib.Session, packetId int, data interface{}) error {
|
|
logger.Logger.Tracef("receive CreateScene %v", data)
|
|
msg, ok := data.(*server.WGCreateScene)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
base.SceneMgrSington.CreateScene(&base.CreateSceneParam{
|
|
Session: session,
|
|
WGCreateScene: msg,
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func DestroyScene(session *netlib.Session, packetId int, data interface{}) error {
|
|
logger.Logger.Trace("receive WGDestroyScene:", data)
|
|
msg, ok := data.(*server.WGDestroyScene)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if !msg.IsGrace {
|
|
// 立刻删除，不管游戏是否结束
|
|
for _, v := range msg.Ids {
|
|
s := base.SceneMgrSington.GetScene(int(v))
|
|
if s == nil {
|
|
continue
|
|
}
|
|
if gameScene, ok := s.ExtraData.(base.GameScene); ok {
|
|
gameScene.SceneDestroy(true)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 游戏结束后删除房间
|
|
for _, v := range msg.Ids {
|
|
s := base.SceneMgrSington.GetScene(int(v))
|
|
if s == nil {
|
|
continue
|
|
}
|
|
if s.IsHundredScene() || s.Gaming {
|
|
s.SetGraceDestroy()
|
|
} else {
|
|
if s.IsMatchScene() {
|
|
s.SetGraceDestroy()
|
|
}
|
|
if gameScene, ok := s.ExtraData.(base.GameScene); ok {
|
|
gameScene.SceneDestroy(true)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
// 创建房间
|
|
netlib.Register(int(server.SSPacketID_PACKET_WG_CREATESCENE), &server.WGCreateScene{}, CreateScene)
|
|
// 删除房间
|
|
netlib.Register(int(server.SSPacketID_PACKET_WG_DESTROYSCENE), &server.WGDestroyScene{}, DestroyScene)
|
|
|
|
//玩家进入
|
|
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
|
|
|
|
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.GetDBGameFree().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
|
|
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.GetDBGameFree().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.Register(int(server.SSPacketID_PACKET_WG_PlayerLEAVE), server.WGPlayerLeave{}, HandleWGPlayerLeave)
|
|
// 同步记牌器过期时间
|
|
netlib.Register(int(server.SSPacketID_PACKET_WG_BUYRECTIMEITEM), server.WGBuyRecTimeItem{}, HandleWGBuyRecTimeItem)
|
|
// 修改皮肤
|
|
netlib.Register(int(server.SSPacketID_PACKET_WG_UpdateSkin), server.WGUpdateSkin{}, HandleWGUpdateSkin)
|
|
// 同步道具数量
|
|
//netlib.Register(int(server.SSPacketID_PACKET_PlayerChangeItems), server.PlayerChangeItems{}, HandlePlayerChangeItems)
|
|
}
|