789 lines
29 KiB
Go
789 lines
29 KiB
Go
package main
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"mongo.games.com/goserver/core/basic"
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/netlib"
|
|
"mongo.games.com/goserver/core/task"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/model"
|
|
"mongo.games.com/game/proto"
|
|
gamehallproto "mongo.games.com/game/protocol/gamehall"
|
|
loginproto "mongo.games.com/game/protocol/login"
|
|
playerproto "mongo.games.com/game/protocol/player"
|
|
serverproto "mongo.games.com/game/protocol/server"
|
|
"mongo.games.com/game/srvdata"
|
|
)
|
|
|
|
func init() {
|
|
// 销毁房间
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_DESTROYSCENE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWDestroyScene{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_DESTROYSCENE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive GWDestroyScene:", pack)
|
|
if msg, ok := pack.(*serverproto.GWDestroyScene); ok {
|
|
SceneMgrSingleton.DestroyScene(int(msg.GetSceneId()), msg.GetIsCompleted())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 离开房间
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERLEAVE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWPlayerLeave{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERLEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
if msg, ok := pack.(*serverproto.GWPlayerLeave); ok {
|
|
logger.Logger.Trace("receive GWPlayerLeave:", msg.GetPlayerId())
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
|
|
if scene != nil {
|
|
p := PlayerMgrSington.GetPlayerBySnId(msg.GetPlayerId())
|
|
if p != nil {
|
|
data := msg.GetPlayerData()
|
|
if len(data) != 0 {
|
|
logger.Logger.Trace("GWPlayerLeave p.UnmarshalData(data)")
|
|
p.UnmarshalData(data, scene)
|
|
}
|
|
switch {
|
|
case scene.IsCoinScene():
|
|
if !CoinSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
|
|
logger.Logger.Warnf("GWPlayerLeave snid:%v sceneid:%v gameid:%v modeid:%v [coinscene]",
|
|
p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
|
|
}
|
|
case scene.IsMatchScene():
|
|
if !MatchSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
|
|
logger.Logger.Warnf("GWPlayerLeave snid:%v sceneid:%v gameid:%v modeid:%v matchid:%v [matchscene]",
|
|
p.SnId, scene.sceneId, scene.gameId, scene.gameMode, scene.MatchSortId)
|
|
} else {
|
|
//结算积分
|
|
if !p.IsRob {
|
|
TournamentMgr.UpdateMatchInfo(p, msg.MatchId, int32(msg.GetReturnCoin()), int32(msg.GetCurIsWin()), msg.GetMatchRobotGrades())
|
|
} else {
|
|
p.matchCtx = nil
|
|
}
|
|
}
|
|
case scene.IsHundredScene():
|
|
if !HundredSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
|
|
logger.Logger.Warnf("GWPlayerLeave snid:%v sceneid:%v gameid:%v modeid:%v [hundredcene]",
|
|
p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
|
|
}
|
|
default:
|
|
scene.PlayerLeave(p, int(msg.GetReason()))
|
|
}
|
|
|
|
if p.scene != nil {
|
|
logger.Logger.Warnf("after GWPlayerLeave found snid:%v sceneid:%v gameid:%v modeid:%v", p.SnId, p.scene.sceneId, p.scene.gameId, p.scene.gameMode)
|
|
}
|
|
|
|
// 同步排位积分
|
|
if scene.IsRankMatch() {
|
|
if p.IsRob {
|
|
RankMgrSingleton.UpdateRobotSeason(p.Platform, p.SnId, scene.dbGameFree.GetRankType(),
|
|
msg.GetRankScore()[scene.dbGameFree.GetRankType()], p.Name, p.Sex, p.HeadUrl, p.Coin, p.PlayerData.GetRoleId())
|
|
} else {
|
|
if model.GameParamData.TestRankMatchAward {
|
|
if RankMgrSingleton.playerSeasons[p.SnId] != nil {
|
|
if RankMgrSingleton.playerSeasons[p.SnId].RankType == nil {
|
|
RankMgrSingleton.playerSeasons[p.SnId].RankType = make(map[int32]*model.PlayerRankInfo)
|
|
}
|
|
if RankMgrSingleton.playerSeasons[p.SnId].RankType[1] == nil {
|
|
RankMgrSingleton.playerSeasons[p.SnId].RankType[1] = &model.PlayerRankInfo{}
|
|
}
|
|
RankMgrSingleton.playerSeasons[p.SnId].RankType[1].LastScore = 7500
|
|
RankMgrSingleton.playerSeasons[p.SnId].RankType[1].Score = 7500
|
|
RankMgrSingleton.playerSeasons[p.SnId].RankType[1].Awards = nil
|
|
}
|
|
RankMgrSingleton.UpdatePlayerSeason(p.SnId, map[int32]int64{1: 10000})
|
|
} else {
|
|
RankMgrSingleton.UpdatePlayerSeason(p.SnId, msg.GetRankScore())
|
|
}
|
|
|
|
}
|
|
}
|
|
//更新玩家等级排行榜
|
|
LogChannelSingleton.WriteLog(&model.PlayerLevelInfo{
|
|
SnId: p.SnId,
|
|
Name: p.Name,
|
|
Level: p.Level,
|
|
Exp: p.Exp,
|
|
ModId: p.PlayerData.GetRoleId(),
|
|
Platform: p.Platform,
|
|
})
|
|
//比赛场不处理下面的内容
|
|
if !scene.IsMatchScene() && !scene.IsCustom() {
|
|
// 破产检测
|
|
sdata := srvdata.PBDB_GameSubsidyMgr.GetData(GameSubsidyid)
|
|
if sdata != nil {
|
|
if !p.IsRob && p.takeCoin > msg.GetReturnCoin() && p.takeCoin >= int64(sdata.LimitNum) && msg.GetReturnCoin() < int64(sdata.LimitNum) {
|
|
CostCoin := p.takeCoin - msg.GetReturnCoin()
|
|
|
|
logger.Logger.Infof("NewBankruptLogEx: snid:%v GetReturnCoin:%v coin:%v CostCoin:%v", p.SnId, msg.GetReturnCoin(), p.takeCoin, CostCoin)
|
|
log := model.NewBankruptLogEx(p.SnId, scene.dbGameFree.GetId(), p.CreateTime.Unix(), CostCoin, p.Platform, p.Channel, scene.gameId)
|
|
if log != nil {
|
|
LogChannelSingleton.WriteLog(log)
|
|
}
|
|
}
|
|
}
|
|
// 破产检测
|
|
|
|
oldCoin := p.Coin
|
|
|
|
//带回金币
|
|
if p.Coin != msg.GetReturnCoin() {
|
|
p.Coin = msg.GetReturnCoin()
|
|
if p.Coin < 0 {
|
|
p.Coin = 0
|
|
}
|
|
|
|
p.dirty = true
|
|
}
|
|
|
|
logger.Logger.Infof("SSPacketID_PACKET_GW_PLAYERLEAVE: snid:%v oldcoin:%v coin:%v", p.SnId, oldCoin, p.Coin)
|
|
p.diffData.Coin = -1 //强制更新金币
|
|
p.diffData.TotalConvertibleFlow = -1 //强制更新流水
|
|
p.SendDiffData() //只是把差异发给前端
|
|
|
|
gameCoinTs := msg.GetGameCoinTs()
|
|
if !p.IsRob && !scene.IsTestScene() {
|
|
//对账点同步
|
|
if p.GameCoinTs < gameCoinTs {
|
|
p.GameCoinTs = gameCoinTs
|
|
p.dirty = true
|
|
}
|
|
|
|
//破产统计
|
|
//if int(msg.GetReason()) == common.PlayerLeaveReason_Bekickout {
|
|
// if len(scene.paramsEx) > 0 {
|
|
// gameIdEx := scene.paramsEx[0]
|
|
// gps := PlatformMgrSingleton.GetGameFree(scene.limitPlatform.IdStr, scene.paramsEx[0])
|
|
// if gps != nil {
|
|
// lowLimit := gps.DbGameFree.GetLowerThanKick()
|
|
// if lowLimit != 0 && p.Coin+p.SafeBoxCoin < int64(lowLimit) {
|
|
// p.ReportBankRuptcy(int32(scene.gameId), int32(scene.gameMode), gameIdEx)
|
|
// }
|
|
// }
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Tracef("GWPlayerLeave LocalRobotIdMgrSington %v", msg.GetPlayerId())
|
|
//LocalRobotIdMgrSington.FreeId(msg.GetPlayerId())
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 观众离开房间
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_AUDIENCELEAVE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWPlayerLeave{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_AUDIENCELEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive PACKET_GW_AUDIENCELEAVE GWPlayerLeave:", pack)
|
|
if msg, ok := pack.(*serverproto.GWPlayerLeave); ok {
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
|
|
if scene != nil {
|
|
p := PlayerMgrSington.GetPlayerBySnId(msg.GetPlayerId())
|
|
if p != nil {
|
|
gameCoinTs := msg.GetGameCoinTs()
|
|
//带回的金币
|
|
if p.Coin != msg.GetReturnCoin() && !scene.IsMatchScene() {
|
|
p.Coin = msg.GetReturnCoin()
|
|
if p.Coin < 0 {
|
|
p.Coin = 0
|
|
}
|
|
p.dirty = true
|
|
}
|
|
|
|
//对账点同步
|
|
if p.GameCoinTs != gameCoinTs {
|
|
p.GameCoinTs = gameCoinTs
|
|
p.dirty = true
|
|
}
|
|
if scene.IsMatchScene() {
|
|
scene.AudienceLeave(p, int(msg.GetReason()))
|
|
} else {
|
|
CoinSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason()))
|
|
}
|
|
|
|
//变化金币
|
|
p.dirty = true
|
|
p.diffData.Coin = -1 //强制更新金币
|
|
p.diffData.TotalConvertibleFlow = -1 //强制更新流水
|
|
p.SendDiffData()
|
|
} else {
|
|
//LocalRobotIdMgrSington.FreeId(msg.GetPlayerId())
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 房间游戏开始
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_SCENESTART), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWSceneStart{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_SCENESTART), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GW_SCENESTART GWSceneStart:", pack)
|
|
if msg, ok := pack.(*serverproto.GWSceneStart); ok {
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
|
|
if scene != nil {
|
|
scene.starting = msg.GetStart()
|
|
scene.currRound = msg.GetCurrRound()
|
|
scene.totalRound = msg.GetMaxRound()
|
|
if scene.starting {
|
|
if scene.currRound == 1 {
|
|
scene.startTime = time.Now()
|
|
//p := PlayerMgrSington.GetPlayer(s.Sid)
|
|
}
|
|
}
|
|
if scene.starting {
|
|
logger.Logger.Trace("游戏开始------", scene.gameId, scene.sceneId, scene.replayCode, scene.currRound)
|
|
} else {
|
|
logger.Logger.Trace("游戏结束------", scene.gameId, scene.sceneId, scene.replayCode, scene.currRound)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 房间游戏状态
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_SCENESTATE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWSceneState{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_SCENESTATE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GW_SCENESTATE GWSceneState:", pack)
|
|
if msg, ok := pack.(*serverproto.GWSceneState); ok {
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
|
|
if scene != nil {
|
|
scene.sp.OnSceneState(scene, int(msg.GetRoomState()))
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 用户状态同步 flag
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERSTATE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWPlayerFlag{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERSTATE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive GWPlayerFlag:", pack)
|
|
if msg, ok := pack.(*serverproto.GWPlayerFlag); ok {
|
|
player := PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if player != nil {
|
|
player.flag = msg.GetFlag()
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 房间服务器状态切换
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GB_STATE_SWITCH), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.ServerStateSwitch{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GB_STATE_SWITCH), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GB_STATE_SWITCH ServerStateSwitch:", pack)
|
|
if sr, ok := pack.(*serverproto.ServerStateSwitch); ok {
|
|
srvid := int(sr.GetSrvId())
|
|
gameSess := GameSessMgrSington.GetGameSess(srvid)
|
|
if gameSess != nil {
|
|
if gameSess.state == common.GAME_SESS_STATE_ON {
|
|
gameSess.SwitchState(common.GAME_SESS_STATE_OFF)
|
|
} else {
|
|
gameSess.SwitchState(common.GAME_SESS_STATE_ON)
|
|
}
|
|
} else {
|
|
gateSess := GameSessMgrSington.GetGateSess(srvid)
|
|
if gateSess != nil {
|
|
if gateSess.state == common.GAME_SESS_STATE_ON {
|
|
gateSess.SwitchState(common.GAME_SESS_STATE_OFF)
|
|
} else {
|
|
gateSess.SwitchState(common.GAME_SESS_STATE_ON)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 游戏服务器的系统广播
|
|
// 捕鱼
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_NEWNOTICE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWNewNotice{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_NEWNOTICE), netlib.HandlerWrapper(func(s *netlib.Session,
|
|
packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive GWNewNotice:", pack)
|
|
if msg, ok := pack.(*serverproto.GWNewNotice); ok {
|
|
//立即发送改为定期发送，控制下广播包的频度
|
|
HorseRaceLampMgrSington.PushGameHorseRaceLamp(msg.GetCh(), msg.GetPlatform(), msg.GetContent(), int32(msg.GetMsgtype()), msg.GetIsrob(), msg.GetPriority())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 同步每局游戏那些玩家一起玩的
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_SCENEPLAYERLOG), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWScenePlayerLog{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_SCENEPLAYERLOG), netlib.HandlerWrapper(func(s *netlib.Session,
|
|
packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive GWScenePlayerLog:", pack)
|
|
if msg, ok := pack.(*serverproto.GWScenePlayerLog); ok {
|
|
sceneLimitMgr.ReceiveData(msg.GetGameId(), msg.GetSnids())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 强制离开房间
|
|
// 返回房间失败
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERFORCELEAVE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWPlayerForceLeave{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERFORCELEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
if msg, ok := pack.(*serverproto.GWPlayerForceLeave); ok {
|
|
logger.Logger.Warn("receive GWPlayerForceLeave:", msg)
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
|
|
if scene != nil {
|
|
p := PlayerMgrSington.GetPlayerBySnId(msg.GetPlayerId())
|
|
if p != nil {
|
|
ctx := scene.GetPlayerGameCtx(p.SnId)
|
|
if ctx != nil && p.scene == scene && scene.HasPlayer(p) && ctx.enterTs == msg.GetEnterTs() {
|
|
switch {
|
|
case scene.IsCoinScene():
|
|
if !CoinSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
|
|
logger.Logger.Warnf("GWPlayerForceLeave snid:%v sceneid:%v gameid:%v modeid:%v [coinscene]", p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
|
|
}
|
|
case scene.IsHundredScene():
|
|
if !HundredSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
|
|
logger.Logger.Warnf("GWPlayerForceLeave snid:%v sceneid:%v gameid:%v modeid:%v [hundredcene]", p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
|
|
}
|
|
case scene.IsMatchScene():
|
|
if !MatchSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
|
|
logger.Logger.Warnf("GWPlayerLeave snid:%v sceneid:%v gameid:%v modeid:%v matchid:%v [matchscene]",
|
|
p.SnId, scene.sceneId, scene.gameId, scene.gameMode, scene.MatchSortId)
|
|
}
|
|
default:
|
|
scene.PlayerLeave(p, int(msg.GetReason()))
|
|
}
|
|
|
|
if p.scene != nil {
|
|
logger.Logger.Warnf("after GWPlayerForceLeave found snid:%v sceneid:%v gameid:%v modeid:%v", p.SnId, p.scene.sceneId, p.scene.gameId, p.scene.gameMode)
|
|
p.scene.PlayerLeave(p, int(msg.GetReason()))
|
|
}
|
|
} else {
|
|
logger.Logger.Warnf("GWPlayerForceLeave snid:%v sceneid:%v gameid:%v modeid:%v fount not p.scene==scene && scene.HasPlayer(p)", p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
|
|
}
|
|
}
|
|
} else {
|
|
logger.Logger.Warnf("GWPlayerForceLeave snid:%v scene:%v had closed", msg.GetPlayerId(), msg.GetRoomId())
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//一局游戏一结算
|
|
//可处理以下业务
|
|
//1.同步玩家游戏场内的实时金币
|
|
//2.触发相关任务:统计有效下注金币数,赢取金币数,牌局次数等
|
|
//3.黑名单处理
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERDATA), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWPlayerData{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERDATA), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive GWPlayerBet:", pack)
|
|
if msg, ok := pack.(*serverproto.GWPlayerData); ok {
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetSceneId()))
|
|
if scene == nil {
|
|
return nil
|
|
}
|
|
for _, playerBet := range msg.GetDatas() {
|
|
player := PlayerMgrSington.GetPlayerBySnId(playerBet.GetSnId())
|
|
if player != nil && !player.IsRob {
|
|
// task 赢次数
|
|
if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeWinTimes, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
if scene.IsRankMatch() {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeRankMatchWinTimes, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
}
|
|
// 大众场
|
|
if common.IsDaZhong(scene.gameId) {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeDaZhong, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
}
|
|
}
|
|
// task 游戏局数
|
|
TaskSubjectSingleton.Touch(common.TaskTypePlayTimes, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
// task 排位赛次数
|
|
if scene.IsRankMatch() {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeRankMatchTimes, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
}
|
|
if !scene.IsMatchScene() { // 比赛没金币是积分
|
|
n := playerBet.GetGain()
|
|
if n < 0 {
|
|
n = -n
|
|
}
|
|
//游戏中输赢金币
|
|
TaskSubjectSingleton.Touch(common.TaskTypeWinOrLose, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: n,
|
|
})
|
|
// 游戏中赢金币
|
|
if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeWinCoin, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: playerBet.GetGain(),
|
|
})
|
|
}
|
|
if playerBet.GetGain() < 0 && playerBet.WinState != 1 {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeLoseCoin, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: playerBet.GetGain(),
|
|
})
|
|
}
|
|
}
|
|
//tienlen 游戏场次
|
|
if scene.dbGameFree.GameDif == common.GameDifTienlen {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeTienlenCount, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
//tienlen 游戏输的金币
|
|
if playerBet.GetGain() < 0 && playerBet.WinState != 1 {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeTienlenLoseCoin, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: playerBet.GetGain(),
|
|
})
|
|
}
|
|
// tienlen游戏中赢金币
|
|
if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeTienlenWinCoin, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: playerBet.GetGain(),
|
|
})
|
|
}
|
|
if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
|
|
TaskSubjectSingleton.Touch(common.TaskTypeTienlenWinTimes, &TaskData{
|
|
SnId: player.SnId,
|
|
GameID: scene.gameId,
|
|
GameFreeID: scene.dbGameFree.GetId(),
|
|
Num: 1,
|
|
})
|
|
}
|
|
}
|
|
|
|
if !scene.IsMatchScene() { // 比赛没金币是积分
|
|
player.Coin = playerBet.GetCoin()
|
|
player.GameCoinTs = playerBet.GetGameCoinTs()
|
|
player.GameTax += playerBet.GetTax()
|
|
player.dirty = true
|
|
player.WBUpdate(playerBet.GetWBGain())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//推送游戏的状态
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_GAMESTATE), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWGameState{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_GAMESTATE), netlib.HandlerWrapper(func(s *netlib.Session,
|
|
packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GW_GAMESTATE GWGameState:", pack)
|
|
if msg, ok := pack.(*serverproto.GWGameState); ok {
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetSceneId()))
|
|
if scene != nil {
|
|
scene.State = msg.GetState()
|
|
scene.StateSec = msg.GetSec()
|
|
//scene.BankerListNum = msg.GetBankerListNum()
|
|
if scene.State == scene.sp.GetBetState() {
|
|
scene.StateTs = msg.GetTs()
|
|
leftTime := int64(scene.StateSec) - (time.Now().Unix() - scene.StateTs)
|
|
if leftTime < 0 {
|
|
leftTime = 0
|
|
}
|
|
pack := &gamehallproto.SCGameState{}
|
|
pack.List = append(pack.List, &gamehallproto.GameState{
|
|
GameFreeId: proto.Int32(scene.dbGameFree.GetId()),
|
|
Ts: proto.Int64(leftTime),
|
|
Sec: proto.Int32(scene.StateSec),
|
|
})
|
|
gameStateMgr.BrodcastGameState(
|
|
int32(scene.gameId), scene.limitPlatform.IdStr, int(gamehallproto.GameHallPacketID_PACKET_SC_GAMESTATE), pack)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_JACKPOTLIST), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWGameJackList{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_JACKPOTLIST), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GW_JACKPOTLIST GWGameJackList:", pack)
|
|
if msg, ok := pack.(*serverproto.GWGameJackList); ok {
|
|
FishJackListMgr.Insert(msg.GetCoin(), msg.GetSnId(), msg.GetRoomId(), msg.GetJackType(), msg.GetGameId(),
|
|
msg.GetPlatform(), msg.GetChannel(), msg.GetName())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_JACKPOTCOIN), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWGameJackCoin{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_JACKPOTCOIN), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GW_JACKPOTCOIN GWGameJackCoin:", pack)
|
|
if msg, ok := pack.(*serverproto.GWGameJackCoin); ok {
|
|
for i, pl := range msg.Platform {
|
|
FishJackpotCoinMgr.Jackpot[pl] = msg.Coin[i]
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//强制换桌
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_CHANGESCENEEVENT), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.GWChangeSceneEvent{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_CHANGESCENEEVENT), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
|
|
logger.Logger.Trace("receive SSPacketID_PACKET_GW_CHANGESCENEEVENT GWChangeSceneEvent:", pack)
|
|
if msg, ok := pack.(*serverproto.GWChangeSceneEvent); ok {
|
|
scene := SceneMgrSingleton.GetScene(int(msg.GetSceneId()))
|
|
if scene != nil {
|
|
//scene.PlayerTryChange()
|
|
}
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
//玩家中转消息
|
|
netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_SS_REDIRECTTOPLAYER), netlib.PacketFactoryWrapper(func() interface{} {
|
|
return &serverproto.SSRedirectToPlayer{}
|
|
}))
|
|
netlib.RegisterHandler(int(serverproto.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.(*serverproto.SSRedirectToPlayer); ok {
|
|
p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
p.SendToClient(int(msg.GetPacketId()), msg.GetData())
|
|
}
|
|
return nil
|
|
}))
|
|
|
|
// 同步道具数量
|
|
netlib.Register(int(serverproto.SSPacketID_PACKET_PlayerChangeItems), &serverproto.PlayerChangeItems{}, HandlePlayerChangeItems)
|
|
}
|
|
|
|
func HandlePlayerChangeItems(session *netlib.Session, packetId int, data interface{}) error {
|
|
logger.Logger.Tracef("HandlePlayerChangeItems recv %v", data)
|
|
msg, ok := data.(*serverproto.PlayerChangeItems)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := 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(),
|
|
})
|
|
}
|
|
_, _, ok = BagMgrSingleton.AddItemsV2(&model.AddItemParam{
|
|
P: p.PlayerData,
|
|
Change: items,
|
|
NoLog: true,
|
|
})
|
|
if !ok {
|
|
logger.Logger.Errorf("HandlePlayerChangeItems add item failed %v", msg)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 机器人服务器向worldsrv发送
|
|
type CSPMCmdPacketFactory struct {
|
|
}
|
|
type CSPMCmdHandler struct {
|
|
}
|
|
|
|
func (this *CSPMCmdPacketFactory) CreatePacket() interface{} {
|
|
pack := &playerproto.CSPMCmd{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSPMCmdHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSPMCmdHandler Process recv ", data)
|
|
if msg, ok := data.(*playerproto.CSPMCmd); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Trace("CSPMCmdHandler p == nil")
|
|
return nil
|
|
}
|
|
|
|
if !p.IsRob && p.GMLevel < 3 {
|
|
logger.Logger.Trace("CSPMCmdHandler p.Channel != common.Channel_Rob && p.GMLevel < 3")
|
|
return nil
|
|
}
|
|
|
|
cmd := msg.GetCmd()
|
|
logger.Logger.Infof("CSPMCmdHandler %v %v", p.SnId, cmd)
|
|
args := strings.Split(cmd, common.PMCmd_SplitToken)
|
|
argsCnt := len(args)
|
|
if argsCnt != 0 {
|
|
switch args[0] {
|
|
case common.PMCmd_AddCoin:
|
|
if argsCnt > 1 {
|
|
coin, err := strconv.ParseInt(args[1], 10, 64) //strconv.Atoi(args[1])
|
|
if err != nil {
|
|
logger.Logger.Warnf("CSPMCmdHandler %v parse %v err:%v", p.SnId, cmd, err)
|
|
return nil
|
|
}
|
|
if coin != 0 {
|
|
p.CoinPayTotal += int64(coin)
|
|
p.dirty = true
|
|
p.AddCoin(coin, 0, common.GainWay_ByPMCmd, p.GetName(), cmd)
|
|
p.ReportSystemGiveEvent(int32(coin), common.GainWay_ByPMCmd, true)
|
|
p.SendDiffData()
|
|
}
|
|
}
|
|
case common.PMCmd_Privilege:
|
|
if p.GMLevel >= 3 {
|
|
if p.Flags&model.PLAYER_FLAGS_PRIVILEGE == 0 {
|
|
p.Flags |= model.PLAYER_FLAGS_PRIVILEGE
|
|
} else {
|
|
p.Flags &= ^model.PLAYER_FLAGS_PRIVILEGE
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CSRobotChgDataPacketFactory struct {
|
|
}
|
|
type CSRobotChgDataHandler struct {
|
|
}
|
|
|
|
func (this *CSRobotChgDataPacketFactory) CreatePacket() interface{} {
|
|
pack := &playerproto.CSRobotChgData{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSRobotChgDataHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSRobotChgDataHandler Process recv ", data)
|
|
if _, ok := data.(*playerproto.CSRobotChgData); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Trace("CSRobotChgDataHandler p == nil")
|
|
return nil
|
|
}
|
|
|
|
if !p.IsRob {
|
|
logger.Logger.Trace("CSRobotChgDataHandler !p.IsRob")
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CSAccountInvalidPacketFactory struct {
|
|
}
|
|
type CSAccountInvalidHandler struct {
|
|
}
|
|
|
|
func (this *CSAccountInvalidPacketFactory) CreatePacket() interface{} {
|
|
pack := &loginproto.CSAccountInvalid{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSAccountInvalidHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSAccountInvalidHandler Process recv ", data)
|
|
if _, ok := data.(*loginproto.CSAccountInvalid); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p != nil && p.IsRobot() {
|
|
snid := p.SnId
|
|
acc := p.AccountId
|
|
task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
|
|
err := model.RemoveAccount(p.Platform, acc)
|
|
if err != nil {
|
|
logger.Logger.Error("Remove robot account data error:", err)
|
|
}
|
|
err = model.RemovePlayerByAcc(p.Platform, acc)
|
|
if err != nil {
|
|
logger.Logger.Error("Remove robot player data error:", err)
|
|
}
|
|
logger.Logger.Trace("CSAccountInvalid message remove :", acc)
|
|
return nil
|
|
}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
|
|
PlayerMgrSington.DelPlayer(snid)
|
|
LoginStateMgrSington.DelAccountByAccid(acc)
|
|
return
|
|
}), "RemoveAccount").StartByFixExecutor("RemoveAccount")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
common.RegisterBoardCastHandler()
|
|
common.RegisterMulticastHandler()
|
|
|
|
common.RegisterHandler(int(playerproto.PlayerPacketID_PACKET_CS_PMCMD), &CSPMCmdHandler{})
|
|
netlib.RegisterFactory(int(playerproto.PlayerPacketID_PACKET_CS_PMCMD), &CSPMCmdPacketFactory{})
|
|
|
|
common.RegisterHandler(int(playerproto.PlayerPacketID_PACKET_CS_ROBOTCHGDATA), &CSRobotChgDataHandler{})
|
|
netlib.RegisterFactory(int(playerproto.PlayerPacketID_PACKET_CS_ROBOTCHGDATA), &CSRobotChgDataPacketFactory{})
|
|
|
|
common.RegisterHandler(int(loginproto.LoginPacketID_PACKET_CS_ACCOUNTINVALID), &CSAccountInvalidHandler{})
|
|
netlib.RegisterFactory(int(loginproto.LoginPacketID_PACKET_CS_ACCOUNTINVALID), &CSAccountInvalidPacketFactory{})
|
|
}
|