public static void Update()
{
if (ZhanDuiZhengBa_K.Initialize)
{
DateTime now = TimeUtil.NowDateTime();
if (now.Day != ZhanDuiZhengBa_K.lastUpdateTime.Day)
{
ZhanDuiZhengBa_K.FixSyncData(now);
}
else
{
lock (ZhanDuiZhengBa_K.Mutex)
{
ZhanDuiZhengBa_K.StateMachine.Tick(now);
}
}
KFCallMsg[] asyncEvArray = null;
lock (ZhanDuiZhengBa_K.Mutex)
{
asyncEvArray = ZhanDuiZhengBa_K.AsyncEvQ.ToArray();
ZhanDuiZhengBa_K.AsyncEvQ.Clear();
}
foreach (KFCallMsg msg in asyncEvArray)
{
ClientAgentManager.Instance().BroadCastMsg(msg, 0);
}
ZhanDuiZhengBa_K.lastUpdateTime = now;
}
}
public static bool InitializeClient(AutoCSer.Net.TcpInternalServer.ServerSocketSender socket, KuaFuClientContext clientInfo)
{
bool isLogin = false;
try
{
if (clientInfo.ServerId != 0)
{
bool bFirstInit = false;
int ret = ClientAgentManager.Instance().InitializeClient(clientInfo, out bFirstInit);
if (ret > 0)
{
isLogin = true;
socket.ClientObject = ClientAgentManager.Instance().GetCurrentClientAgent(clientInfo.ServerId);
if (clientInfo.MapClientCountDict != null && clientInfo.MapClientCountDict.Count > 0)
{
KuaFuServerManager.UpdateKuaFuLineData(clientInfo.ServerId, clientInfo.MapClientCountDict);
ClientAgentManager.Instance().SetMainlinePayload(clientInfo.ServerId, clientInfo.MapClientCountDict.Values.ToList <int>().Sum());
}
}
}
else
{
LogManager.WriteLog(LogTypes.Error, string.Format("InitializeClient时GameType错误,禁止连接.ServerId:{0},GameType:{1}", clientInfo.ServerId, clientInfo.GameType), null, true);
}
}
catch (Exception ex)
{
LogManager.WriteExceptionUseCache(string.Format("InitializeClient服务器ID重复,禁止连接.ServerId:{0},ClientId:{1},info:{2}", clientInfo.ServerId, clientInfo.ClientId, clientInfo.Token));
}
return(isLogin);
}
public static void NotifyFuBenRoleEnterGame(KuaFu5v5FuBenData fuBenData)
{
try
{
lock (fuBenData)
{
List <int> serverIDs = new List <int>();
foreach (KuaFuFuBenRoleData role in fuBenData.RoleDict.Values)
{
if (!serverIDs.Contains(role.ServerId))
{
serverIDs.Add(role.ServerId);
AsyncDataItem evItem = new AsyncDataItem(KuaFuEventTypes.KuaFu5v5UpdateAndNotifyEnterGame, new object[]
{
fuBenData
});
ClientAgentManager.Instance().PostAsyncEvent(role.ServerId, TianTi5v5Service.ChannelGameType, evItem);
}
}
}
}
catch (Exception ex)
{
}
}
public static void RemoveGameFuBen(KuaFu5v5FuBenData KuaFu5v5FuBenData)
{
int gameId = KuaFu5v5FuBenData.GameId;
KuaFu5v5FuBenData KuaFu5v5FuBenDataTemp;
if (TianTi5v5Service.FuBenDataDict.TryRemove(gameId, out KuaFu5v5FuBenDataTemp))
{
KuaFu5v5FuBenDataTemp.State = GameFuBenState.End;
}
ClientAgentManager.Instance().RemoveKfFuben(TianTi5v5Service.GameType, KuaFu5v5FuBenData.ServerId, (long)KuaFu5v5FuBenData.GameId);
lock (KuaFu5v5FuBenData)
{
foreach (KeyValuePair <int, int> kv in KuaFu5v5FuBenData.ZhanDuiDict)
{
KF5v5PiPeiTeam team;
if (TianTi5v5Service.PiPeiDict.TryGetValue(kv.Key, out team))
{
if (team.GameId == gameId && team.State >= 3)
{
team.State = 0;
}
}
}
}
}
public static void Update()
{
if (EscapeBattle_K.Initialize)
{
DateTime now = TimeUtil.NowDateTime();
TimeSpan timeOfWeek = TimeUtil.TimeOfWeek(now);
bool open = false;
lock (EscapeBattle_K.Mutex)
{
List <TimeSpan> list = EscapeBattle_K._Config.MatchConfigList[0].TimePoints;
for (int i = 0; i < list.Count - 1; i += 2)
{
if (list[i] <= timeOfWeek && timeOfWeek < list[i + 1])
{
open = true;
break;
}
}
if (EscapeBattle_K.SyncData.State != open)
{
EscapeBattle_K.SyncData.State = open;
}
int nowSecs = (int)now.TimeOfDay.TotalSeconds;
if (nowSecs / EscapeBattleConsts.BattleSignSecs != EscapeBattle_K.LastMatchMinute / EscapeBattleConsts.BattleSignSecs)
{
EscapeBattle_K.LastMatchMinute = nowSecs;
EscapeBattle_K.PrepareMatchList();
}
EscapeBattle_K.PrepareGameFuBen(now);
if (open)
{
if (!EscapeBattle_K.NeedUpdateRank)
{
EscapeBattle_K.NeedUpdateRank = true;
}
}
else if ((EscapeBattle_K.NeedUpdateRank && EscapeBattle_K.ThisLoopPkLogs.Count == 0) || EscapeBattle_K.lastUpdateTime.Day != now.Day)
{
EscapeBattle_K.NeedUpdateRank = false;
EscapeBattle_K.LoadSyncData(now, true);
}
EscapeBattle_K.ClearTimeOverGameFuBen(now);
}
KFCallMsg[] asyncEvArray = null;
lock (EscapeBattle_K.Mutex)
{
asyncEvArray = EscapeBattle_K.AsyncEvQ.ToArray();
EscapeBattle_K.AsyncEvQ.Clear();
}
foreach (KFCallMsg msg in asyncEvArray)
{
ClientAgentManager.Instance().BroadCastMsg(msg, 0);
}
EscapeBattle_K.lastUpdateTime = now;
}
}
public static void UpdateKuaFuMapClientCount(AutoCSer.Net.TcpInternalServer.ServerSocketSender socket, int serverId, Dictionary <int, int> mapClientCountDict)
{
ClientAgent agent = socket.ClientObject as ClientAgent;
if (mapClientCountDict != null && mapClientCountDict.Count > 0)
{
KuaFuServerManager.UpdateKuaFuLineData(agent.ClientInfo.ServerId, mapClientCountDict);
ClientAgentManager.Instance().SetMainlinePayload(agent.ClientInfo.ServerId, mapClientCountDict.Values.ToList <int>().Sum());
}
}
private void HandleUnCompleteFuBenData()
{
foreach (KeyValuePair <int, KuaFu5v5FuBenData> fubenItem in this.FuBenDataDict)
{
KuaFu5v5FuBenData fubenData = fubenItem.Value;
ClientAgentManager.Instance().RemoveKfFuben(this.GameType, fubenData.ServerId, (long)fubenData.GameId);
}
this.FuBenDataDict.Clear();
this.ZhanDuiIDVsGameIDDict.Clear();
}
public static int GameResult(int gameId, List <int> zhanDuiScoreList)
{
int result;
lock (EscapeBattle_K.Mutex)
{
EscapeBattlePkLogData log = null;
LogManager.WriteLog(LogTypes.Trace, string.Format("EscapeBattle::GameResult,gameid={0},scoreList={1}", gameId, string.Join <int>("_", zhanDuiScoreList)), null, true);
if (!EscapeBattle_K.ThisLoopPkLogs.TryGetValue(gameId, out log))
{
result = 3;
}
else
{
DateTime now = TimeUtil.NowDateTime();
for (int i = 0; i < zhanDuiScoreList.Count - 1; i += 2)
{
int zhanDuiID = zhanDuiScoreList[i];
int score = zhanDuiScoreList[i + 1];
if (log.ZhanDuiIDs.Contains(zhanDuiID))
{
EscapeBattle_K.JoinPkData pkData;
if (EscapeBattle_K.JoinDict.TryGetValue(zhanDuiID, out pkData))
{
if (pkData.InGame)
{
pkData.InGame = false;
pkData.CurrGameID = 0;
pkData.DuanWeiJiFen = TianTi5v5Service.UpdateEscapeZhanDui(pkData.ZhanDuiID, score, now);
}
}
LogManager.WriteLog(LogTypes.Trace, string.Format("EscapeBattle::GameResult,gameid={0},zhanduiid={1},score={2}", gameId, zhanDuiID, score), null, true);
EscapeBattle_K.ZhanDuiChangeState(pkData, 5);
}
}
bool canRemove = true;
foreach (int zhanDuiID in log.ZhanDuiIDs)
{
EscapeBattle_K.JoinPkData pkData;
if (EscapeBattle_K.JoinDict.TryGetValue(zhanDuiID, out pkData) && pkData.InGame)
{
canRemove = false;
}
}
if (canRemove)
{
EscapeBattle_K.ThisLoopPkLogs.Remove(gameId);
ClientAgentManager.Instance().RemoveKfFuben(EscapeBattle_K.GameType, log.ToServerID, (long)log.GameID);
}
result = 0;
}
}
return(result);
}
public int GameFuBenComplete_ZorkBattle(ZorkBattleStatisticalData data)
{
int result = 0;
try
{
lock (this.Mutex)
{
KuaFu5v5FuBenData fubenData;
if (!this.FuBenDataDict.TryGetValue(data.GameId, out fubenData))
{
result = -4000;
return(result);
}
ClientAgentManager.Instance().RemoveKfFuben(this.GameType, fubenData.ServerId, (long)data.GameId);
this.FuBenDataDict.Remove(data.GameId);
foreach (KeyValuePair <int, int> item in fubenData.ZhanDuiDict)
{
this.ZhanDuiIDVsGameIDDict.Remove(item.Key);
}
foreach (KeyValuePair <int, TianTi5v5ZhanDuiData> item2 in data.ZhanDuiDict)
{
TianTi5v5ZhanDuiData zhanduiData = item2.Value;
TianTi5v5Service.UpdateZorkZhanDuiData(zhanduiData);
}
foreach (ZorkBattleRoleInfo client in data.ClientContextDataList)
{
this.Persistence.UpdateZorkBattleRoleData(client, true);
}
string zhanduiIdArray = string.Join <int>("|", data.ZhanDuiDict.Keys.ToArray <int>());
string strLog = string.Format("Zork::GameFuBenComplete_ZorkBattle SeasonID:{0} GameID:{1} ZhanDuiIDWin:{2} ZhanDuiID:{3} Round:{2} ZhanDuiInfo:", new object[]
{
this.CurrentSeasonID,
data.GameId,
data.ZhanDuiIDWin,
zhanduiIdArray,
this.CurrentRound
});
foreach (KeyValuePair <int, TianTi5v5ZhanDuiData> item2 in data.ZhanDuiDict)
{
TianTi5v5ZhanDuiData zhanduiData = item2.Value;
strLog += string.Format(" [ZhanDuiID:{0} JiFen:{1}]", item2.Key, zhanduiData.ZorkJiFen);
}
LogManager.WriteLog(LogTypes.Analysis, strLog, null, true);
return(result);
}
}
catch (Exception ex)
{
result = -11;
LogManager.WriteLog(LogTypes.Error, "Zork5v5Service.GameFuBenComplete_ZorkBattle failed!", ex, true);
}
return(result);
}
private void AssginKfFuben(KuaFu5v5FuBenData fubenData)
{
int toServerId = 0;
int gameId = 0;
gameId = TianTiPersistence.Instance.GetNextGameId();
int roleNum = fubenData.ZhanDuiDict.Count * 5;
if (ClientAgentManager.Instance().AssginKfFuben(this.GameType, (long)gameId, roleNum, out toServerId))
{
fubenData.ServerId = toServerId;
fubenData.GameId = gameId;
fubenData.GameType = (int)this.GameType;
fubenData.LoginInfo = KuaFuServerManager.GetKuaFuLoginInfo(0, toServerId);
this.FuBenDataDict[gameId] = fubenData;
foreach (int zhanDuiID in fubenData.ZhanDuiDict.Keys)
{
this.ZhanDuiIDVsGameIDDict[zhanDuiID] = gameId;
KF5v5PiPeiTeam kuaFuRoleDataTemp;
if (this.PiPeiDict.TryGetValue(zhanDuiID, out kuaFuRoleDataTemp))
{
kuaFuRoleDataTemp.GameId = fubenData.GameId;
}
}
string zhanduiIdArray = string.Join <int>("|", fubenData.ZhanDuiDict.Keys.ToArray <int>());
LogManager.WriteLog(LogTypes.Analysis, string.Format("Zork::分组 SeasonID:{0} gameId:{1} zhanduiId:{2} Round:{3}", new object[]
{
this.CurrentSeasonID,
gameId,
zhanduiIdArray,
this.CurrentRound
}), null, true);
}
else
{
string zhanduiIdArray = string.Join <int>("|", fubenData.ZhanDuiDict.Keys.ToArray <int>());
LogManager.WriteLog(LogTypes.Analysis, string.Format("Zork::分配游戏服务器失败 SeasonID:{0} gameId:{1} zhanduiId:{2} Round:{3}", new object[]
{
this.CurrentSeasonID,
gameId,
zhanduiIdArray,
this.CurrentRound
}), null, true);
}
}
private static void ZhanDuiChangeState(EscapeBattle_K.JoinPkData pkData, int state)
{
int zhanDuiState = 0;
if (state >= 5)
{
pkData.InGame = false;
zhanDuiState = 0;
}
pkData.State = zhanDuiState;
int sid = KuaFuServerManager.GetServerIDFromZoneID(pkData.ZoneId);
ClientAgentManager.Instance().SendMsg(sid, KFCallMsg.New <int[]>(KuaFuEventTypes.EscapeBattle_GameState, new int[]
{
pkData.ZhanDuiID,
pkData.CurrGameID,
zhanDuiState
}));
}
public static void ThreadProc(object state)
{
if (TianTi5v5Service.ThreadInit)
{
try
{
DateTime now = TimeUtil.NowDateTime();
Global.UpdateNowTime(now);
if (now > TianTi5v5Service.CheckRoleTimerProcTime)
{
TianTi5v5Service.CheckRoleTimerProcTime = now.AddSeconds(1.428);
int signUpCnt;
int startCnt;
TianTi5v5Service.CheckRoleTimerProc(now, out signUpCnt, out startCnt);
ClientAgentManager.Instance().SetGameTypeLoad(TianTi5v5Service.GameType, signUpCnt, startCnt);
}
if (now > TianTi5v5Service.SaveServerStateProcTime)
{
TianTi5v5Service.SaveServerStateProcTime = now.AddSeconds(30.0);
if (now.Hour >= 3 && now.Hour < 4)
{
TianTi5v5Service.ClearRolePairFightCount();
TianTi5v5Service.UpdateZhanDuiRankData(now, false);
ZhanDuiZhengBa_K.LoadSyncData(now, false);
}
}
if (now > TianTi5v5Service.CheckGameFuBenTime)
{
TianTi5v5Service.CheckGameFuBenTime = now.AddSeconds(1000.0);
TianTi5v5Service.CheckGameFuBenTimerProc(now);
}
TianTi5v5Service.Persistence.DelayWriteDataProc();
}
catch (Exception ex)
{
LogManager.WriteExceptionUseCache(ex.ToString());
}
}
}
private static void ClearTimeOverGameFuBen(DateTime now)
{
List <int> PkLogsRemoveList = new List <int>();
foreach (int gameID in EscapeBattle_K.ThisLoopPkLogs.Keys.ToList <int>())
{
EscapeBattlePkLogData log;
if (EscapeBattle_K.ThisLoopPkLogs.TryGetValue(gameID, out log))
{
if (log.EndTime < now || log.State >= 7)
{
List <int> scoreList = new List <int>();
foreach (int zhanDuiID in log.ZhanDuiIDs)
{
scoreList.Add(zhanDuiID);
scoreList.Add(int.MinValue);
}
try
{
EscapeBattle_K.GameResult(gameID, scoreList);
}
catch (Exception ex)
{
LogManager.WriteException(ex.ToString());
PkLogsRemoveList.Add(log.GameID);
}
}
}
}
foreach (int gameid in PkLogsRemoveList)
{
EscapeBattlePkLogData log;
if (EscapeBattle_K.ThisLoopPkLogs.TryGetValue(gameid, out log))
{
EscapeBattle_K.ThisLoopPkLogs.Remove(gameid);
ClientAgentManager.Instance().RemoveKfFuben(EscapeBattle_K.GameType, log.ToServerID, (long)log.GameID);
}
}
}
private static void MS_PkLoopEnd_Update(DateTime now)
{
ZhanDuiZhengBaMatchConfig matchConfig = ZhanDuiZhengBa_K._Config.MatchConfigList.Find((ZhanDuiZhengBaMatchConfig _m) => _m.ID == ZhanDuiZhengBa_K.SyncData.RealActID);
if (now.TimeOfDay.Ticks >= matchConfig.DayBeginTick + 10000000L * (long)(matchConfig.WaitSeconds + matchConfig.FightSeconds + matchConfig.ClearSeconds))
{
foreach (ZhanDuiZhengBaPkLogData kvp in ZhanDuiZhengBa_K.ThisLoopPkLogs.Values.ToList <ZhanDuiZhengBaPkLogData>())
{
ZhanDuiZhengBa_K.ZhengBaPkResult((int)kvp.GameID, kvp.BetterZhanDuiID);
}
ZhanDuiZhengBa_K.ThisLoopPkLogs.Clear();
foreach (ZhanDuiZhengBa_K.JoinRolePkData role in ZhanDuiZhengBa_K.TodayJoinRoleDatas)
{
if (role.CurrGameID > 0 || role.ToServerID > 0)
{
ClientAgentManager.Instance().RemoveKfFuben(ZhanDuiZhengBa_K.GameType, role.ToServerID, (long)role.CurrGameID);
}
role.ToServerID = 0;
role.CurrGameID = 0;
}
ZhanDuiZhengBa_K.StateMachine.SetCurrState(3, now);
}
}
private void MS_NotifyEnter_Update(DateTime now, int param)
{
ZorkBattleSceneInfo matchConfig = this.SceneDataDict.Values.FirstOrDefault <ZorkBattleSceneInfo>();
Zork5v5StateMachine.StateType GameState = Zork5v5StateMachine.StateType.None;
for (int i = 0; i < matchConfig.TimePoints.Count - 1; i += 2)
{
if (now.DayOfWeek == (DayOfWeek)matchConfig.TimePoints[i].Days)
{
int RoundSeconds = matchConfig.BattleSignSecs + matchConfig.PrepareSecs + matchConfig.FightingSecs + matchConfig.ClearRolesSecs;
int MatchPerRound = (int)(matchConfig.SecondsOfDay[i + 1] - matchConfig.SecondsOfDay[i]) / RoundSeconds;
for (int matchloop = 0; matchloop < MatchPerRound; matchloop++)
{
int signSeconds = (int)matchConfig.SecondsOfDay[i] + RoundSeconds * matchloop;
int startSeconds = signSeconds + matchConfig.BattleSignSecs;
int endSeconds = startSeconds + RoundSeconds - matchConfig.BattleSignSecs;
if ((double)startSeconds <= now.TimeOfDay.TotalSeconds && now.TimeOfDay.TotalSeconds < (double)endSeconds)
{
GameState = Zork5v5StateMachine.StateType.GameStart;
}
}
}
}
if (GameState == Zork5v5StateMachine.StateType.GameStart)
{
foreach (KuaFu5v5FuBenData item in this.FuBenDataDict.Values)
{
KuaFu5v5FuBenData SyncData = item;
ClientAgentManager.Instance().BroadCastAsyncEvent(this.EvItemGameType, new AsyncDataItem(KuaFuEventTypes.Zork5v5NtfEnter, new object[]
{
SyncData
}), 0);
}
this.StateMachine.SetCurrState(GameState, now, param);
LogManager.WriteLog(LogTypes.Analysis, string.Format("Zork::MS_NotifyEnter_Update To:{0} SeasonID:{1} Round:{2}", GameState, this.CurrentSeasonID, this.CurrentRound), null, true);
}
}
public void KFSendPeriodsData()
{
ClientAgentManager.Instance().BroadCastMsg(KFCallMsg.New <OpenLottery>(KuaFuEventTypes.BoCaiPeriodsData, this.GetOpenLottery()), 0);
}
private static bool CreateGameFuBen(DateTime now, ZhanDuiZhengBaMatchConfig matchConfig, ZhanDuiZhengBa_K.JoinRolePkData joinRole1, ZhanDuiZhengBa_K.JoinRolePkData joinRole2)
{
bool result;
if (joinRole1.CurrGameID > 0)
{
result = true;
}
else
{
int betterZhanDuiID = (joinRole1.Rank < joinRole2.Rank) ? joinRole1.ZhanDuiID : joinRole2.ZhanDuiID;
int toServerId = 0;
int gameId = TianTiPersistence.Instance.GetNextGameId();
if (ClientAgentManager.Instance().AssginKfFuben(ZhanDuiZhengBa_K.GameType, (long)gameId, 10, out toServerId))
{
ZhanDuiZhengBaFuBenData copyData = new ZhanDuiZhengBaFuBenData();
copyData.GameID = (long)gameId;
copyData.SideDict[(long)joinRole1.ZhanDuiID] = 1;
copyData.SideDict[(long)joinRole2.ZhanDuiID] = 2;
copyData.BetterZhanDuiID = betterZhanDuiID;
copyData.ConfigID = matchConfig.ID;
copyData.JoinGrade = (int)matchConfig.JoinGrade;
copyData.NewGrade = (int)matchConfig.WillUpGrade;
copyData.ServerID = toServerId;
copyData.RoleDict.AddRange(TianTi5v5Service.GetZhanDuiMemberIDs(joinRole1.ZhanDuiID));
if (joinRole1.ZhanDuiID != joinRole2.ZhanDuiID)
{
copyData.RoleDict.AddRange(TianTi5v5Service.GetZhanDuiMemberIDs(joinRole2.ZhanDuiID));
}
joinRole1.ToServerID = (joinRole2.ToServerID = toServerId);
joinRole1.CurrGameID = (joinRole2.CurrGameID = gameId);
joinRole1.CopyData = (joinRole2.CopyData = copyData);
joinRole1.WaitReqEnter = (joinRole2.WaitReqEnter = true);
ZhanDuiZhengBaNtfEnterData data = new ZhanDuiZhengBaNtfEnterData();
data.ZhanDuiID1 = joinRole1.ZhanDuiID;
data.ZhanDuiID2 = joinRole2.ZhanDuiID;
data.ToServerId = toServerId;
data.GameId = gameId;
data.Day = ZhanDuiZhengBa_K.SyncData.RealActID;
ZhanDuiZhengBa_K.AsyncEvQ.Enqueue(KFCallMsg.New <ZhanDuiZhengBaNtfEnterData>(KuaFuEventTypes.ZhanDuiZhengBa_NotifyEnter, data));
LogManager.WriteLog(LogTypes.Info, string.Format("战队争霸第{0}轮战队成员通知入场，zhanduiID1={1},zhanduiID2={2}", ZhanDuiZhengBa_K.SyncData.RealActID, joinRole1.ZhanDuiID, joinRole2.ZhanDuiID), null, true);
ZhanDuiZhengBaPkLogData log = new ZhanDuiZhengBaPkLogData();
log.Month = ZhanDuiZhengBa_K.SyncData.Month;
log.ID = ZhanDuiZhengBa_K.SyncData.RealActID;
log.ZhanDuiID1 = joinRole1.ZhanDuiID;
log.ZoneID1 = joinRole1.ZoneId;
log.ZhanDuiName1 = joinRole1.RoleName;
log.ZhanDuiID2 = joinRole2.ZhanDuiID;
log.ZoneID2 = joinRole2.ZoneId;
log.ZhanDuiName2 = joinRole2.RoleName;
log.StartTime = now;
log.BetterZhanDuiID = betterZhanDuiID;
log.GameID = (long)gameId;
ZhanDuiZhengBa_K.ThisLoopPkLogs[gameId] = log;
result = true;
}
else
{
LogManager.WriteLog(LogTypes.Error, string.Format("战队争霸第{0}轮分配游戏服务器失败，zhanduiID1={1},zhanduiID2={2}", ZhanDuiZhengBa_K.SyncData.RealActID, joinRole1.ZhanDuiID, joinRole2.ZhanDuiID), null, true);
result = false;
}
}
return(result);
}
public static bool AssignGameFuben(KF5v5PiPeiTeam kuaFuRoleData, RangeKey range, DateTime now)
{
int roleCount = 0;
DateTime stateEndTime = now.AddSeconds((double)TianTi5v5Service.EnterGameSecs);
List <KuaFuFuBenRoleData> updateRoleDataList = new List <KuaFuFuBenRoleData>();
KuaFu5v5FuBenData KuaFu5v5FuBenData = new KuaFu5v5FuBenData();
int side = 0;
int removeZhanDuiIDFromPiPeiList = 0;
KF5v5PiPeiTeam team = kuaFuRoleData;
if (Consts.TianTiRoleCountTotal > 1)
{
foreach (Tuple <KF5v5PiPeiTeam, int, int, int> z in TianTi5v5Service.ProcessPiPeiList)
{
if (z.Item2 >= range.Left && z.Item2 <= range.Right)
{
if (kuaFuRoleData.GroupIndex >= z.Item3 && kuaFuRoleData.GroupIndex <= z.Item4)
{
if (TianTi5v5Service.CanAddFuBenRole(kuaFuRoleData.TeamID, z.Item1.TeamID))
{
removeZhanDuiIDFromPiPeiList = z.Item1.TeamID;
team = z.Item1;
if (KuaFu5v5FuBenData.AddZhanDui(team.TeamID, ref roleCount, ref side))
{
TianTi5v5ZhanDuiData teamData;
if (TianTi5v5Service.ZhanDuiDict.TryGetValue(team.TeamID, out teamData))
{
foreach (TianTi5v5ZhanDuiRoleData role in teamData.teamerList)
{
KuaFuFuBenRoleData kuaFuFuBenRoleData = new KuaFuFuBenRoleData
{
ServerId = team.ServerID,
RoleId = role.RoleID,
Side = side
};
KuaFu5v5FuBenData.AddKuaFuFuBenRoleData(kuaFuFuBenRoleData, team.TeamID);
}
}
}
}
}
}
}
if (removeZhanDuiIDFromPiPeiList == 0)
{
TianTi5v5Service.ProcessPiPeiList.Add(new Tuple <KF5v5PiPeiTeam, int, int, int>(kuaFuRoleData, kuaFuRoleData.GroupIndex, range.Left, range.Right));
return(true);
}
TianTi5v5Service.ProcessPiPeiList.RemoveAll((Tuple <KF5v5PiPeiTeam, int, int, int> x) => x.Item1.TeamID == removeZhanDuiIDFromPiPeiList);
TianTi5v5Service.ProcessPiPeiList.RemoveAll((Tuple <KF5v5PiPeiTeam, int, int, int> x) => x.Item1.TeamID == kuaFuRoleData.TeamID);
}
team = kuaFuRoleData;
if (KuaFu5v5FuBenData.AddZhanDui(team.TeamID, ref roleCount, ref side))
{
TianTi5v5ZhanDuiData teamData;
if (TianTi5v5Service.ZhanDuiDict.TryGetValue(team.TeamID, out teamData))
{
foreach (TianTi5v5ZhanDuiRoleData role in teamData.teamerList)
{
KuaFuFuBenRoleData kuaFuFuBenRoleData = new KuaFuFuBenRoleData
{
ServerId = team.ServerID,
RoleId = role.RoleID,
Side = side
};
KuaFu5v5FuBenData.AddKuaFuFuBenRoleData(kuaFuFuBenRoleData, team.TeamID);
}
}
}
try
{
int kfSrvId = 0;
int gameId = TianTi5v5Service.Persistence.GetNextGameId();
bool createSuccess = ClientAgentManager.Instance().AssginKfFuben(TianTi5v5Service.GameType, (long)gameId, roleCount, out kfSrvId);
if (createSuccess)
{
KuaFu5v5FuBenData.ServerId = kfSrvId;
KuaFu5v5FuBenData.GameId = gameId;
KuaFu5v5FuBenData.GameType = (int)TianTi5v5Service.GameType;
KuaFu5v5FuBenData.EndTime = Global.NowTime.AddMinutes(8.0);
KuaFu5v5FuBenData.LoginInfo = KuaFuServerManager.GetKuaFuLoginInfo(kuaFuRoleData.ServerID, kfSrvId);
TianTi5v5Service.AddGameFuBen(KuaFu5v5FuBenData);
TianTi5v5Service.Persistence.LogCreateTianTiFuBen(KuaFu5v5FuBenData.GameId, KuaFu5v5FuBenData.ServerId, 0, roleCount);
foreach (int zhanDuiID in KuaFu5v5FuBenData.ZhanDuiDict.Keys)
{
KF5v5PiPeiTeam kuaFuRoleDataTemp;
if (TianTi5v5Service.PiPeiDict.TryGetValue(zhanDuiID, out kuaFuRoleDataTemp))
{
kuaFuRoleDataTemp.State = 3;
kuaFuRoleDataTemp.StateEndTicks = stateEndTime.Ticks;
kuaFuRoleDataTemp.GameId = KuaFu5v5FuBenData.GameId;
}
}
KuaFu5v5FuBenData.State = GameFuBenState.Start;
TianTi5v5Service.NotifyFuBenRoleEnterGame(KuaFu5v5FuBenData);
TianTi5v5Service.AddRolePairFightCount(KuaFu5v5FuBenData);
return(true);
}
return(false);
}
catch (Exception ex)
{
LogManager.WriteExceptionUseCache(ex.ToString());
}
return(false);
}
public void KFSendStageData()
{
ClientAgentManager.Instance().BroadCastMsg(KFCallMsg.New <KFStageData>(KuaFuEventTypes.BoCaiStageChange, this.GetKFStageData()), 0);
}
private static bool CreateGameFuBen(DateTime now, params EscapeBattle_K.JoinPkData[] joinArr)
{
for (int side = 1; side <= joinArr.Length; side++)
{
joinArr[side - 1].Side = side;
if (joinArr[side - 1].InGame)
{
return(true);
}
}
int toServerId = 0;
int gameId = TianTiPersistence.Instance.GetNextGameId();
if (ClientAgentManager.Instance().AssginKfFuben(EscapeBattle_K.GameType, (long)gameId, 10, out toServerId))
{
EscapeBattleFuBenData copyData = new EscapeBattleFuBenData();
copyData.GameID = (long)gameId;
copyData.ServerID = toServerId;
EscapeBattleNtfEnterData data = new EscapeBattleNtfEnterData();
data.ToServerId = toServerId;
data.GameId = gameId;
EscapeBattlePkLogData log = new EscapeBattlePkLogData();
log.Season = EscapeBattle_K.SyncData.Season;
log.StartTime = now;
log.GameID = gameId;
log.ToServerID = toServerId;
EscapeBattleMatchConfig config = EscapeBattle_K._Config.MatchConfigList[0];
log.EndTime = now.AddSeconds((double)config.TotalSecs);
foreach (EscapeBattle_K.JoinPkData joinRole in joinArr)
{
copyData.SideDict[(long)joinRole.ZhanDuiID] = joinRole.Side;
copyData.RoleDict.AddRange(TianTi5v5Service.GetZhanDuiMemberIDs(joinRole.ZhanDuiID));
joinRole.ToServerID = toServerId;
joinRole.CurrGameID = gameId;
joinRole.CopyData = copyData;
joinRole.InGame = true;
data.ZhanDuiIDList.Add(joinRole.ZhanDuiID);
log.ZhanDuiIDs.Add(joinRole.ZhanDuiID);
log.ZoneIDs.Add(joinRole.ZoneId);
log.ZhanDuiNames.Add(joinRole.ZhanDuiName);
EscapeBattle_K.JoinPkData zhandui;
if (EscapeBattle_K.JoinDict.TryGetValue(joinRole.ZhanDuiID, out zhandui))
{
zhandui.InGame = true;
zhandui.CurrGameID = gameId;
zhandui.Side = joinRole.Side;
zhandui.ToServerID = toServerId;
zhandui.CopyData = copyData;
zhandui.State = 3;
zhandui.ReadyState = false;
zhandui.ReadyNum = 0;
}
}
EscapeBattle_K.AsyncEvQ.Enqueue(KFCallMsg.New <EscapeBattleNtfEnterData>(KuaFuEventTypes.EscapeBattle_NotifyEnter, data));
EscapeBattle_K.ThisLoopPkLogs[gameId] = log;
if (!EscapeBattle_K.NeedUpdateRank)
{
EscapeBattle_K.NeedUpdateRank = true;
}
LogManager.WriteLog(LogTypes.Trace, string.Format("大逃杀第{0}赛季战队成员通知入场,GameID={1},zhanduiIDs={2}", EscapeBattle_K.SyncData.Season, data.GameId, string.Join <int>(",", log.ZhanDuiIDs)), null, true);
return(true);
}
LogManager.WriteLog(LogTypes.Warning, string.Format("大逃杀第{0}赛季分配游戏服务器失败", EscapeBattle_K.SyncData.Season), null, true);
return(false);
}
private static void UpDateTick(object sender)
{
try
{
char[] ChArray = new char[]
{
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'J',
'K',
'L',
'M',
'N',
'P',
'Q',
'R',
'S',
'T',
'W',
'V',
'U',
'X',
'Y',
'Z'
};
string str = "";
for (int i = 0; i < (int)sender; i++)
{
str += ChArray[i % ChArray.Length];
}
long allnum = 0L;
long sunum = 0L;
while (TestS2KFCommunication.Flag)
{
allnum += 1L;
if (allnum > 50000L)
{
break;
}
try
{
ClientAgentManager.Instance().BroadCastMsg(KFCallMsg.New <string>(KuaFuEventTypes.Test, str), 0);
sunum += 1L;
}
catch (Exception ex)
{
LogManager.WriteException(ex.ToString());
Console.WriteLine("UpDateTick Exception");
}
}
Console.WriteLine(string.Format("发送allnum={0}， sunum={1}", allnum - 1L, sunum));
}
catch (Exception ex)
{
LogManager.WriteException(ex.ToString());
Console.WriteLine("UpDateTick Exception");
}
}
public static void TimerProc()
{
ClientAgentManager.Instance().SendAsyncKuaFuMsg();
}
