433 lines
12 KiB
Go
433 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"math"
|
|
"sort"
|
|
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/srvlib"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/model"
|
|
serverproto "mongo.games.com/game/protocol/server"
|
|
webapi2 "mongo.games.com/game/protocol/webapi"
|
|
"mongo.games.com/game/webapi"
|
|
)
|
|
|
|
func init() {
|
|
ClockMgrSington.RegisteSinker(SceneMgrSingleton)
|
|
}
|
|
|
|
var SceneMgrSingleton = &SceneMgr{
|
|
scenes: make(map[int]*Scene),
|
|
privateAutoId: common.PrivateSceneStartId,
|
|
matchAutoId: common.MatchSceneStartId,
|
|
coinSceneAutoId: common.CoinSceneStartId,
|
|
hundredSceneAutoId: common.HundredSceneStartId,
|
|
}
|
|
|
|
// SceneMgr 房间管理器
|
|
type SceneMgr struct {
|
|
BaseClockSinker // 驱动时间事件
|
|
|
|
scenes map[int]*Scene // 房间id: Scene
|
|
privateAutoId int // 私人房房间号
|
|
matchAutoId int // 比赛场房间号
|
|
coinSceneAutoId int // 金币场房间号
|
|
hundredSceneAutoId int // 百人场房间号
|
|
}
|
|
|
|
// AllocReplayCode 获取回访码
|
|
func (m *SceneMgr) AllocReplayCode() string {
|
|
code, _ := model.GetOneReplayId()
|
|
return code
|
|
}
|
|
|
|
// GenOnePrivateSceneId 生产一个私人房间id
|
|
func (m *SceneMgr) GenOnePrivateSceneId() int {
|
|
m.privateAutoId++
|
|
if m.privateAutoId > common.PrivateSceneMaxId {
|
|
m.privateAutoId = common.PrivateSceneStartId
|
|
}
|
|
return m.privateAutoId
|
|
}
|
|
|
|
// GenOneCoinSceneId 生产一个金币场房间id
|
|
func (m *SceneMgr) GenOneCoinSceneId() int {
|
|
m.coinSceneAutoId++
|
|
if m.coinSceneAutoId > common.CoinSceneMaxId {
|
|
m.coinSceneAutoId = common.CoinSceneStartId
|
|
}
|
|
return m.coinSceneAutoId
|
|
}
|
|
|
|
// GenOneHundredSceneId 生产一个百人场房间id
|
|
func (m *SceneMgr) GenOneHundredSceneId() int {
|
|
m.hundredSceneAutoId++
|
|
if m.hundredSceneAutoId > common.HundredSceneMaxId {
|
|
m.hundredSceneAutoId = common.HundredSceneStartId
|
|
}
|
|
return m.hundredSceneAutoId
|
|
}
|
|
|
|
// GenOneMatchSceneId 生产一个比赛场房间id
|
|
func (m *SceneMgr) GenOneMatchSceneId() int {
|
|
m.matchAutoId++
|
|
if m.matchAutoId > common.MatchSceneMaxId {
|
|
m.matchAutoId = common.MatchSceneStartId
|
|
}
|
|
return m.matchAutoId
|
|
}
|
|
|
|
// GetScene 获取房间对象
|
|
func (m *SceneMgr) GetScene(sceneId int) *Scene {
|
|
if s, exist := m.scenes[sceneId]; exist && !s.deleting {
|
|
return s
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetScenesByGame 根据游戏id查询房间
|
|
func (m *SceneMgr) GetScenesByGame(gameId int) []*Scene {
|
|
var scenes []*Scene
|
|
for _, value := range m.scenes {
|
|
if value.gameId == gameId {
|
|
s := m.GetScene(value.sceneId)
|
|
if s != nil {
|
|
scenes = append(scenes, value)
|
|
}
|
|
}
|
|
}
|
|
return scenes
|
|
}
|
|
|
|
// GetScenesByGameFreeId 根据场次id查询房间
|
|
func (m *SceneMgr) GetScenesByGameFreeId(gameFreeId int32) []*Scene {
|
|
var scenes []*Scene
|
|
for _, value := range m.scenes {
|
|
if value.dbGameFree.GetId() == gameFreeId {
|
|
s := m.GetScene(value.sceneId)
|
|
if s != nil {
|
|
scenes = append(scenes, value)
|
|
}
|
|
}
|
|
}
|
|
return scenes
|
|
}
|
|
|
|
// MarshalAllRoom 获取房间列表
|
|
func (m *SceneMgr) MarshalAllRoom(platform string, groupId, gameId int, gameMode, clubId, sceneMode, sceneId int,
|
|
gameFreeId, snId int32, start, end, pageSize int32) ([]*webapi2.RoomInfo, int32, int32) {
|
|
roomInfo := make([]*webapi2.RoomInfo, 0, len(m.scenes))
|
|
var isNeedFindAll = false
|
|
if model.GameParamData.IsFindRoomByGroup && platform != "" && snId != 0 && gameId == 0 &&
|
|
gameMode == 0 && sceneId == -1 && groupId == 0 && clubId == 0 && sceneMode == 0 {
|
|
p := PlayerMgrSington.GetPlayerBySnId(snId)
|
|
if p != nil && p.Platform == platform {
|
|
isNeedFindAll = true
|
|
}
|
|
}
|
|
for _, s := range m.scenes {
|
|
if (((s.limitPlatform != nil && s.limitPlatform.IdStr == platform) || platform == "") &&
|
|
((s.gameId == gameId && s.gameMode == gameMode) || gameId == 0) &&
|
|
(s.sceneId == sceneId || sceneId == 0) && (s.groupId == int32(groupId) || groupId == 0) &&
|
|
(s.ClubId == int32(clubId) || clubId == 0) && (s.dbGameFree.GetId() == gameFreeId || gameFreeId == 0) &&
|
|
(s.sceneMode == sceneMode || sceneMode == -1)) || isNeedFindAll {
|
|
var platformName string
|
|
if s.limitPlatform != nil {
|
|
platformName = s.limitPlatform.IdStr
|
|
}
|
|
|
|
si := &webapi2.RoomInfo{
|
|
Platform: platformName,
|
|
SceneId: int32(s.sceneId),
|
|
GameId: int32(s.gameId),
|
|
GameMode: int32(s.gameMode),
|
|
SceneMode: int32(s.sceneMode),
|
|
GroupId: s.groupId,
|
|
Creator: s.creator,
|
|
Agentor: s.agentor,
|
|
ReplayCode: s.replayCode,
|
|
Params: common.CopySliceInt64ToInt32(s.params),
|
|
PlayerCnt: int32(len(s.players) - s.robotNum),
|
|
RobotCnt: int32(s.robotNum),
|
|
CreateTime: s.createTime.Unix(),
|
|
BaseScore: s.dbGameFree.BaseScore,
|
|
}
|
|
if common.IsLocalGame(s.gameId) {
|
|
si.BaseScore = s.BaseScore
|
|
}
|
|
if s.paramsEx != nil && len(s.paramsEx) > 0 {
|
|
si.GameFreeId = s.paramsEx[0]
|
|
}
|
|
if s.starting {
|
|
si.Start = 1
|
|
} else {
|
|
si.Start = 0
|
|
}
|
|
if s.IsHundredScene() {
|
|
si.Start = 1
|
|
}
|
|
if s.gameSess != nil {
|
|
si.SrvId = s.gameSess.GetSrvId()
|
|
}
|
|
cnt := 0
|
|
total := len(s.players)
|
|
robots := []int32{}
|
|
|
|
isContinue := false
|
|
if snId != 0 {
|
|
for _, p := range s.players {
|
|
if p.SnId == int32(snId) {
|
|
isContinue = true
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
isContinue = true
|
|
}
|
|
if !isContinue {
|
|
continue
|
|
}
|
|
|
|
//优先显示玩家
|
|
for id, p := range s.players {
|
|
if !p.IsRob || total < 10 {
|
|
si.PlayerIds = append(si.PlayerIds, id)
|
|
cnt++
|
|
} else {
|
|
robots = append(robots, id)
|
|
}
|
|
if cnt > 10 {
|
|
break
|
|
}
|
|
}
|
|
//不够再显示机器人
|
|
if total > cnt && cnt < 10 && len(robots) != 0 {
|
|
for i := 0; cnt < 10 && i < len(robots); i++ {
|
|
si.PlayerIds = append(si.PlayerIds, robots[i])
|
|
cnt++
|
|
if cnt > 10 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
roomInfo = append(roomInfo, si)
|
|
}
|
|
}
|
|
|
|
sort.Slice(roomInfo, func(i, j int) bool {
|
|
if roomInfo[i].CreateTime < roomInfo[j].CreateTime ||
|
|
(roomInfo[i].CreateTime == roomInfo[j].CreateTime && roomInfo[i].SceneId < roomInfo[j].SceneId) {
|
|
return true
|
|
}
|
|
return false
|
|
})
|
|
|
|
//分页处理
|
|
roomSum := float64(len(roomInfo)) //房间总数
|
|
pageCount := int32(math.Ceil(roomSum / float64(pageSize))) //总页数
|
|
if roomSum <= float64(start) {
|
|
start = 0
|
|
}
|
|
if roomSum < float64(end) {
|
|
end = int32(roomSum)
|
|
}
|
|
needList := roomInfo[start:end] //需要的房间列表
|
|
if len(needList) > 0 {
|
|
return needList, pageCount, int32(roomSum)
|
|
}
|
|
return nil, 0, int32(roomSum)
|
|
}
|
|
|
|
// CreateScene 创建房间
|
|
func (m *SceneMgr) CreateScene(agentor, creator int32, sceneId, gameId, gameMode, sceneMode int, clycleTimes int32,
|
|
numOfGames int32, params []int64, gs *GameSession, limitPlatform *Platform, groupId int32, dbGameFree *serverproto.DB_GameFree,
|
|
paramsEx ...int32) *Scene {
|
|
logger.Logger.Trace("(this *SceneMgr) CreateScene ")
|
|
s := NewScene(agentor, creator, sceneId, gameId, gameMode, sceneMode, clycleTimes, numOfGames, params, gs, limitPlatform, groupId,
|
|
dbGameFree, paramsEx...)
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
|
|
m.scenes[sceneId] = s
|
|
if !s.IsMatchScene() && dbGameFree != nil && limitPlatform != nil {
|
|
//平台水池设置
|
|
gs.DetectCoinPoolSetting(limitPlatform.IdStr, dbGameFree.GetId(), s.groupId)
|
|
}
|
|
|
|
gs.AddScene(s)
|
|
var platformName string
|
|
if limitPlatform != nil {
|
|
platformName = limitPlatform.IdStr
|
|
}
|
|
logger.Logger.Infof("(this *SceneMgr) CreateScene (gameId=%v, mode=%v), SceneId=%v groupid=%v platform=%v",
|
|
gameId, gameMode, sceneId, groupId, platformName)
|
|
return s
|
|
}
|
|
|
|
// CreateLocalGameScene 创建本地游戏房间
|
|
func (m *SceneMgr) CreateLocalGameScene(creator int32, sceneId, gameId, gameSite, sceneMode int, clycleTimes int32, params []int64,
|
|
gs *GameSession, limitPlatform *Platform, playerNum int, dbGameFree *serverproto.DB_GameFree, baseScore, groupId int32,
|
|
paramsEx ...int32) *Scene {
|
|
logger.Logger.Trace("(this *SceneMgr) CreateLocalGameScene gameSite: ", gameSite, " sceneMode: ", sceneMode)
|
|
s := NewLocalGameScene(creator, sceneId, gameId, gameSite, sceneMode, clycleTimes, params, gs, limitPlatform, playerNum, dbGameFree,
|
|
baseScore, groupId, paramsEx...)
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
|
|
m.scenes[sceneId] = s
|
|
gs.AddScene(s)
|
|
|
|
var platformName string
|
|
if limitPlatform != nil {
|
|
platformName = limitPlatform.IdStr
|
|
}
|
|
logger.Logger.Infof("(this *SceneMgr) CreateScene (gameId=%v), SceneId=%v platform=%v", gameId, sceneId, platformName)
|
|
return s
|
|
}
|
|
|
|
// DestroyScene 解散房间
|
|
// 房间销毁，游戏服务断开
|
|
func (m *SceneMgr) DestroyScene(sceneId int, isCompleted bool) {
|
|
logger.Logger.Trace("(this *SceneMgr) DestroyScene ")
|
|
s, ok := m.scenes[sceneId]
|
|
if !ok || s == nil {
|
|
return
|
|
}
|
|
|
|
switch {
|
|
case s.IsCoinScene():
|
|
CoinSceneMgrSingleton.OnDestroyScene(s.sceneId)
|
|
|
|
case s.IsHundredScene():
|
|
HundredSceneMgrSington.OnDestroyScene(s.sceneId)
|
|
|
|
case s.IsMatchScene():
|
|
MatchSceneMgrSingleton.OnDestroyScene(s.sceneId)
|
|
}
|
|
|
|
s.gameSess.DelScene(s)
|
|
s.OnClose()
|
|
delete(m.scenes, s.sceneId)
|
|
logger.Logger.Infof("(this *SceneMgr) DestroyScene, SceneId=%v", sceneId)
|
|
}
|
|
|
|
func (m *SceneMgr) OnPlayerLeaveScene(s *Scene, p *Player) {
|
|
logger.Logger.Trace("(this *SceneMgr) OnPlayerLeaveScene", p.SnId)
|
|
|
|
// 记录玩家在每个游戏场次最后进入的房间号
|
|
// 只记录金币场
|
|
if s.IsCoinScene() {
|
|
const MINHOLD = 10
|
|
const MAXHOLD = 20
|
|
holdCnt := MINHOLD
|
|
if s.csp != nil {
|
|
holdCnt = s.csp.GetHasTruePlayerSceneCnt() + 2
|
|
if holdCnt < MINHOLD {
|
|
holdCnt = MINHOLD
|
|
}
|
|
if holdCnt > MAXHOLD {
|
|
holdCnt = MAXHOLD
|
|
}
|
|
}
|
|
if p.lastSceneId == nil {
|
|
p.lastSceneId = make(map[int32][]int32)
|
|
}
|
|
id := s.dbGameFree.GetId()
|
|
if sceneIds, exist := p.lastSceneId[id]; exist {
|
|
if !common.InSliceInt32(sceneIds, int32(s.sceneId)) {
|
|
sceneIds = append(sceneIds, int32(s.sceneId))
|
|
cnt := len(sceneIds)
|
|
if cnt > holdCnt {
|
|
sceneIds = sceneIds[cnt-holdCnt:]
|
|
}
|
|
p.lastSceneId[id] = sceneIds
|
|
}
|
|
} else {
|
|
p.lastSceneId[id] = []int32{int32(s.sceneId)}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m *SceneMgr) DoDelete(sceneId []int, isGrace bool) {
|
|
if len(sceneId) == 0 {
|
|
return
|
|
}
|
|
var ids []int64
|
|
for _, v := range sceneId {
|
|
ids = append(ids, int64(v))
|
|
s, ok := m.scenes[v]
|
|
if !isGrace && ok && s != nil {
|
|
s.deleting = true
|
|
s.force = true
|
|
}
|
|
}
|
|
pack := &serverproto.WGDestroyScene{
|
|
Ids: ids,
|
|
IsGrace: isGrace,
|
|
}
|
|
srvlib.ServerSessionMgrSington.Broadcast(int(serverproto.SSPacketID_PACKET_WG_DESTROYSCENE), pack, common.GetSelfAreaId(), srvlib.GameServerType)
|
|
}
|
|
|
|
// GetThirdScene 获取三方游戏房间
|
|
//func (m *SceneMgr) GetThirdScene(i webapi.IThirdPlatform) *Scene {
|
|
// if i == nil {
|
|
// return nil
|
|
// }
|
|
// sceneId := i.GetPlatformBase().SceneId
|
|
// scene := m.scenes[sceneId]
|
|
// if scene != nil {
|
|
// return scene
|
|
// }
|
|
//
|
|
// gs := GameSessMgrSington.GetMinLoadSess(i.GetPlatformBase().BaseGameID)
|
|
// if gs != nil {
|
|
// limitPlatform := PlatformMgrSingleton.GetPlatform(DefaultPlatform)
|
|
// var gameMode = common.SceneMode_Thr
|
|
// dbGameFree := srvdata.PBDB_GameFreeMgr.GetData(i.GetPlatformBase().VultGameID)
|
|
// scene := SceneMgrSingleton.CreateScene(0, 0, sceneId, i.GetPlatformBase().BaseGameID, gameMode, int(common.SceneMode_Thr), 1, -1,
|
|
// []int64{}, gs, limitPlatform, 0, dbGameFree, i.GetPlatformBase().VultGameID)
|
|
// return scene
|
|
// } else {
|
|
// logger.Logger.Errorf("Get %v game min session failed.", i.GetPlatformBase().BaseGameID)
|
|
// return nil
|
|
// }
|
|
//}
|
|
|
|
//=========================ClockSinker===============================
|
|
|
|
// InterestClockEvent 接收所有时间事件
|
|
func (m *SceneMgr) InterestClockEvent() int {
|
|
return 1 << CLOCK_EVENT_MINUTE
|
|
}
|
|
|
|
func (m *SceneMgr) OnMiniTimer() {
|
|
// 解散空闲房间
|
|
for _, s := range m.scenes {
|
|
if webapi.ThridPlatformMgrSington.FindPlatformByPlatformBaseGameId(s.gameId) != nil {
|
|
continue
|
|
}
|
|
switch {
|
|
case s.IsCoinScene():
|
|
if s.IsLongTimeInactive() {
|
|
if s.dbGameFree.GetCreateRoomNum() == 0 {
|
|
logger.Logger.Warnf("SceneMgr.DeleteLongTimeInactive CoinScene DoDelete scene:%v IsLongTimeInactive", s.sceneId)
|
|
s.DoDelete(false)
|
|
}
|
|
if s.dbGameFree.GetCreateRoomNum() > 0 && s.csp != nil && s.csp.GetRoomNum() > int(s.dbGameFree.GetCreateRoomNum()) {
|
|
logger.Logger.Warnf("SceneMgr.DeleteLongTimeInactive CoinScene DoDelete scene:%v IsLongTimeInactive", s.sceneId)
|
|
s.DoDelete(false)
|
|
}
|
|
}
|
|
case s.IsPrivateScene():
|
|
if s.IsLongTimeInactive() {
|
|
logger.Logger.Warnf("SceneMgr.DeleteLongTimeInactive PrivateScene DoDelete scene:%v IsLongTimeInactive", s.sceneId)
|
|
s.DoDelete(false)
|
|
}
|
|
}
|
|
}
|
|
}
|