common/clock.go

@@ -250,7 +250,6 @@ func RegisterClockFunc(fs *ClockFunc) {
 	if fs == nil {
 		return
 	}
-
 	if fs.OnSecTimerFunc != nil {
 		fs.event = fs.event | 1<<ClockEventSecond
 	}
@@ -273,9 +272,5 @@ func RegisterClockFunc(fs *ClockFunc) {
 		fs.event = fs.event | 1<<ClockEventShutdown
 	}
 
-	if fs.event == 0 {
-		return
-	}
-
 	ClockMgrSingleton.RegisterSinker(fs)
 }

common/constant.go

@@ -899,6 +899,6 @@ var GuideIdToGainWay = map[int]int{
 	GuideIdCustom:    GainWayGuide2,
 }
 
-func GetKeyGameDif(gamedif string) string {
+func GetGameDifKey(gamedif string) string {
 	return fmt.Sprintf("gamedif-%v", gamedif)
 }

gamerule/thirteen/constants.go

@@ -35,7 +35,6 @@ const (
 	ThirteenWaterPlayerOpReset   = 4 // 重新选牌
 	ThirteenWaterPlayerJoin      = 5 // 加入游戏
 	ThirteenWaterPlayerOpSelect  = 6 // 预选牌
-	ThirteenWaterPlayerOpAuto    = 7 // 自动摆牌 1自动 2手动
 )
 const (
 	ThirteenWaterSceneWaitTimeout = time.Second * 2  //等待倒计时

gamesrv/base/player.go

@@ -653,12 +653,6 @@ func (this *Player) ReportGameEvent(param *ReportGameEventParam) *ReportGameEven
 		gameTimes = dataGame.Statics.GameTimes
 	}
 
-	dataGameDif, ok := this.GDatas[common.GetKeyGameDif(this.scene.GetDBGameFree().GetGameDif())]
-	if ok {
-		gamedifFirstTime = dataGameDif.FirstTime
-		gamedifTimes = dataGameDif.Statics.GameTimes
-	}
-
 	isNew := int32(0)
 	tCreateDay := now.New(this.CreateTime.Local()).BeginningOfDay()
 	if now.BeginningOfDay().Equal(tCreateDay) {

gamesrv/base/scene.go

@@ -2111,7 +2111,7 @@ func (this *Scene) Statistics(param *StaticParam) {
 	var statics []*model.PlayerGameStatics
 	keyGameId := strconv.Itoa(this.GetGameId())
 	keyGameFreeId := strconv.Itoa(int(this.GetGameFreeId()))
-	keyGameDif := common.GetKeyGameDif(this.GetDBGameFree().GetGameDif())
+	keyGameDif := common.GetGameDifKey(this.GetDBGameFree().GetGameDif())
 	// 当天数据统计
 	// 按场次分
 	if data, ok := p.TodayGameData.CtrlData[keyGameFreeId]; ok {
@@ -2350,7 +2350,7 @@ func (this *Scene) StaticsLaba(param *StaticLabaParam) {
 	var statics []*model.PlayerGameStatics
 	keyGameId := strconv.Itoa(this.GetGameId())
 	keyGameFreeId := strconv.Itoa(int(this.GetGameFreeId()))
-	keyGameDif := common.GetKeyGameDif(this.GetDBGameFree().GetGameDif())
+	keyGameDif := common.GetGameDifKey(this.GetDBGameFree().GetGameDif())
 	// 当天数据统计
 	// 按场次分
 	if data, ok := p.TodayGameData.CtrlData[keyGameFreeId]; ok {

gamesrv/thirteen/player.go

@@ -1,8 +1,6 @@
 package thirteen
 
 import (
-	"time"
-
 	"mongo.games.com/goserver/core/logger"
 
 	"mongo.games.com/game/gamerule/thirteen"
@@ -27,10 +25,7 @@ type PlayerEx struct {
 	odds          int32
 	totalScore    int64
 	defGroup      *thirteen.Group
-	playerPool    int           // 个人水池分
+	playerPool    int // 个人水池分
-	AutoState     int           // 是否自动模式
-	AutoMill      time.Duration // 自动时长
-	HandMill      time.Duration // 手动时长
 }
 
 func (this *PlayerEx) Clear() {
@@ -47,9 +42,6 @@ func (this *PlayerEx) Clear() {
 	this.gainCoin = 0
 	this.taxCoin = 0
 	this.deterMine = false
-	this.AutoState = 0
-	this.AutoMill = time.Duration(0)
-	this.HandMill = time.Duration(0)
 	this.score = [7]int64{0, 0, 0, 0, 0, 0, 0}
 	this.tableScore = [6]int64{}
 	this.winThreePos = make(map[int]int64)

gamesrv/thirteen/scene.go

@@ -86,7 +86,6 @@ type SceneEx struct {
 	ctrlType        int // 1控赢 2控输 0不控
 	cardsArr        [][13]int
 	cardsGroup      []map[int]*rule.Group
-	timestamp       time.Time
 }
 
 func NewThirteenWaterSceneData(s *base.Scene) *SceneEx {

gamesrv/thirteen/scenepolicy.go

@@ -4,7 +4,6 @@ import (
 	"strconv"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"mongo.games.com/goserver/core"
 	"mongo.games.com/goserver/core/logger"
 
@@ -12,7 +11,6 @@ import (
 	rule "mongo.games.com/game/gamerule/thirteen"
 	"mongo.games.com/game/gamesrv/base"
 	"mongo.games.com/game/model"
-	"mongo.games.com/game/mq"
 	"mongo.games.com/game/proto"
 	"mongo.games.com/game/protocol/thirteen"
 )
@@ -810,11 +808,6 @@ func (this *StateOp) OnEnter(s *base.Scene) {
 	logger.Logger.Tracef("(this *StateOp) OnEnter, sceneid=%v", s.GetSceneId())
 	this.BaseState.OnEnter(s)
 	ThirteenWaterBroadcastRoomState(s)
-	sceneEx, ok := s.ExtraData.(*SceneEx)
-	if !ok {
-		return
-	}
-	sceneEx.timestamp = time.Now()
 }
 
 // 玩家操作
@@ -833,34 +826,38 @@ func (this *StateOp) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, param
 		return false
 	}
 
-	returnFunc := func(code thirteen.OpResultCode, broadcast bool) {
+	returnFunc := func(code thirteen.OpResultCode) {
 		pack := &thirteen.SCThirteenPlayerOp{
 			OpRetCode: code,
 			OpCode:    int32(opcode),
 			OpParam:   params,
 			Pos:       int32(playerEx.GetPos()),
 		}
-		if broadcast {
+		if code == thirteen.OpResultCode_OPRC_Error {
-			playerEx.Broadcast(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerOp), pack, 0)
+			proto.SetDefaults(pack)
-		} else {
+			logger.Logger.Trace("SCThirteenPlayerOp:", pack)
 			playerEx.SendToClient(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerOp), pack)
+			return
 		}
-		logger.Logger.Trace("SCThirteenPlayerOp:", pack)
 	}
 
 	if !playerEx.IsGameing() {
-		returnFunc(thirteen.OpResultCode_OPRC_Error, false)
+		returnFunc(thirteen.OpResultCode_OPRC_Error)
 		return true
 	}
 
 	switch opcode {
 	case rule.ThirteenWaterPlayerOpMS: //确定牌
+		//if playerEx.deterMine { // 确认牌型
+		//	returnFunc(thirteen.OpResultCode_OPRC_Error)
+		//	return false
+		//}
 		if len(params) == 13 {
 			//校验牌
 			a := rule.DelCards(playerEx.cards[:], common.Int64Toint(params))
 			if len(a) != 0 {
 				logger.Logger.Error("the cards is error.")
-				returnFunc(thirteen.OpResultCode_OPRC_Error, false)
+				returnFunc(thirteen.OpResultCode_OPRC_Error)
 				return true
 			}
 			//牌赋值
@@ -876,7 +873,6 @@ func (this *StateOp) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, param
 		playerEx.Trusteeship = 0
 		playerEx.UnmarkFlag(base.PlayerState_Auto)
 		playerEx.deterMine = true
-		playerEx.AutoState = 0
 		//如果所有玩家都确认牌之后 可以直接开始下一阶段
 		a := true
 		for _, v := range sceneEx.players {
@@ -896,70 +892,38 @@ func (this *StateOp) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, param
 		playerEx.cardsO = &rule.Group{Head: [3]int{-1, -1, -1}, Mid: [5]int{-1, -1, -1, -1, -1}, End: [5]int{-1, -1, -1, -1, -1}, PokerType: -1}
 		playerEx.Trusteeship = 0
 		playerEx.UnmarkFlag(base.PlayerState_Auto)
+		pack := &thirteen.SCThirteenPlayerOp{
+			OpRetCode: thirteen.OpResultCode_OPRC_Sucess,
+			OpCode:    int32(opcode),
+			OpParam:   params,
+			Pos:       int32(playerEx.GetPos()),
+		}
 		if len(params) == 13 {
 			//校验牌
-			remain := len(playerEx.cards)
+			a := rule.DelCards(playerEx.cards[:], common.Int64Toint(params))
-			remainCards := make([]int, remain)
+			if len(a) != 0 {
-			copy(remainCards, playerEx.cards[:])
+				logger.Logger.Error("the cards is error.")
-			for _, v := range params {
+				returnFunc(thirteen.OpResultCode_OPRC_Error)
-				if v >= 0 {
+				return true
-					a := rule.DelCards(remainCards, []int{int(v)})
-					if len(a) == remain {
-						logger.Logger.Error("the cards is error.")
-						returnFunc(thirteen.OpResultCode_OPRC_Error, false)
-						return true
-					}
-					remain = len(a)
-					remainCards = a
-				}
 			}
-
 			//牌赋值
 			copy(playerEx.preCardsO.Head[:], common.Int64Toint(params[:3]))
 			copy(playerEx.preCardsO.Mid[:], common.Int64Toint(params[3:8]))
 			copy(playerEx.preCardsO.End[:], common.Int64Toint(params[8:]))
 			playerEx.preCardsO.PokerType = 0
-
-			for k, v := range playerEx.preCardsO.Head {
-				if v < 0 {
-					playerEx.preCardsO.Head[k] = remainCards[0]
-					remainCards = remainCards[1:]
-				}
-			}
-			for k, v := range playerEx.preCardsO.Mid {
-				if v < 0 {
-					playerEx.preCardsO.Mid[k] = remainCards[0]
-					remainCards = remainCards[1:]
-				}
-			}
-			for k, v := range playerEx.preCardsO.End {
-				if v < 0 {
-					playerEx.preCardsO.End[k] = remainCards[0]
-					remainCards = remainCards[1:]
-				}
-			}
 		}
-
+		playerEx.SendToClient(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerOp), pack)
-		if len(params) == 1 {
-			sceneEx.SelectCards(playerEx, int(params[0]))
-		}
-
-		if len(params) == 0 {
-			playerEx.preCardsO = &rule.Group{Head: [3]int{-1, -1, -1}, Mid: [5]int{-1, -1, -1, -1, -1}, End: [5]int{-1, -1, -1, -1, -1}, PokerType: -1}
-		}
-		returnFunc(thirteen.OpResultCode_OPRC_Sucess, true)
 
 	case rule.ThirteenWaterPlayerOpReset:
 		// 取消确认
 		playerEx.deterMine = false
-		returnFunc(thirteen.OpResultCode_OPRC_Sucess, true)
+		pack := &thirteen.SCThirteenPlayerOp{
-
+			OpRetCode: thirteen.OpResultCode_OPRC_Sucess,
-	case rule.ThirteenWaterPlayerOpAuto:
+			OpCode:    int32(opcode),
-		if len(params) == 0 {
+			OpParam:   params,
-			return true
+			Pos:       int32(playerEx.GetPos()),
 		}
-
+		playerEx.Broadcast(int(thirteen.TWMmoPacketID_PACKET_SCThirteenPlayerOp), pack, 0)
-		playerEx.AutoState = int(params[0])
 
 	default:
 		return false
@@ -977,19 +941,6 @@ func (this *StateOp) OnLeave(s *base.Scene) {
 
 	for _, player := range sceneEx.players {
 		if player != nil && player.IsGameing() {
-
-			if !player.IsRobot() {
-				mq.Write(model.ThirteenAutoLog{
-					Id:       primitive.NewObjectID().Hex(),
-					Platform: player.Platform,
-					LogId:    sceneEx.logid,
-					SnId:     player.SnId,
-					AutoTime: player.AutoMill.Milliseconds(),
-					HandTime: player.HandMill.Milliseconds(),
-					Ts:       time.Now().Unix(),
-				}, mq.BackThirteenAutoLog)
-			}
-
 			// 使用预选牌
 			if player.preCardsO != nil && player.preCardsO.PokerType != -1 && (player.cardsO == nil || player.cardsO.PokerType == -1) {
 				player.cardsO = player.preCardsO
@@ -1169,23 +1120,7 @@ func (this *StateOp) OnLeave(s *base.Scene) {
 func (this *StateOp) OnTick(s *base.Scene) {
 	this.BaseState.OnTick(s)
 	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
-		now := time.Now()
+		if time.Now().Sub(sceneEx.StateStartTime) > sceneEx.GetBaiPai() {
-		addTime := now.Sub(sceneEx.timestamp)
-		for _, v := range sceneEx.seats {
-			if v != nil && v.IsGameing() {
-				switch v.AutoState {
-				case 2:
-					v.AutoMill += addTime
-				case 1:
-					v.HandMill += addTime
-				default:
-
-				}
-			}
-		}
-		sceneEx.timestamp = now
-
-		if now.Sub(sceneEx.StateStartTime) > sceneEx.GetBaiPai() {
 			s.ChangeSceneState(rule.ThirteenWaterSceneStateShowCards)
 		}
 	}

gamesrv/tienlen/scenedata_tienlen.go

@@ -1298,20 +1298,24 @@ func (this *TienLenSceneData) SendHandCardOdds() {
 			allcs[i], allcs[j] = allcs[j], allcs[i]
 		})
 
-		allcs = common.DelSliceIn32s(allcs, this.testPokers[1:])
+		if len(this.testPokers) > 14 {
-		this.testPokers = append(this.testPokers, allcs...)
+			this.testPokers = this.testPokers[:14]
-
-		for _, seat := range this.seats {
-			if seat != nil && seat.IsGameing() && seat.SnId == this.testPokers[0] {
-				f1(seat, this.testPokers[1:14])
-				this.testPokers = this.testPokers[14:]
-				break
-			}
 		}
+		if len(this.testPokers) < 14 {
+			allcs = common.DelSliceIn32s(allcs, this.testPokers[1:])
+			this.testPokers = append(this.testPokers, allcs[:14-len(this.testPokers)]...)
+			allcs = allcs[14-len(this.testPokers):]
+		}
+
+		allcs = common.DelSliceIn32s(allcs, this.testPokers[1:])
 		for _, seat := range this.seats {
-			if seat != nil && seat.IsGameing() && seat.cards[0] == rule.InvalideCard {
+			if seat != nil && seat.IsGameing() {
-				f1(seat, this.testPokers[:13])
+				if seat.SnId == this.testPokers[0] {
-				this.testPokers = this.testPokers[13:]
+					f1(seat, this.testPokers[1:])
+				} else {
+					f1(seat, allcs[:13])
+					allcs = allcs[13:]
+				}
 			}
 		}
 		this.testPokers = nil

model/bankruptlog.go

@@ -8,11 +8,9 @@ type BankruptLog struct {
 	LogId      bson.ObjectId `bson:"_id"`
 	SnId       int32         //玩家id
 	Channel    string        // 渠道
-	ChannelId  string        // 推广渠道
 	Platform   string        //平台名称
 	GameId     int           //游戏id
 	GameFreeID int32         //房间id
-	GameDif    string        // 游戏分组
 
 	CreateTime int64 // 注册时间
 	UseCoin    int64 // 消耗金币
@@ -24,14 +22,12 @@ func NewBankruptLog() *BankruptLog {
 	return log
 }
 
-func NewBankruptLogEx(snid int32, gamefreeid int32, createtime, usecoin int64, platform, channel, channelId, gamedif string, gameId int) *BankruptLog {
+func NewBankruptLogEx(snid int32, gamefreeid int32, createtime, usecoin int64, platform, channel string, gameId int) *BankruptLog {
 	cl := NewBankruptLog()
 	cl.SnId = snid
 	cl.Platform = platform
 	cl.Channel = channel
-	cl.ChannelId = channelId
 	cl.GameId = gameId
-	cl.GameDif = gamedif
 
 	cl.GameFreeID = gamefreeid
 	cl.CreateTime = createtime

model/player.go

@@ -1262,11 +1262,9 @@ func SavePlayerData(pd *PlayerData) bool {
 	}
 	if pd != nil {
 		var ret bool
-		t1 := time.Now()
 		err := rpcCli.CallWithTimeout("PlayerDataSvc.SavePlayerData", pd, &ret, time.Second*30)
 		if err != nil {
-			logger.Logger.Errorf("SavePlayerData %v cost:%v fail err:%v PlayerData:%+v",
+			logger.Logger.Errorf("SavePlayerData %v err:%v", pd.SnId, err)
-				pd.SnId, time.Now().Sub(t1), err, *pd)
 			return false
 		}
 		return ret

model/rabbit_mq.go

@@ -15,13 +15,6 @@ func GenerateOnline(online map[string]map[string]int) *mq.RabbitMQData {
 	return NewRabbitMQData(mq.BackOnline, params)
 }
 
-func GenerateOnlineGame(online map[string]map[string]map[string]map[int]map[int]int) *mq.RabbitMQData {
-	params := make(map[string]interface{})
-	params["Online"] = online
-	params["Time"] = time.Now().Unix()
-	return NewRabbitMQData(mq.BackOnlineGame, params)
-}
-
 // GenerateLogin 玩家登陆事件
 func GenerateLogin(o *PlayerLoginEvent) *mq.RabbitMQData {
 	return NewRabbitMQData(mq.BackLogin, o)

model/thirteen.go

@@ -1,11 +0,0 @@
-package model
-
-type ThirteenAutoLog struct {
-	Id       string `gorm:"primaryKey"`
-	Platform string `gorm:"-"`
-	LogId    string `gorm:"index;column:logid"`
-	SnId     int32  `gorm:"index;column:snid"`
-	AutoTime int64  // 自动时长，毫秒
-	HandTime int64  // 手动时长，毫秒
-	Ts       int64
-}

mq/export.go

@@ -55,18 +55,18 @@ type RabbitMQData struct {
 	Data   interface{}
 }
 
-func (c *MessageMgr) Send(data interface{}, name string, options ...broker.PublishOption) error {
+func (c *MessageMgr) Send(data interface{}, name ...string) error {
 	if msg, ok := data.(*RabbitMQData); ok {
-		return Send(msg.MQName, msg.Data, options...)
+		return Send(msg.MQName, msg.Data)
 	}
-	if len(name) > 0 {
+	if len(name) > 0 && name[0] != "" {
-		return Send(name, data, options...)
+		return Send(name[0], data)
 	}
 	key := c.getName(data)
 	if key == "" {
 		key = "_null_"
 	}
-	return Send(key, data, options...)
+	return Send(key, data)
 }
 
 type RegisterHandlerParam struct {
@@ -132,14 +132,7 @@ func RegisterMessage(param *RegisterMessageParam) {
 // Write 发送消息
 // 默认队列名称规则：队列前缀_消息结构体名称
 func Write(data interface{}, name ...string) error {
-	if len(name) > 0 && name[0] != "" {
+	return MessageMgrSingle.Send(data, name...)
-		return MessageMgrSingle.Send(data, name[0])
-	}
-	return MessageMgrSingle.Send(data, "")
-}
-
-func WriteWithOptions(data interface{}, name string, opts ...broker.PublishOption) error {
-	return MessageMgrSingle.Send(data, name, opts...)
 }
 
 // RegisterHandler 注册消息处理函数

mq/keyconf.go

@@ -18,14 +18,11 @@ const (
 	BackSystemPermitTask     = "back_permittask"
 	BackSystemJyb            = "back_jyblog"
 	BackActivityLog          = "back_activitylog"
-	BackOnlineGame           = "back_onlinegame"
 )
 
-// go后端
+// mgrsrv
 
-const (
+const ()
-	BackThirteenAutoLog = "b_thirteenautolog"
-)
 
 // worldsrv 消息
 

protocol/thirteen/thirteen.pb.go

@@ -386,7 +386,7 @@ type CSThirteenPlayerOp struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	OpCode int32 `protobuf:"varint,1,opt,name=OpCode,proto3" json:"OpCode,omitempty"` // 1:确定牌 2站起状态 3test 4重新选牌 5加入游戏 6预选 7自动手动切换(1自动，2手动)
+	OpCode int32 `protobuf:"varint,1,opt,name=OpCode,proto3" json:"OpCode,omitempty"` // 1:确定牌 2站起状态 3test 4重新选牌 5加入游戏 6预选
 	// 确定牌时，两种参数规则,都可以
 	// 第一种：玩家从推荐牌型中选择一个，把Poker.IndexType发过来（减少数据传输）
 	// 第二种：按头墩中墩尾墩顺序把牌发过来

protocol/thirteen/thirteen.proto

@@ -73,7 +73,7 @@ message SCThirteenPlayerCards {
 //玩家操作
 //PACKET_CSThirteenPlayerOp
 message CSThirteenPlayerOp {
-    int32 OpCode = 1; // 1:确定牌 2站起状态 3test 4重新选牌 5加入游戏 6预选 7自动手动切换(1自动，2手动)
+    int32 OpCode = 1; // 1:确定牌 2站起状态 3test 4重新选牌 5加入游戏 6预选
 
     // 确定牌时，两种参数规则,都可以
     // 第一种：玩家从推荐牌型中选择一个，把Poker.IndexType发过来（减少数据传输）

statistics/etc/config.yaml

@@ -24,9 +24,4 @@ update_invite_num: 30
 # 几秒读取一次道具日志
 update_second_item: 10
 # 一次最多读取多少道具日志
-update_item_num: 100
+update_item_num: 100
-
-# rabbitmq配置
-rabbitmq:
-  url: amqp://win88:123456@127.0.0.1:5672/win99
-  exchange: win99

statistics/main.go

@@ -15,10 +15,9 @@ import (
 	"mongo.games.com/goserver/core/utils"
 	"mongo.games.com/goserver/core/viperx"
 
-	"mongo.games.com/game/mq"
 	mongomodel "mongo.games.com/game/statistics/modelmongo"
 	mysqlmodel "mongo.games.com/game/statistics/modelmysql"
-	_ "mongo.games.com/game/statistics/mq"
+	"mongo.games.com/game/statistics/static"
 	"mongo.games.com/game/statistics/syn"
 )
 
@@ -93,32 +92,26 @@ func main() {
 
 	mysqlx.SetAutoMigrateTables(mysqlmodel.Tables)
 
-	// mq
-	mq.StartConsumer(VP.GetString("rabbitmq.url"), VP.GetString("rabbitmq.exchange"), true)
-
 	wg := &sync.WaitGroup{}
 	ctx, cancel := context.WithCancel(context.Background())
 
-	// 同步注册和登录日志
 	DoTick(ctx, wg, time.Duration(VP.GetInt64("update_second"))*time.Second, SyncSnId)
 
-	//DoTick(ctx, wg, time.Duration(VP.GetInt64("update_second_snid"))*time.Second, func(ctx context.Context) {
+	DoTick(ctx, wg, time.Duration(VP.GetInt64("update_second_snid"))*time.Second, func(ctx context.Context) {
-	//	wg := new(sync.WaitGroup)
+		wg := new(sync.WaitGroup)
-	//	for _, v := range VP.GetStringSlice("platforms") {
+		for _, v := range VP.GetStringSlice("platforms") {
-	//		platform := v
+			platform := v
-	//		wg.Add(1)
+			wg.Add(1)
-	//		go func() {
+			go func() {
-	//			defer wg.Done()
+				defer wg.Done()
-	//			Static(platform)
+				Static(platform)
-	//		}()
+			}()
-	//	}
+		}
-	//	wg.Wait()
+		wg.Wait()
-	//})
+	})
 
-	// 同步邀请数据
 	DoTick(ctx, wg, time.Duration(VP.GetInt64("update_second_invite"))*time.Second, SyncInvite)
 
-	// 同步道具日志数据
 	DoTickPlatform(ctx, wg, time.Duration(VP.GetInt64("update_second_item"))*time.Second, VP.GetInt("update_item_num"),
 		func(ctx context.Context, platform string, batchSize int) {
 			err := syn.ItemGainDone(&syn.Data[mongomodel.ItemLog]{
@@ -130,7 +123,7 @@ func main() {
 			}
 		})
 
-	logger.Logger.Info("start success")
+	logger.Logger.Info("start")
 
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, os.Kill)
@@ -169,36 +162,36 @@ func SyncSnId(ctx context.Context) {
 }
 
 // Static 玩家id触发数据统计
-//func Static(platform string) {
+func Static(platform string) {
-//	// 查询需要更新的玩家id
+	// 查询需要更新的玩家id
-//	var ids []*mysqlmodel.UserID
+	var ids []*mysqlmodel.UserID
-//	db, err := mysqlx.GetDatabase(platform)
+	db, err := mysqlx.GetDatabase(platform)
-//	if err != nil {
+	if err != nil {
-//		logger.Logger.Errorf("GetDatabase error: %v", err)
+		logger.Logger.Errorf("GetDatabase error: %v", err)
-//		return
+		return
-//	}
+	}
-//	if err := db.Limit(VP.GetInt("update_snid_num")).Find(&ids).Error; err != nil {
+	if err := db.Limit(VP.GetInt("update_snid_num")).Find(&ids).Error; err != nil {
-//		logger.Logger.Warnf("Get UserID error: %v", err)
+		logger.Logger.Warnf("Get UserID error: %v", err)
-//		return
+		return
-//	}
+	}
-//
+
-//	if len(ids) == 0 {
+	if len(ids) == 0 {
-//		logger.Logger.Tracef("Static: no need to update")
+		logger.Logger.Tracef("Static: no need to update")
-//		return
+		return
-//	}
+	}
-//
+
-//	// 统计玩家跳出记录
+	// 统计玩家跳出记录
-//	//if err := static.UserLogin(platform, ids); err != nil {
+	if err := static.UserLogin(platform, ids); err != nil {
-//	//	logger.Logger.Errorf("StaticUserLogin error: %v", err)
+		logger.Logger.Errorf("StaticUserLogin error: %v", err)
-//	//	return
+		return
-//	//}
+	}
-//
+
-//	// 删除更新过的玩家id
+	// 删除更新过的玩家id
-//	if err := db.Delete(ids).Error; err != nil {
+	if err := db.Delete(ids).Error; err != nil {
-//		logger.Logger.Errorf("Delete error: %v", err)
+		logger.Logger.Errorf("Delete error: %v", err)
-//		return
+		return
-//	}
+	}
-//}
+}
 
 // SyncInvite 同步邀请数据
 func SyncInvite(ctx context.Context) {

statistics/modelmysql/tables.go

@@ -1,7 +1,5 @@
 package modelmysql
 
-import "mongo.games.com/game/model"
-
 // 需要自动迁移的表添加在这里 Tables
 
 var Tables = []interface{}{
@@ -16,5 +14,4 @@ var Tables = []interface{}{
 	&LogMid{},
 	&ItemGain{},
 	&ItemTotalGain{},
-	&model.ThirteenAutoLog{},
 }

statistics/mq/handler.go

@@ -1,35 +1 @@
 package mq
-
-import (
-	"mongo.games.com/goserver/core/logger"
-	"mongo.games.com/goserver/core/mysqlx"
-
-	"mongo.games.com/game/model"
-	"mongo.games.com/game/mq"
-)
-
-func init() {
-	mq.RegisterHandler(&mq.RegisterHandlerParam{
-		Name: mq.BackThirteenAutoLog,
-		Data: &model.ThirteenAutoLog{},
-		Handler: func(data interface{}) (err error) {
-			d, ok := data.(*model.ThirteenAutoLog)
-			if !ok {
-				return nil
-			}
-
-			db, err := mysqlx.GetDatabase(d.Platform)
-			if err != nil {
-				logger.Logger.Errorf("mysql: SyncThirteenAutoLog failed to get database: %v", err)
-				return err
-			}
-
-			if err = db.Create(d).Error; err != nil {
-				logger.Logger.Errorf("mysql: SyncThirteenAutoLog failed to create thirteen_auto_log: %v", err)
-				return err
-			}
-
-			return nil
-		},
-	})
-}

statistics/static/user_login.go

@@ -1,355 +1,371 @@
 package static
 
-//func getAccountTel(platform string, id int) (string, error) {
+import (
-//	acc := &mongomodel.Account{}
+	"context"
-//	cc, err := mymongo.GetUserCollection(platform, mongomodel.UserAccount)
+	"errors"
-//	if err != nil {
+
-//		logger.Logger.Errorf("get collection %s error %v", mongomodel.UserAccount, err)
+	"go.mongodb.org/mongo-driver/bson"
-//		return "", err
+	"go.mongodb.org/mongo-driver/mongo"
-//	}
+	"go.mongodb.org/mongo-driver/mongo/options"
-//	dd := cc.FindOne(context.TODO(), bson.M{"snid": id}, options.FindOne().SetProjection(bson.M{"tel": 1}))
+	"mongo.games.com/goserver/core/logger"
-//	err = dd.Err()
+
-//	if err != nil {
+	mymongo "mongo.games.com/goserver/core/mongox"
-//		if errors.Is(err, mongo.ErrNoDocuments) {
+	mymysql "mongo.games.com/goserver/core/mysqlx"
-//			logger.Logger.Tracef("getAccountTel %v not found in user_account", id)
+
-//			return "", nil
+	mongomodel "mongo.games.com/game/statistics/modelmongo"
-//		}
+	mysqlmodel "mongo.games.com/game/statistics/modelmysql"
-//		logger.Logger.Errorf("getAccountTel %v get user_account err: %v", id, err)
+)
-//		return "", err
+
-//	}
+func getAccountTel(platform string, id int) (string, error) {
-//	if err := dd.Decode(acc); err != nil {
+	acc := &mongomodel.Account{}
-//		logger.Logger.Errorf("getAccountTel %v decode user_account err: %v", id, err)
+	cc, err := mymongo.GetUserCollection(platform, mongomodel.UserAccount)
-//		return "", err
+	if err != nil {
-//	}
+		logger.Logger.Errorf("get collection %s error %v", mongomodel.UserAccount, err)
-//	return acc.Tel, nil
+		return "", err
-//}
+	}
-//
+	dd := cc.FindOne(context.TODO(), bson.M{"snid": id}, options.FindOne().SetProjection(bson.M{"tel": 1}))
-//// 游戏结束离开
+	err = dd.Err()
-//func checkGameOver(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
+	if err != nil {
-//	// 最早的一条掉线记录并且是游戏结束离开
+		if errors.Is(err, mongo.ErrNoDocuments) {
-//	a := &mongomodel.LoginLog{}
+			logger.Logger.Tracef("getAccountTel %v not found in user_account", id)
-//	c, err := mymongo.GetLogCollection(platform, mongomodel.LogLogin)
+			return "", nil
-//	if err != nil {
+		}
-//		logger.Logger.Errorf("get collection %s error %v", mongomodel.LogLogin, err)
+		logger.Logger.Errorf("getAccountTel %v get user_account err: %v", id, err)
-//		return false, err
+		return "", err
-//	}
+	}
-//	d := c.FindOne(context.TODO(), bson.M{"snid": id, "logtype": mongomodel.LogTypeDrop, "gameid": 0, "lastgameid": bson.D{{"$gt", 0}}},
+	if err := dd.Decode(acc); err != nil {
-//		options.FindOne().SetSort(bson.D{{"time", 1}}))
+		logger.Logger.Errorf("getAccountTel %v decode user_account err: %v", id, err)
-//	err = d.Err()
+		return "", err
-//	if err != nil {
+	}
-//		if errors.Is(err, mongo.ErrNoDocuments) {
+	return acc.Tel, nil
-//			logger.Logger.Tracef("checkGameOver %v not found in log_login", id)
+}
-//			return false, nil
+
-//		}
+// 游戏结束离开
-//		logger.Logger.Errorf("checkGameOver %v get log_login err: %v", id, err)
+func checkGameOver(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
-//		return false, err
+	// 最早的一条掉线记录并且是游戏结束离开
-//	}
+	a := &mongomodel.LoginLog{}
-//	if err := d.Decode(a); err != nil {
+	c, err := mymongo.GetLogCollection(platform, mongomodel.LogLogin)
-//		logger.Logger.Errorf("checkGameOver %v decode log_login err: %v", id, err)
+	if err != nil {
-//		return false, err
+		logger.Logger.Errorf("get collection %s error %v", mongomodel.LogLogin, err)
-//	}
+		return false, err
-//
+	}
-//	// account tel
+	d := c.FindOne(context.TODO(), bson.M{"snid": id, "logtype": mongomodel.LogTypeDrop, "gameid": 0, "lastgameid": bson.D{{"$gt", 0}}},
-//	tel, err := getAccountTel(platform, id)
+		options.FindOne().SetSort(bson.D{{"time", 1}}))
-//	if err != nil {
+	err = d.Err()
-//		logger.Logger.Warnf("get account tel %v err: %v", id, err)
+	if err != nil {
-//	}
+		if errors.Is(err, mongo.ErrNoDocuments) {
-//
+			logger.Logger.Tracef("checkGameOver %v not found in log_login", id)
-//	update := &mysqlmodel.UserLogin{
+			return false, nil
-//		//OfflineTs:    int(a.Ts),
+		}
-//		OfflineTime:  a.Time,
+		logger.Logger.Errorf("checkGameOver %v get log_login err: %v", id, err)
-//		OutType:      mysqlmodel.OutTypeGameOver,
+		return false, err
-//		GameID:       a.LastGameID,
+	}
-//		Tel:          tel,
+	if err := d.Decode(a); err != nil {
-//		DeviceName:   a.DeviceName,
+		logger.Logger.Errorf("checkGameOver %v decode log_login err: %v", id, err)
-//		AppVersion:   a.AppVersion,
+		return false, err
-//		BuildVersion: a.BuildVersion,
+	}
-//		AppChannel:   a.AppChannel,
+
-//		ChannelId:    a.ChannelId,
+	// account tel
-//	}
+	tel, err := getAccountTel(platform, id)
-//
+	if err != nil {
-//	if err := db.Model(login).Select(
+		logger.Logger.Warnf("get account tel %v err: %v", id, err)
-//		"OfflineTime", "OutType", "GameID", "DeviceName", "AppVersion", "BuildVersion", "AppChannel", "Tel",
+	}
-//	).Updates(update).Error; err != nil {
+
-//		logger.Logger.Errorf("checkLogin %v update user_login err: %v", id, err)
+	update := &mysqlmodel.UserLogin{
-//		return false, err
+		//OfflineTs:    int(a.Ts),
-//	}
+		OfflineTime:  a.Time,
-//
+		OutType:      mysqlmodel.OutTypeGameOver,
-//	return true, nil
+		GameID:       a.LastGameID,
-//}
+		Tel:          tel,
-//
+		DeviceName:   a.DeviceName,
-//// 游戏中离开
+		AppVersion:   a.AppVersion,
-//func checkGaming(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
+		BuildVersion: a.BuildVersion,
-//	// 最早的一条掉线记录并且是游戏中掉线
+		AppChannel:   a.AppChannel,
-//	a := &mongomodel.LoginLog{}
+		ChannelId:    a.ChannelId,
-//	c, err := mymongo.GetLogCollection(platform, mongomodel.LogLogin)
+	}
-//	if err != nil {
+
-//		logger.Logger.Errorf("get collection %s error %v", mongomodel.LogLogin, err)
+	if err := db.Model(login).Select(
-//		return false, err
+		"OfflineTime", "OutType", "GameID", "DeviceName", "AppVersion", "BuildVersion", "AppChannel", "Tel",
-//	}
+	).Updates(update).Error; err != nil {
-//	d := c.FindOne(context.TODO(), bson.M{"snid": id, "logtype": mongomodel.LogTypeDrop, "gameid": bson.D{{"$gt", 0}}},
+		logger.Logger.Errorf("checkLogin %v update user_login err: %v", id, err)
-//		options.FindOne().SetSort(bson.D{{"time", 1}}))
+		return false, err
-//	err = d.Err()
+	}
-//	if err != nil {
+
-//		if errors.Is(err, mongo.ErrNoDocuments) {
+	return true, nil
-//			logger.Logger.Tracef("checkGaming %v not found in log_login", id)
+}
-//			return false, nil
+
-//		}
+// 游戏中离开
-//		logger.Logger.Errorf("checkGaming %v get log_login err: %v", id, err)
+func checkGaming(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
-//		return false, err
+	// 最早的一条掉线记录并且是游戏中掉线
-//	}
+	a := &mongomodel.LoginLog{}
-//	if err := d.Decode(a); err != nil {
+	c, err := mymongo.GetLogCollection(platform, mongomodel.LogLogin)
-//		logger.Logger.Errorf("checkGaming %v decode log_login err: %v", id, err)
+	if err != nil {
-//		return false, err
+		logger.Logger.Errorf("get collection %s error %v", mongomodel.LogLogin, err)
-//	}
+		return false, err
-//
+	}
-//	// account tel
+	d := c.FindOne(context.TODO(), bson.M{"snid": id, "logtype": mongomodel.LogTypeDrop, "gameid": bson.D{{"$gt", 0}}},
-//	tel, err := getAccountTel(platform, id)
+		options.FindOne().SetSort(bson.D{{"time", 1}}))
-//	if err != nil {
+	err = d.Err()
-//		logger.Logger.Warnf("get account tel %v err: %v", id, err)
+	if err != nil {
-//	}
+		if errors.Is(err, mongo.ErrNoDocuments) {
-//
+			logger.Logger.Tracef("checkGaming %v not found in log_login", id)
-//	update := &mysqlmodel.UserLogin{
+			return false, nil
-//		//OfflineTs:    int(a.Ts),
+		}
-//		OfflineTime:  a.Time,
+		logger.Logger.Errorf("checkGaming %v get log_login err: %v", id, err)
-//		OutType:      mysqlmodel.OutTypeGaming,
+		return false, err
-//		GameID:       a.GameId,
+	}
-//		Tel:          tel,
+	if err := d.Decode(a); err != nil {
-//		DeviceName:   a.DeviceName,
+		logger.Logger.Errorf("checkGaming %v decode log_login err: %v", id, err)
-//		AppVersion:   a.AppVersion,
+		return false, err
-//		BuildVersion: a.BuildVersion,
+	}
-//		AppChannel:   a.AppChannel,
+
-//		ChannelId:    a.ChannelId,
+	// account tel
-//	}
+	tel, err := getAccountTel(platform, id)
-//
+	if err != nil {
-//	if err := db.Model(login).Select(
+		logger.Logger.Warnf("get account tel %v err: %v", id, err)
-//		"OfflineTime", "OutType", "GameID", "DeviceName", "AppVersion", "BuildVersion", "AppChannel", "Tel",
+	}
-//	).Updates(update).Error; err != nil {
+
-//		logger.Logger.Errorf("checkLogin %v update user_login err: %v", id, err)
+	update := &mysqlmodel.UserLogin{
-//		return false, err
+		//OfflineTs:    int(a.Ts),
-//	}
+		OfflineTime:  a.Time,
-//
+		OutType:      mysqlmodel.OutTypeGaming,
-//	return true, nil
+		GameID:       a.GameId,
-//}
+		Tel:          tel,
-//
+		DeviceName:   a.DeviceName,
-//// 登录后离开
+		AppVersion:   a.AppVersion,
-//func checkLogin(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
+		BuildVersion: a.BuildVersion,
-//	// 最早的一条掉线记录
+		AppChannel:   a.AppChannel,
-//	a := &mongomodel.LoginLog{}
+		ChannelId:    a.ChannelId,
-//	c, err := mymongo.GetLogCollection(platform, mongomodel.LogLogin)
+	}
-//	if err != nil {
+
-//		logger.Logger.Errorf("get collection %s error %v", mongomodel.LogLogin, err)
+	if err := db.Model(login).Select(
-//		return false, err
+		"OfflineTime", "OutType", "GameID", "DeviceName", "AppVersion", "BuildVersion", "AppChannel", "Tel",
-//	}
+	).Updates(update).Error; err != nil {
-//	d := c.FindOne(context.TODO(), bson.M{"snid": id, "logtype": mongomodel.LogTypeDrop}, options.FindOne().SetSort(bson.D{{"time", 1}}))
+		logger.Logger.Errorf("checkLogin %v update user_login err: %v", id, err)
-//	err = d.Err()
+		return false, err
-//	if err != nil {
+	}
-//		if errors.Is(err, mongo.ErrNoDocuments) {
+
-//			logger.Logger.Tracef("checkLogin %v not found in log_login", id)
+	return true, nil
-//			return false, nil
+}
-//		}
+
-//		logger.Logger.Errorf("checkLogin %v get log_login err: %v", id, err)
+// 登录后离开
-//		return false, err
+func checkLogin(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
-//	}
+	// 最早的一条掉线记录
-//	if err := d.Decode(a); err != nil {
+	a := &mongomodel.LoginLog{}
-//		logger.Logger.Errorf("checkLogin %v decode log_login err: %v", id, err)
+	c, err := mymongo.GetLogCollection(platform, mongomodel.LogLogin)
-//		return false, err
+	if err != nil {
-//	}
+		logger.Logger.Errorf("get collection %s error %v", mongomodel.LogLogin, err)
-//
+		return false, err
-//	// account tel
+	}
-//	tel, err := getAccountTel(platform, id)
+	d := c.FindOne(context.TODO(), bson.M{"snid": id, "logtype": mongomodel.LogTypeDrop}, options.FindOne().SetSort(bson.D{{"time", 1}}))
-//	if err != nil {
+	err = d.Err()
-//		logger.Logger.Warnf("get account tel %v err: %v", id, err)
+	if err != nil {
-//	}
+		if errors.Is(err, mongo.ErrNoDocuments) {
-//
+			logger.Logger.Tracef("checkLogin %v not found in log_login", id)
-//	update := &mysqlmodel.UserLogin{
+			return false, nil
-//		//OfflineTs:    int(a.Ts),
+		}
-//		OfflineTime:  a.Time,
+		logger.Logger.Errorf("checkLogin %v get log_login err: %v", id, err)
-//		OutType:      mysqlmodel.OutTypeLogin,
+		return false, err
-//		Tel:          tel,
+	}
-//		DeviceName:   a.DeviceName,
+	if err := d.Decode(a); err != nil {
-//		AppVersion:   a.AppVersion,
+		logger.Logger.Errorf("checkLogin %v decode log_login err: %v", id, err)
-//		BuildVersion: a.BuildVersion,
+		return false, err
-//		AppChannel:   a.AppChannel,
+	}
-//		ChannelId:    a.ChannelId,
+
-//	}
+	// account tel
-//
+	tel, err := getAccountTel(platform, id)
-//	if err := db.Model(login).Select(
+	if err != nil {
-//		"OfflineTime", "OutType", "DeviceName", "AppVersion", "BuildVersion", "AppChannel", "Tel",
+		logger.Logger.Warnf("get account tel %v err: %v", id, err)
-//	).Updates(update).Error; err != nil {
+	}
-//		logger.Logger.Errorf("checkLogin %v update user_login err: %v", id, err)
+
-//		return false, err
+	update := &mysqlmodel.UserLogin{
-//	}
+		//OfflineTs:    int(a.Ts),
-//
+		OfflineTime:  a.Time,
-//	return true, nil
+		OutType:      mysqlmodel.OutTypeLogin,
-//}
+		Tel:          tel,
-//
+		DeviceName:   a.DeviceName,
-//// 注册后离开
+		AppVersion:   a.AppVersion,
-//func checkRegister(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
+		BuildVersion: a.BuildVersion,
-//	a := &mongomodel.Account{}
+		AppChannel:   a.AppChannel,
-//	c, err := mymongo.GetUserCollection(platform, mongomodel.UserAccount)
+		ChannelId:    a.ChannelId,
-//	if err != nil {
+	}
-//		logger.Logger.Errorf("get collection %s error %v", mongomodel.UserAccount, err)
+
-//		return false, err
+	if err := db.Model(login).Select(
-//	}
+		"OfflineTime", "OutType", "DeviceName", "AppVersion", "BuildVersion", "AppChannel", "Tel",
-//	d := c.FindOne(context.TODO(), bson.M{"snid": id})
+	).Updates(update).Error; err != nil {
-//	err = d.Err()
+		logger.Logger.Errorf("checkLogin %v update user_login err: %v", id, err)
-//	if err != nil {
+		return false, err
-//		if errors.Is(err, mongo.ErrNoDocuments) {
+	}
-//			logger.Logger.Warnf("checkRegister %v not found in user_account", id)
+
-//			return false, nil
+	return true, nil
-//		}
+}
-//		logger.Logger.Errorf("checkRegister %v get user_account err: %v", id, err)
+
-//		return false, err
+// 注册后离开
-//	}
+func checkRegister(db *mymysql.Database, login *mysqlmodel.UserLogin, platform string, id int) (bool, error) {
-//	if err := d.Decode(a); err != nil {
+	a := &mongomodel.Account{}
-//		logger.Logger.Errorf("checkRegister %v decode user_account err: %v", id, err)
+	c, err := mymongo.GetUserCollection(platform, mongomodel.UserAccount)
-//		return false, err
+	if err != nil {
-//	}
+		logger.Logger.Errorf("get collection %s error %v", mongomodel.UserAccount, err)
-//
+		return false, err
-//	// account tel
+	}
-//	tel, err := getAccountTel(platform, id)
+	d := c.FindOne(context.TODO(), bson.M{"snid": id})
-//	if err != nil {
+	err = d.Err()
-//		logger.Logger.Warnf("get account tel %v err: %v", id, err)
+	if err != nil {
-//	}
+		if errors.Is(err, mongo.ErrNoDocuments) {
-//
+			logger.Logger.Warnf("checkRegister %v not found in user_account", id)
-//	login.Snid = id
+			return false, nil
-//	//login.OnlineTs = int(a.RegisterTs)
+		}
-//	login.OnlineTime = a.RegisteTime
+		logger.Logger.Errorf("checkRegister %v get user_account err: %v", id, err)
-//	//login.OfflineTs = int(a.RegisterTs)
+		return false, err
-//	login.OfflineTime = a.RegisteTime
+	}
-//	login.OutType = mysqlmodel.OutTypRegister
+	if err := d.Decode(a); err != nil {
-//	login.Tel = tel
+		logger.Logger.Errorf("checkRegister %v decode user_account err: %v", id, err)
-//	login.DeviceName = a.DeviceName
+		return false, err
-//	login.AppVersion = a.AppVersion
+	}
-//	login.BuildVersion = a.BuildVersion
+
-//	login.AppChannel = a.AppChannel
+	// account tel
-//	login.ChannelId = a.ChannelId
+	tel, err := getAccountTel(platform, id)
-//
+	if err != nil {
-//	if err := db.Create(login).Error; err != nil {
+		logger.Logger.Warnf("get account tel %v err: %v", id, err)
-//		logger.Logger.Errorf("checkRegister create err: %v", err)
+	}
-//		return false, err
+
-//	}
+	login.Snid = id
-//	return true, nil
+	//login.OnlineTs = int(a.RegisterTs)
-//}
+	login.OnlineTime = a.RegisteTime
+	//login.OfflineTs = int(a.RegisterTs)
+	login.OfflineTime = a.RegisteTime
+	login.OutType = mysqlmodel.OutTypRegister
+	login.Tel = tel
+	login.DeviceName = a.DeviceName
+	login.AppVersion = a.AppVersion
+	login.BuildVersion = a.BuildVersion
+	login.AppChannel = a.AppChannel
+	login.ChannelId = a.ChannelId
+
+	if err := db.Create(login).Error; err != nil {
+		logger.Logger.Errorf("checkRegister create err: %v", err)
+		return false, err
+	}
+	return true, nil
+}
 
 // UserLogin 玩家跳出统计
-//func UserLogin(platform string, ids []*mysqlmodel.UserID) error {
+func UserLogin(platform string, ids []*mysqlmodel.UserID) error {
-//	f := func(id int) error {
+	f := func(id int) error {
-//		// 玩家是否已经统计结束,已经是游戏结束状态
+		// 玩家是否已经统计结束,已经是游戏结束状态
-//		login := &mysqlmodel.UserLogin{}
+		login := &mysqlmodel.UserLogin{}
-//		db, err := mymysql.GetDatabase(platform)
+		db, err := mymysql.GetDatabase(platform)
-//		if err != nil {
+		if err != nil {
-//			logger.Logger.Errorf("UserLogin get db err: %v", err)
+			logger.Logger.Errorf("UserLogin get db err: %v", err)
-//			return err
+			return err
-//		}
+		}
-//		if err = db.Where("snid = ?", id).Find(login).Error; err != nil {
+		if err = db.Where("snid = ?", id).Find(login).Error; err != nil {
-//			logger.Logger.Errorf("UserLogin find %v err: %v", id, err)
+			logger.Logger.Errorf("UserLogin find %v err: %v", id, err)
-//			return err
+			return err
-//		}
+		}
-//
+
-//		switch login.OutType {
+		switch login.OutType {
-//		case mysqlmodel.OutTypeGameOver:
+		case mysqlmodel.OutTypeGameOver:
-//			return nil
+			return nil
-//
+
-//		case mysqlmodel.OutTypeGaming:
+		case mysqlmodel.OutTypeGaming:
-//			_, err := checkGameOver(db, login, platform, id)
+			_, err := checkGameOver(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			return nil
+			return nil
-//
+
-//		case mysqlmodel.OutTypeLogin:
+		case mysqlmodel.OutTypeLogin:
-//			ret, err := checkGameOver(db, login, platform, id)
+			ret, err := checkGameOver(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//			ret, err = checkGaming(db, login, platform, id)
+			ret, err = checkGaming(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGaming %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGaming %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//
+
-//		case mysqlmodel.OutTypRegister:
+		case mysqlmodel.OutTypRegister:
-//			ret, err := checkGameOver(db, login, platform, id)
+			ret, err := checkGameOver(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//			ret, err = checkGaming(db, login, platform, id)
+			ret, err = checkGaming(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGaming %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGaming %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//			ret, err = checkLogin(db, login, platform, id)
+			ret, err = checkLogin(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkLogin %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkLogin %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//
+
-//		default:
+		default:
-//			ret, err := checkRegister(db, login, platform, id)
+			ret, err := checkRegister(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkRegister %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkRegister %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if !ret {
+			if !ret {
-//				logger.Logger.Warnf("UserLogin not found user_account checkRegister %v err: %v", id, err)
+				logger.Logger.Warnf("UserLogin not found user_account checkRegister %v err: %v", id, err)
-//				return nil
+				return nil
-//			}
+			}
-//
+
-//			ret, err = checkGameOver(db, login, platform, id)
+			ret, err = checkGameOver(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGameOver %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//			ret, err = checkGaming(db, login, platform, id)
+			ret, err = checkGaming(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkGaming %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkGaming %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//			ret, err = checkLogin(db, login, platform, id)
+			ret, err = checkLogin(db, login, platform, id)
-//			if err != nil {
+			if err != nil {
-//				logger.Logger.Errorf("UserLogin checkLogin %v err: %v", id, err)
+				logger.Logger.Errorf("UserLogin checkLogin %v err: %v", id, err)
-//				return err
+				return err
-//			}
+			}
-//			if ret {
+			if ret {
-//				return nil
+				return nil
-//			}
+			}
-//			return nil
+			return nil
-//		}
+		}
-//
+
-//		return nil
+		return nil
-//	}
+	}
-//
+
-//	for _, v := range ids {
+	for _, v := range ids {
-//		if err := f(v.Snid); err != nil {
+		if err := f(v.Snid); err != nil {
-//			return err
+			return err
-//		}
+		}
-//	}
+	}
-//
+
-//	return nil
+	return nil
-//}
+}

statistics/syn/log_login.go

@@ -9,12 +9,12 @@ import (
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"gorm.io/gorm"
-	"mongo.games.com/goserver/core/logger"
-	mymongo "mongo.games.com/goserver/core/mongox"
-	mymysql "mongo.games.com/goserver/core/mysqlx"
 
 	mongomodel "mongo.games.com/game/statistics/modelmongo"
 	mysqlmodel "mongo.games.com/game/statistics/modelmysql"
+	"mongo.games.com/goserver/core/logger"
+	mymongo "mongo.games.com/goserver/core/mongox"
+	mymysql "mongo.games.com/goserver/core/mysqlx"
 )
 
 /*
@@ -155,19 +155,19 @@ func LogLogin(platform string, batchSize int) ([]*mysqlmodel.LogLogin, error) {
 				return err
 			}
 
-			//for _, v := range ls {
+			for _, v := range ls {
-			//	if err = tx.First(&mysqlmodel.UserID{}, "snid = ?", v.Snid).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+				if err = tx.First(&mysqlmodel.UserID{}, "snid = ?", v.Snid).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-			//		logger.Logger.Errorf("mysql: SyncLogLogin failed to find user_id: %v", err)
+					logger.Logger.Errorf("mysql: SyncLogLogin failed to find user_id: %v", err)
-			//		return err
+					return err
-			//	}
+				}
-			//
+
-			//	if errors.Is(err, gorm.ErrRecordNotFound) {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
-			//		if err = tx.Create(&mysqlmodel.UserID{Snid: v.Snid}).Error; err != nil {
+					if err = tx.Create(&mysqlmodel.UserID{Snid: v.Snid}).Error; err != nil {
-			//			logger.Logger.Errorf("mysql: SyncLogLogin failed to create user_id: %v", err)
+						logger.Logger.Errorf("mysql: SyncLogLogin failed to create user_id: %v", err)
-			//			return err
+						return err
-			//		}
+					}
-			//	}
+				}
-			//}
+			}
 
 			return nil
 		})

statistics/syn/readme

@@ -1,3 +1 @@
-游戏服mongodb同步到mysql
+游戏服mongodb同步到mysql
-
-datasync.go 同步模型

statistics/task/etc/config.yaml

@@ -1,18 +1,17 @@
-StartTime: "2024-12-19T00:00:00+08:00"
+StartTime: "2024-11-26T00:00:00+08:00"
-EndTime: "2024-12-20T00:00:00+08:00"
+EndTime: "2024-11-27T00:00:00+08:00"
 
 Switch: # 1: open, 0: close
   - 0 # 新用户游戏破产率
   - 0 # 新用户平均游戏时长
-  - 1 # 用户平均游戏时长
   - 0 # 新用户平均局数
   - 0 # 平均倍数
-  - 0 # 活跃破产率
+  - 1 # 活跃破产率
-  - 0 # 控输赢胜率
+  - 1 # 控输赢胜率
-  - 0 # 机器人胜率
+  - 1 # 机器人胜率
-  - 0 # 人均获得金币
+  - 1 # 人均获得金币
-  - 0 # 破产后离线
+  - 1 # 破产后离线
-  - 0 # 充值玩家金币余额
+  - 1 # 充值玩家金币余额
 
 Gamefreeids:
   - 2070001

statistics/task/main.go

@@ -18,7 +18,6 @@ import (
 const (
 	ExcelTypeNewPlayerBankrupt = iota // 新用户游戏破产率
 	ExcelTypeGameTimeAvg              // 新用户平均游戏时长
-	ExcelTypeGameTimeAllAvg           // 用户平均游戏时长
 	ExcelTypeGameCountAvg             // 新用户平均局数
 	ExcelTypeGameRate                 // 平均倍数
 	ExcelTypeActiveRate               // 活跃破产率
@@ -72,7 +71,6 @@ func main() {
 	mgr := NewExcelMgr()
 	mgr.Register(ExcelTypeNewPlayerBankrupt, []string{"日期", "场次id", "破产人数", "参与人数", "破产率"})
 	mgr.Register(ExcelTypeGameTimeAvg, []string{"日期", "场次id", "参与人数", "平均游戏时长"})
-	mgr.Register(ExcelTypeGameTimeAllAvg, []string{"日期", "场次id", "参与人数", "平均游戏时长"})
 	mgr.Register(ExcelTypeGameCountAvg, []string{"日期", "场次id", "参与人数", "平均局数"})
 	mgr.Register(ExcelTypeGameRate, []string{"日期", "场次id", "总局数", "平均倍数", "有炸弹分局数", "炸弹分平均倍数", "2留在手里的局数"})
 	mgr.Register(ExcelTypeActiveRate, []string{"日期", "场次id", "破产人数", "参与人数", "破产率"})
@@ -101,10 +99,6 @@ func main() {
 			// 新用户平均游戏时长
 			mgr.GenNewPlayerGameTimeAvgExcel("1", startTimeStr, endTimeStr)
 		}
-		if switchArr[ExcelTypeGameTimeAllAvg] == 1 {
-			// 用户平均游戏时长
-			mgr.GenPlayerGameTimeAvgExcel("1", startTimeStr, endTimeStr)
-		}
 		if switchArr[ExcelTypeGameCountAvg] == 1 {
 			// 新用户平均局数
 			mgr.GenGameCountExcel("1", startTimeStr, endTimeStr)
@@ -150,10 +144,7 @@ func (e *ExcelMgr) SaveAll(startTime, endTime string) {
 		e.Save(ExcelTypeNewPlayerBankrupt, fmt.Sprintf("新用户破产率_%s_%s.xlsx", startTime, endTime))
 	}
 	if switchArr[ExcelTypeGameTimeAvg] == 1 {
-		e.Save(ExcelTypeGameTimeAvg, fmt.Sprintf("新用户平均游戏时长_%s_%s.xlsx", startTime, endTime))
+		e.Save(ExcelTypeGameTimeAvg, fmt.Sprintf("新用户平局游戏时长_%s_%s.xlsx", startTime, endTime))
-	}
-	if switchArr[ExcelTypeGameTimeAllAvg] == 1 {
-		e.Save(ExcelTypeGameTimeAllAvg, fmt.Sprintf("用户平均游戏时长_%s_%s.xlsx", startTime, endTime))
 	}
 	if switchArr[ExcelTypeGameCountAvg] == 1 {
 		e.Save(ExcelTypeGameCountAvg, fmt.Sprintf("新用户平均局数_%s_%s.xlsx", startTime, endTime))
@@ -232,29 +223,6 @@ func (e *ExcelMgr) GenNewPlayerGameTimeAvgExcel(plt string, startTime, endTime s
 	}
 }
 
-func (e *ExcelMgr) GenPlayerGameTimeAvgExcel(plt string, startTime, endTime string) {
-	for _, v := range VP.GetIntSlice("Gamefreeids") {
-		a, b, err := task.PlayerGameTimeAvg(plt, startTime, endTime, v)
-		if err != nil {
-			logger.Logger.Errorf("PlayerGameTimeAvg get StartTime:%v EndTime:%v GameFreeId:%v err: %v", startTime, endTime, v, err)
-			continue
-		}
-		ex := e.Get(ExcelTypeGameTimeAllAvg)
-		ex.NewLine()
-		ex.SetCell(startTime[:10])
-		ex.SetCell(GetGameFreeName(v))
-		ex.SetCell(a)
-		if a > 0 {
-			avg := float64(b) / float64(a)
-			show := fmt.Sprintf("%v", time.Second*time.Duration(avg))
-			ex.SetCell(show)
-		} else {
-			ex.SetCell(0)
-		}
-		logger.Logger.Tracef("PlayerGameTimeAvg GameFreeId: %v avg: %v", v, float64(b)/float64(a))
-	}
-}
-
 func (e *ExcelMgr) GenGameCountExcel(plt string, startTime, endTime string) {
 	for _, v := range VP.GetIntSlice("Gamefreeids") {
 		a, b, err := task.NewPlayerGameCountAvg(plt, startTime, endTime, v)

statistics/task/task/bankruptcy.go

@@ -45,37 +45,6 @@ func GetNewPayerIds(plt string, startTime, endTime string) ([]int, error) {
 	return ret, nil
 }
 
-func GetPayerIds(plt string, startTime, endTime string, gamefreeid int) ([]int, error) {
-	s, e := common.StrRFC3339TimeToTime(startTime), common.StrRFC3339TimeToTime(endTime)
-	c, err := mymongo.GetLogCollection(plt, mongomodel.LogGamePlayerListLog)
-	if err != nil {
-		return nil, err
-	}
-
-	var res []struct{ Snid int }
-	dd, err := c.Aggregate(context.TODO(), bson.A{
-		bson.M{"$match": bson.M{"time": bson.M{"$gte": s, "$lt": e}, "gamefreeid": gamefreeid}},
-		bson.M{"$group": bson.M{"_id": "$snid", "snid": bson.M{"$first": "$snid"}}},
-	})
-	if err != nil {
-		if errors.Is(err, mongo.ErrNoDocuments) {
-			return nil, nil
-		}
-		logger.Logger.Errorf("find game player snid get err: %v", err)
-		return nil, err
-	}
-	if err := dd.All(context.TODO(), &res); err != nil {
-		logger.Logger.Errorf("find game player snid decode err: %v", err)
-		return nil, err
-	}
-	var ret []int
-	for _, v := range res {
-		ret = append(ret, v.Snid)
-	}
-	logger.Logger.Tracef("find game player snid: %v", ret)
-	return ret, nil
-}
-
 // 场次破产总人数
 func GameFreeIdBankruptPlayerCount(plt string, ids []int, startTime, endTime string, gamefreeid int) (int, error) {
 	s, e := common.StrRFC3339TimeToTime(startTime), common.StrRFC3339TimeToTime(endTime)

statistics/task/task/gametime.go

@@ -36,10 +36,7 @@ func NewPlayerGameTime(plt string, ids []int, startTime, endTime string, gamefre
 		if gamefreeid > 0 {
 			where["gamefreeid"] = gamefreeid
 		}
-		cur, err := c.Aggregate(context.Background(), bson.A{
+		cur, err := c.Find(context.TODO(), where, options.Find().SetProjection(bson.M{"gamedetailedlogid": 1}))
-			bson.M{"$match": where},
-			bson.M{"$group": bson.M{"_id": "$gamedetailedlogid", "gamedetailedlogid": bson.M{"$first": "$gamedetailedlogid"}}},
-		})
 		if err != nil {
 			logger.Logger.Errorf("find player gamedetailedlogid get err: %v", err)
 			return 0, 0, err
@@ -105,26 +102,3 @@ func NewPlayerGameTimeAvg(plt string, startTime, endTime string, gamefreeid int)
 	}
 	return b, a, err
 }
-
-func PlayerGameTimeAvg(plt string, startTime, endTime string, gamefreeid int) (int, int, error) {
-	s, e := common.StrRFC3339TimeToTime(startTime), common.StrRFC3339TimeToTime(endTime)
-	if s.IsZero() || e.IsZero() {
-		return 0, 0, fmt.Errorf("time format error")
-	}
-	ids, err := GetPayerIds(plt, startTime, endTime, gamefreeid)
-	if err != nil {
-		return 0, 0, err
-	}
-	if len(ids) == 0 {
-		return 0, 0, nil
-	}
-	a, _, err := NewPlayerGameTime(plt, ids, startTime, endTime, gamefreeid)
-	if err != nil {
-		return 0, 0, err
-	}
-	if len(ids) == 0 {
-		return 0, 0, nil
-	}
-
-	return len(ids), a, err
-}

worldsrv/action_game.go

@@ -180,11 +180,6 @@ func (this *CSEnterRoomHandler) Process(s *netlib.Session, packetid int, data in
 			p.matchCtx = mc
 		}
 	}
-	if scene.IsCustom() {
-		if scene.CustomParam.GetCostType() == 1 {
-			sp.CostPayment(scene, p.SnId)
-		}
-	}
 
 	if !scene.PlayerEnter(p, -1, true) {
 		code = gamehall.OpResultCode_Game_OPRC_Error_Game
@@ -1347,13 +1342,15 @@ func CSCreatePrivateRoomHandler(s *netlib.Session, packetId int, data interface{
 
 	csp.AddScene(scene)
 
-	sp.CostPayment(scene, p.SnId)
-
 	if !scene.PlayerEnter(p, -1, true) {
 		send()
 		return nil
 	}
 
+	if costType == 2 {
+		sp.CostPayment(scene, p.SnId)
+	}
+
 	code = gamehall.OpResultCode_Game_OPRC_Sucess_Game
 	pack = &gamehall.SCCreatePrivateRoom{
 		GameFreeId:   msg.GetGameFreeId(),

worldsrv/action_server.go

@@ -134,8 +134,7 @@ func init() {
 					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,
+					log := model.NewBankruptLogEx(p.SnId, scene.dbGameFree.GetId(), p.CreateTime.Unix(), CostCoin, p.Platform, p.Channel, scene.gameId)
-						p.Platform, p.Channel, p.ChannelId, scene.dbGameFree.GetGameDif(), scene.gameId)
 					if log != nil {
 						mq.Write(log)
 					}

worldsrv/player.go

@@ -324,6 +324,8 @@ func (this *Player) OnLogined() {
 
 		this.DealShopLog()
 
+		PlayerOnlineSington.Check = true
+
 		this.LoadMessage(tLastLogout.Unix(), isFirstLogin, !inSameWeek)
 
 		//登录次数
@@ -399,6 +401,7 @@ func (this *Player) OnRehold() {
 	if !this.IsRob {
 		TournamentMgr.Quit(this.Platform, this.SnId) // 比赛没有开始，退赛
 		this.SendJackPotInit()
+		PlayerOnlineSington.Check = true
 
 		this.DealShopLog()
 
@@ -1185,6 +1188,7 @@ func (this *Player) DropLine() {
 
 		this.SendPlayerCoin()
 		this.OnlineLogDrop()
+		PlayerOnlineSington.Check = true
 	}
 
 	if this.scene != nil && this.scene.gameSess != nil {
@@ -1218,6 +1222,7 @@ func (this *Player) OnLogoutFinish() {
 
 	if !this.IsRobot() {
 		FriendUnreadMgrSington.SaveFriendUnreadData(this.Platform, this.SnId)
+		PlayerOnlineSington.Check = true
 
 		//登录日志
 		logState := LoginStateMgrSington.GetLoginStateBySid(this.sid)
@@ -1260,7 +1265,6 @@ func (this *Player) UnmarshalData(data []byte, scene *Scene) {
 		strconv.Itoa(int(scene.dbGameFree.GetGameId())),
 		common.GetKeyNoviceGameId(int(scene.dbGameFree.GetGameId())),
 		common.GetKeyGameType(int(scene.dbGameFree.GetGameType())),
-		common.GetKeyGameDif(scene.dbGameFree.GetGameDif()),
 	} {
 		if d, ok := pd.GDatas[v]; ok {
 			this.GDatas[v] = d

worldsrv/playeronline.go

@@ -8,40 +8,8 @@ import (
 	"mongo.games.com/game/common"
 	"mongo.games.com/game/model"
 	"mongo.games.com/game/mq"
-	"mongo.games.com/game/worldsrv/internal"
 )
 
-func init() {
-	module.RegisteModule(PlayerOnlineSington, 5*time.Second, 0)
-
-	internal.RegisterPlayerListenerFunc(&internal.PlayerListenerFunc[*Player, *Scene]{
-		OnPlayerLoginedFunc: func(p *Player) {
-			if p == nil || p.IsRob {
-				return
-			}
-			PlayerOnlineSington.Check = true
-		},
-		OnPlayerLogoutedFunc: func(p *Player) {
-			if p == nil || p.IsRob {
-				return
-			}
-			PlayerOnlineSington.Check = true
-		},
-		OnPlayerDropLineFunc: func(p *Player) {
-			if p == nil || p.IsRob {
-				return
-			}
-			PlayerOnlineSington.Check = true
-		},
-		OnPlayerReholdFunc: func(p *Player) {
-			if p == nil || p.IsRob {
-				return
-			}
-			PlayerOnlineSington.Check = true
-		},
-	})
-}
-
 var PlayerOnlineSington = &PlayerOnlineEvent{
 	OnlineCh: make(map[string]map[string]int),
 }
@@ -98,3 +66,7 @@ here:
 func (p *PlayerOnlineEvent) Shutdown() {
 	module.UnregisteModule(p)
 }
+
+func init() {
+	module.RegisteModule(PlayerOnlineSington, 5*time.Second, 0)
+}

worldsrv/playeronlinegame.go

@@ -1,125 +0,0 @@
-package main
-
-import (
-	"slices"
-	"time"
-
-	"golang.org/x/exp/maps"
-	"mongo.games.com/goserver/core/logger"
-	"mongo.games.com/goserver/core/module"
-
-	"mongo.games.com/game/common"
-	"mongo.games.com/game/model"
-	"mongo.games.com/game/mq"
-	"mongo.games.com/game/worldsrv/internal"
-)
-
-func init() {
-	module.RegisteModule(PlayerOnlineGameSingleton, 10*time.Second, 0)
-
-	internal.RegisterPlayerListenerFunc(&internal.PlayerListenerFunc[*Player, *Scene]{
-		OnPlayerEnterSceneAfterFunc: func(p *Player, s *Scene) {
-			if p == nil || p.IsRob {
-				return
-			}
-			PlayerOnlineGameSingleton.Check = true
-		},
-		OnPlayerLeaveSceneAfterFunc: func(p *Player, s *Scene) {
-			if p == nil || p.IsRob {
-				return
-			}
-			PlayerOnlineGameSingleton.Check = true
-		},
-	})
-}
-
-var PlayerOnlineGameSingleton = &PlayerOnlineGameEvent{
-	Online: make(map[string]map[string]map[string]map[int]map[int]int),
-}
-
-type PlayerOnlineGameEvent struct {
-	Online map[string]map[string]map[string]map[int]map[int]int // 平台：推广渠道：游戏组：游戏id：场次id：在线人数
-	Check  bool
-}
-
-func (p *PlayerOnlineGameEvent) ModuleName() string {
-	return "PlayerOnlineGameEvent"
-}
-
-func (p *PlayerOnlineGameEvent) Init() {
-}
-
-func (p *PlayerOnlineGameEvent) Update() {
-	if !p.Check {
-		return
-	}
-	p.Check = false
-
-	onlineCh := make(map[string]map[string]map[string]map[int]map[int]int)
-
-	for _, v := range SceneMgrSingleton.scenes {
-		if v == nil {
-			continue
-		}
-
-		plt := SceneMgrSingleton.GetPlatformBySceneId(v.sceneId)
-		// 平台
-		if _, ok := onlineCh[plt]; !ok {
-			onlineCh[plt] = map[string]map[string]map[int]map[int]int{}
-		}
-
-		for _, player := range v.players {
-			if player == nil || player.IsRob || player.Platform == common.Platform_Rob && player.Channel == common.Channel_Rob {
-				continue
-			}
-
-			// 渠道
-			if _, ok := onlineCh[plt][player.ChannelId]; !ok {
-				onlineCh[plt][player.ChannelId] = map[string]map[int]map[int]int{}
-			}
-			// 游戏组
-			if _, ok := onlineCh[plt][player.ChannelId][v.dbGameFree.GetGameDif()]; !ok {
-				onlineCh[plt][player.ChannelId][v.dbGameFree.GetGameDif()] = map[int]map[int]int{}
-			}
-			// 游戏id
-			if _, ok := onlineCh[plt][player.ChannelId][v.dbGameFree.GetGameDif()][int(v.dbGameFree.GetGameId())]; !ok {
-				onlineCh[plt][player.ChannelId][v.dbGameFree.GetGameDif()][int(v.dbGameFree.GetGameId())] = map[int]int{}
-			}
-			onlineCh[plt][player.ChannelId][v.dbGameFree.GetGameDif()][int(v.dbGameFree.GetGameId())][int(v.dbGameFree.GetId())] += 1
-		}
-	}
-
-	// 判断差异
-	if !slices.Equal(maps.Keys(p.Online), maps.Keys(onlineCh)) {
-		goto here
-	}
-	for k, v := range p.Online {
-		if !slices.Equal(maps.Keys(v), maps.Keys(onlineCh[k])) {
-			goto here
-		}
-		for k1, v1 := range v {
-			if !slices.Equal(maps.Keys(v1), maps.Keys(onlineCh[k][k1])) {
-				goto here
-			}
-			for k2, v2 := range v1 {
-				if !slices.Equal(maps.Keys(v2), maps.Keys(onlineCh[k][k1][k2])) {
-					goto here
-				}
-				for k3, v3 := range v2 {
-					if !slices.Equal(maps.Keys(v3), maps.Keys(onlineCh[k][k1][k2][k3])) {
-						goto here
-					}
-				}
-			}
-		}
-	}
-
-here:
-	p.Online = onlineCh
-	mq.Write(model.GenerateOnlineGame(p.Online))
-	logger.Logger.Trace("PlayerOnlineGameEvent", p.Online)
-}
-
-func (p *PlayerOnlineGameEvent) Shutdown() {
-	module.UnregisteModule(p)
-}

worldsrv/scene.go

@@ -162,10 +162,6 @@ func NewScene(args *CreateSceneParam) *Scene {
 	return s
 }
 
-func (this *Scene) GetPlatform() *Platform {
-	return this.platform
-}
-
 func (this *Scene) RobotIsLimit() bool {
 	if this.robotLimit != 0 {
 		if this.robotNum >= this.robotLimit {

worldsrv/scenepolicydata.go

@@ -57,6 +57,11 @@ func (spd *ScenePolicyData) OnTick(s *Scene) {
 
 func (spd *ScenePolicyData) OnPlayerEnter(s *Scene, snid int32) {
 	s.NotifyPrivateRoom(common.ListModify)
+	if s.IsCustom() {
+		if s.CustomParam.GetCostType() == 1 { // AA
+			spd.CostPayment(s, snid)
+		}
+	}
 }
 
 func (spd *ScenePolicyData) OnPlayerLeave(s *Scene, snid int32) {

worldsrv/trascate_webapi.go

@@ -2257,13 +2257,11 @@ func init() {
 
 				state = msg.GetState()
 				player := PlayerMgrSington.GetPlayerBySnId(info.SnId)
-				logger.Logger.Info("CallbackPayment player", player)
+				if player == nil {
-				if player == nil || (player != nil && player.IsOffline()) {
 					if msg.State == 1 {
 						state = 3
 					}
 				}
-				logger.Logger.Info("------------CallbackPayment state----------", state)
 				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
 					err := model.UpdateDbShopState(msg.Platform, msg.OrderId, state)
 					if err != nil {
@@ -2276,7 +2274,7 @@ func init() {
 						retFail("购买记录状态修改失败")
 						return
 					}
-					if player != nil || (player != nil && player.IsOffline()) {
+					if player != nil {
 						player.DoShopInfo(info, false)
 						// 邀请积分
 						InviteTask(msg.Platform, player.PSnId, info.SnId, common.InviteScoreTypePay, int64(info.ConsumeNum))