private static void OnAskForAllianceRankingListMessageReceived(AskForAllianceRankingListMessage message, ServerSessionMessage requestMessage)
{
if (message.GetLocalRanking())
{
AllianceLocalRankingListMessage allianceLocalRankingListMessage = new AllianceLocalRankingListMessage();
allianceLocalRankingListMessage.SetAllianceRankingList(new LogicArrayList <AllianceRankingEntry>(0));
allianceLocalRankingListMessage.SetVillageType(message.GetVillageType());
ServerMessageManager.SendMessage(ScoringMessageManager.CreateForwardLogicMessage(allianceLocalRankingListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
else
{
AllianceRankingListMessage allianceRankingListMessage = new AllianceRankingListMessage();
allianceRankingListMessage.SetAllianceRankingList(ScoringManager.GetAllianceRankingList(message.GetVillageType(), message.RemoveAllianceId()));
allianceRankingListMessage.SetDiamondPrizes(ScoringManager.GetDiamondPrizes());
allianceRankingListMessage.SetNextEndTimeSeconds(ScoringManager.GetNextEndTimeSeconds());
allianceRankingListMessage.SetVillageType(message.GetVillageType());
ServerMessageManager.SendMessage(ScoringMessageManager.CreateForwardLogicMessage(allianceRankingListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
}
private void SaveState()
{
if (this.m_logicGameMode.GetState() == 1)
{
LogicJSONObject jsonObject = new LogicJSONObject(64);
this.m_logicGameMode.SaveToJSON(jsonObject);
ZLibHelper.CompressInZLibFormat(LogicStringUtil.GetBytes(LogicJSONParser.CreateJSONString(jsonObject, 1536)), out byte[] homeJSON);
ServerMessageManager.SendMessage(new GameStateCallbackMessage
{
AccountId = this.m_logicGameMode.GetLevel().GetPlayerAvatar().GetId(),
SessionId = this.m_session.Id,
LogicClientAvatar = this.m_logicGameMode.GetLevel().GetPlayerAvatar(),
AvatarChanges = this.m_avatarChangeListener.RemoveAvatarChanges(),
ExecutedServerCommands = new LogicArrayList <LogicServerCommand>(),
HomeJSON = homeJSON,
RemainingShieldTime = this.m_logicGameMode.GetShieldRemainingSeconds(),
RemainingGuardTime = this.m_logicGameMode.GetGuardRemainingSeconds(),
NextPersonalBreakTime = this.m_logicGameMode.GetPersonalBreakCooldownSeconds(),
SaveTime = TimeUtil.GetTimestamp()
}, 9);
}
else
{
ServerMessageManager.SendMessage(new GameStateCallbackMessage
{
AccountId = this.m_logicGameMode.GetLevel().GetPlayerAvatar().GetId(),
SessionId = this.m_session.Id,
LogicClientAvatar = this.m_logicGameMode.GetLevel().GetPlayerAvatar(),
AvatarChanges = this.m_avatarChangeListener.RemoveAvatarChanges()
}, 9);
}
}
private static void Update()
{
while (true)
{
Task t1 = ((ScoringSeason)ScoringManager.m_currentSeason).Update();
Task t2 = ((ScoringSeason)ScoringManager.m_lastSeason)?.Update();
t1.Wait();
t2?.Wait();
if (((ScoringSeason)ScoringManager.m_currentSeason).IsEnded())
{
DateTime utcTime = DateTime.UtcNow.AddMonths(1);
ScoringManager.m_lastSeason = ScoringManager.m_currentSeason;
ScoringManager.m_currentSeason = ScoringManager.LoadOrCreateSeason(new LogicLong(utcTime.Year, utcTime.Month));
}
for (int i = 1, count = ServerManager.GetServerCount(26); i < count; i++)
{
ServerMessageManager.SendMessage(new ScoringSyncMessage
{
CurrentSeasonDocument = ScoringManager.m_currentSeason,
LastSeasonDocument = ScoringManager.m_lastSeason,
}, 26, i);
}
Thread.Sleep(2000);
}
}
private static async void OnSendAllianceBookmarksFullDataToClientMessageReceived(SendAllianceBookmarksFullDataToClientMessage message)
{
AllianceBookmarksFullDataMessage allianceBookmarksFullDataMessage = new AllianceBookmarksFullDataMessage();
allianceBookmarksFullDataMessage.SetAlliances(await SearchManager.GetAllianceHeaderList(message.AllianceIds));
ServerMessageManager.SendMessage(SearchMessageManager.CreateForwardLogicMessage(allianceBookmarksFullDataMessage, message.SessionId), ServerManager.GetProxySocket(message.SessionId));
}
public static void OnStartServerSessionMessageReceived(StartServerSessionMessage message)
{
if (GameModeClusterManager.m_sessionClusters.ContainsKey(message.SessionId))
{
throw new Exception("GameModeClusterManager.onStartSessionMessageReceived: session already started!");
}
GameModeCluster gameModeCluster = GameModeClusterManager.GetFastestCluster();
if (gameModeCluster != null)
{
GameModeClusterManager.m_sessionClusters.Add(message.SessionId, gameModeCluster);
gameModeCluster.SendMessage(message);
}
else
{
if (message.BindRequestMessage != null)
{
ServerRequestManager.SendResponse(new BindServerSocketResponseMessage(), message.BindRequestMessage);
}
ServerMessageManager.SendMessage(new StartServerSessionFailedMessage
{
SessionId = message.SessionId
}, message.Sender);
}
}
private void OnAvatarReceived(ServerRequestArgs args)
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
this.LogicClientAvatar = ((AvatarResponseMessage)args.ResponseMessage).LogicClientAvatar;
if (AllianceManager.TryGet(this.LogicClientAvatar.GetAllianceId(), out Alliance avatarAlliance) && avatarAlliance.Members.ContainsKey(this.AccountId))
{
this.Alliance = avatarAlliance;
this.Alliance.AddOnlineMember(this.AccountId, this);
this.SendPiranhaMessage(this.Alliance.GetAllianceFulEntryUpdateMessage(), 1);
this.SendPiranhaMessage(this.Alliance.GetAllianceStreamMessage(), 1);
AllianceMemberUtil.SetLogicClientAvatarToAllianceMemberEntry(this.LogicClientAvatar, this.Alliance.Members[this.AccountId], this.Alliance);
AllianceManager.Save(this.Alliance);
}
else
{
this.SendMessage(new StopServerSessionMessage(), 1);
ServerMessageManager.SendMessage(new AllianceLeavedMessage
{
AccountId = this.AccountId,
AllianceId = this.LogicClientAvatar.GetAllianceId()
}, 9);
AllianceSessionManager.Remove(this.Id);
}
}
else
{
this.SendMessage(new StopServerSessionMessage(), 1);
AllianceSessionManager.Remove(this.Id);
}
}
public void RemoveAvatarStreamEntry(LogicLong streamId)
{
int index = this.AvatarStreamList.IndexOf(streamId);
if (index != -1)
{
this.AvatarStreamList.Remove(index);
ServerMessageManager.SendMessage(new RemoveAvatarStreamMessage
{
AccountId = streamId
}, ServerManager.GetDocumentSocket(11, this.Id));
if (this.CurrentSession != null)
{
AvatarStreamEntryRemovedMessage avatarStreamEntryRemovedMessage = new AvatarStreamEntryRemovedMessage();
avatarStreamEntryRemovedMessage.SetStreamEntryId(streamId);
this.CurrentSession.SendPiranhaMessage(avatarStreamEntryRemovedMessage, 1);
}
else
{
GameAvatar.Save(this);
}
}
}
private static void OnAskForAvatarRankingListMessageReceived(AskForAvatarRankingListMessage message, ServerSessionMessage requestMessage)
{
if (message.GetVillageType() == 1)
{
AvatarDuelRankingListMessage avatarDuelRankingListMessage = new AvatarDuelRankingListMessage();
LogicLong avatarId = message.RemoveAvatarId();
avatarDuelRankingListMessage.SetAvatarRankingList(ScoringManager.GetAvatarDuelRankingList(avatarId));
avatarDuelRankingListMessage.SetNextEndTimeSeconds(ScoringManager.GetNextEndTimeSeconds());
avatarDuelRankingListMessage.SetSeasonMonth(ScoringManager.GetSeasonMonth());
avatarDuelRankingListMessage.SetSeasonYear(ScoringManager.GetSeasonYear());
avatarDuelRankingListMessage.SetLastSeasonAvatarRankingList(ScoringManager.GetLastSeasonAvatarDuelRankingList(avatarId));
avatarDuelRankingListMessage.SetLastSeasonMonth(ScoringManager.GetLastSeasonMonth());
avatarDuelRankingListMessage.SetLastSeasonYear(ScoringManager.GetLastSeasonYear());
ServerMessageManager.SendMessage(ScoringMessageManager.CreateForwardLogicMessage(avatarDuelRankingListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
else
{
AvatarRankingListMessage avatarRankingListMessage = new AvatarRankingListMessage();
LogicLong avatarId = message.RemoveAvatarId();
avatarRankingListMessage.SetAvatarRankingList(ScoringManager.GetAvatarRankingList(avatarId));
avatarRankingListMessage.SetNextEndTimeSeconds(ScoringManager.GetNextEndTimeSeconds());
avatarRankingListMessage.SetSeasonMonth(ScoringManager.GetSeasonMonth());
avatarRankingListMessage.SetSeasonYear(ScoringManager.GetSeasonYear());
avatarRankingListMessage.SetLastSeasonAvatarRankingList(ScoringManager.GetLastSeasonAvatarRankingList(avatarId));
avatarRankingListMessage.SetLastSeasonMonth(ScoringManager.GetLastSeasonMonth());
avatarRankingListMessage.SetLastSeasonYear(ScoringManager.GetLastSeasonYear());
ServerMessageManager.SendMessage(ScoringMessageManager.CreateForwardLogicMessage(avatarRankingListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
}
public void ChangeMemberRole(AllianceMemberEntry allianceMemberEntry, LogicAvatarAllianceRole allianceRole, LogicLong eventAvatarId, string eventAvatarName)
{
if (allianceMemberEntry.GetAllianceRole() != allianceRole)
{
bool isPromoted = allianceMemberEntry.HasLowerRoleThan(allianceRole);
allianceMemberEntry.SetAllianceRole(allianceRole);
LogicChangeAllianceRoleCommand logicChangeAllianceRoleCommand = new LogicChangeAllianceRoleCommand();
logicChangeAllianceRoleCommand.SetData(this.Id, allianceRole);
ServerMessageManager.SendMessage(new GameAllowServerCommandMessage
{
AccountId = allianceMemberEntry.GetAvatarId(),
ServerCommand = logicChangeAllianceRoleCommand
}, 9);
AllianceEventStreamEntry allianceEventStreamEntry = new AllianceEventStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(allianceEventStreamEntry, allianceMemberEntry);
allianceEventStreamEntry.SetEventAvatarId(eventAvatarId);
allianceEventStreamEntry.SetEventAvatarName(eventAvatarName);
allianceEventStreamEntry.SetEventType(isPromoted ? AllianceEventStreamEntryType.PROMOTED : AllianceEventStreamEntryType.DEMOTED);
StreamManager.Create(this.Id, allianceEventStreamEntry);
this.AddStreamEntry(allianceEventStreamEntry);
}
}
private static void OnSendAvatarStreamsToClientMessageReceived(SendAvatarStreamsToClientMessage message)
{
AvatarStreamMessage avatarStreamMessage = new AvatarStreamMessage();
LogicArrayList <LogicLong> ids = message.StreamIds;
LogicArrayList <AvatarStreamEntry> avatarStreamList = new LogicArrayList <AvatarStreamEntry>(ids.Size());
for (int i = 0; i < ids.Size(); i++)
{
AvatarStreamEntry avatarStreamEntry = StreamManager.GetAvatarStream(ids[i]);
if (avatarStreamEntry != null)
{
avatarStreamList.Add(avatarStreamEntry);
}
}
avatarStreamMessage.SetStreamEntries(avatarStreamList);
avatarStreamMessage.Encode();
ServerMessageManager.SendMessage(StreamMessageManager.CreateForwardLogicMessage(avatarStreamMessage, message.SessionId), ServerManager.GetProxySocket(message.SessionId));
for (int i = 0; i < avatarStreamList.Size(); i++)
{
AvatarStreamEntry avatarStreamEntry = avatarStreamList[i];
if (avatarStreamEntry.IsNew())
{
avatarStreamEntry.SetNew(false);
StreamManager.Save(avatarStreamEntry);
}
}
}
private static void OnForwardLogicMessageRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForAllianceDataMessage.MESSAGE_TYPE:
AskForAllianceDataMessage askForAllianceDataMessage = (AskForAllianceDataMessage)logicMessage;
LogicLong allianceId = askForAllianceDataMessage.RemoveAllianceId();
if (AllianceManager.TryGet(allianceId, out Alliance alliance))
{
ServerMessageManager.SendMessage(StreamMessageManager.CreateForwardLogicMessage(alliance.GetAllianceDataMessage(), message.SessionId),
ServerManager.GetProxySocket(message.SessionId));
}
break;
}
}
}
private static void OnAllianceCreateMailMessageReceived(AllianceCreateMailMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry senderMemberEntry))
{
AllianceMailAvatarStreamEntry allianceMailAvatarStreamEntry = new AllianceMailAvatarStreamEntry();
allianceMailAvatarStreamEntry.SetSenderAvatarId(senderMemberEntry.GetAvatarId());
allianceMailAvatarStreamEntry.SetSenderHomeId(senderMemberEntry.GetHomeId());
allianceMailAvatarStreamEntry.SetSenderName(senderMemberEntry.GetName());
allianceMailAvatarStreamEntry.SetSenderLevel(senderMemberEntry.GetExpLevel());
allianceMailAvatarStreamEntry.SetSenderLeagueType(senderMemberEntry.GetLeagueType());
allianceMailAvatarStreamEntry.SetMessage(message.Message);
allianceMailAvatarStreamEntry.SetAllianceId(alliance.Id);
allianceMailAvatarStreamEntry.SetAllianceName(alliance.Header.GetAllianceName());
allianceMailAvatarStreamEntry.SetAllianceBadgeId(alliance.Header.GetAllianceBadgeId());
foreach (AllianceMemberEntry memberEntry in alliance.Members.Values)
{
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = memberEntry.GetAvatarId(),
Entry = allianceMailAvatarStreamEntry
}, 9);
}
}
}
private void AddAvatarStreamEntry(AvatarStreamEntry entry)
{
if (this.AvatarStreamList.Size() > 50)
{
this.RemoveAvatarStreamEntry(this.AvatarStreamList[0]);
}
this.AvatarStreamList.Add(entry.GetId());
if (this.CurrentSession != null)
{
AvatarStreamEntryMessage avatarStreamEntryMessage = new AvatarStreamEntryMessage();
avatarStreamEntryMessage.SetAvatarStreamEntry(entry);
this.CurrentSession.SendPiranhaMessage(avatarStreamEntryMessage, 1);
if (entry.IsNew())
{
ServerMessageManager.SendMessage(new AvatarStreamSeenMessage
{
AccountId = entry.GetId()
}, 11);
}
}
else
{
GameAvatar.Save(this);
}
}
private void CreateChallengeReplay()
{
string battleLog = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetLevel().GetBattleLog().GenerateAttackerJSON());
ServerRequestManager.Create(new CreateReplayStreamRequestMessage
{
JSON = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetReplay().GetJson(), 1536)
}, ServerManager.GetNextSocket(11)).OnComplete = args =>
{
LogicLong replayId = null;
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
replayId = ((CreateReplayStreamResponseMessage)args.ResponseMessage).Id;
}
ServerMessageManager.SendMessage(new AllianceChallengeReportMessage
{
AccountId = this.m_challengeAllianceId,
StreamId = this.m_challengeStreamId,
ReplayId = replayId,
BattleLog = battleLog
}, 11);
};
}
private void OnDonateAllianceUnitMessageReceived(DonateAllianceUnitMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicCombatItemData unitData = message.GetAllianceUnitData();
if (!unitData.IsDonationDisabled())
{
if (message.UseQuickDonate())
{
if (!LogicDataTables.GetGlobals().EnableQuickDonate() || this.m_session.LogicClientAvatar.GetDiamonds() < unitData.GetDonateCost())
{
return;
}
}
else
{
if (this.m_session.LogicClientAvatar.GetUnitCount(unitData) <= 0)
{
return;
}
}
if (alliance.StreamEntryList.IndexOf(message.GetStreamId()) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.DONATE)
{
DonateStreamEntry donateStreamEntry = (DonateStreamEntry)streamEntry;
if (donateStreamEntry.CanAddDonation(this.m_session.AccountId, message.GetAllianceUnitData(), alliance.Header.GetAllianceLevel()))
{
donateStreamEntry.AddDonation(this.m_session.AccountId, unitData, this.m_session.LogicClientAvatar.GetUnitUpgradeLevel(unitData));
donateStreamEntry.SetDonationPendingRequestCount(donateStreamEntry.GetDonationPendingRequestCount() + 1);
StreamManager.Save(donateStreamEntry);
alliance.UpdateStreamEntry(donateStreamEntry);
if (message.UseQuickDonate())
{
this.m_session.LogicClientAvatar.CommodityCountChangeHelper(0, unitData, -1);
}
LogicDonateAllianceUnitCommand logicDonateAllianceUnitCommand = new LogicDonateAllianceUnitCommand();
logicDonateAllianceUnitCommand.SetData(unitData, streamEntry.GetId(), message.UseQuickDonate());
ServerMessageManager.SendMessage(new GameAllowServerCommandMessage
{
AccountId = this.m_session.AccountId,
ServerCommand = logicDonateAllianceUnitCommand
}, 9);
}
}
}
}
}
}
private void SendAvatarStreamMessageToClient()
{
ServerMessageManager.SendMessage(new SendAvatarStreamsToClientMessage
{
StreamIds = this.GameAvatar.AvatarStreamList,
SessionId = this.Id
}, ServerManager.GetDocumentSocket(11, this.GameAvatar.Id));
}
private static void OnAskForLocalAvatarRankingListMessageReceived(AskForAvatarLocalRankingListMessage message, ServerSessionMessage requestMessage)
{
AvatarLocalRankingListMessage avatarLocalRankingListMessage = new AvatarLocalRankingListMessage();
avatarLocalRankingListMessage.SetAvatarRankingList(new LogicArrayList <AvatarRankingEntry>(0));
ServerMessageManager.SendMessage(ScoringMessageManager.CreateForwardLogicMessage(avatarLocalRankingListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
private void OnAskForAllianceBookmarksFullDataMessageReceived(AskForAllianceBookmarksFullDataMessage message)
{
ServerMessageManager.SendMessage(new SendAllianceBookmarksFullDataToClientMessage
{
SessionId = this.m_session.Id,
AllianceIds = this.m_session.GameAvatar.AllianceBookmarksList
}, ServerManager.GetNextSocket(29));
}
private void UpdateLiveReplay(int clientSubTick, LogicArrayList <LogicCommand> commands)
{
ServerMessageManager.SendMessage(new ClientUpdateLiveReplayMessage
{
AccountId = this.m_liveReplayId,
SubTick = clientSubTick,
Commands = commands
}, 9);
}
private static void OnGameSpectateLiveReplayMessageReceived(GameSpectateLiveReplayMessage message)
{
if (GameSessionManager.TryGet(message.SessionId, out GameSession session))
{
ServerRequestManager.Create(new LiveReplayAddSpectatorRequestMessage
{
LiveReplayId = message.LiveReplayId,
SlotId = message.IsEnemy ? 1 : 0,
SessionId = session.Id
}, ServerManager.GetDocumentSocket(9, message.LiveReplayId)).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
if (session.IsDestructed())
{
ServerMessageManager.SendMessage(new LiveReplayRemoveSpectatorMessage
{
AccountId = message.LiveReplayId,
SessionId = session.Id
}, 9);
}
else
{
session.DestructGameState();
session.SpectateLiveReplayId = message.LiveReplayId;
session.SpectateLiveReplaySlotId = message.IsEnemy ? 1 : 0;
}
}
else if (!session.IsDestructed())
{
LiveReplayFailedMessage liveReplayFailedMessage = new LiveReplayFailedMessage();
if (args.ErrorCode == ServerRequestError.Success)
{
LiveReplayAddSpectatorResponseMessage responseMessage = (LiveReplayAddSpectatorResponseMessage)args.ResponseMessage;
switch (responseMessage.ErrorCode)
{
case LiveReplayAddSpectatorResponseMessage.Reason.NOT_EXISTS:
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
break;
case LiveReplayAddSpectatorResponseMessage.Reason.FULL:
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.NO_FREE_SLOTS);
break;
}
}
else
{
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
}
session.SendPiranhaMessage(liveReplayFailedMessage, 1);
}
};
}
}
public override void SendClanMail(string message)
{
ServerMessageManager.SendMessage(new AllianceCreateMailMessage
{
AccountId = this.m_playerAvatar.GetAllianceId(),
MemberId = this.m_playerAvatar.GetId(),
Message = message
}, 11);
}
public void SendMessage(ServerSessionMessage message, int serverType)
{
message.SessionId = this.Id;
if (this.m_sockets[serverType] != null)
{
ServerMessageManager.SendMessage(message, this.m_sockets[serverType]);
}
}
public override void OnReceiveCoreMessage(ServerCoreMessage message)
{
switch (message.GetMessageType())
{
case ServerMessageType.SERVER_PERFORMANCE:
ServerMessageManager.SendMessage(new ServerPerformanceDataMessage(), message.Sender);
break;
}
}
private static void OnAskForAvatarDuelLastSeasonRankingListMessageReceived(AskForAvatarDuelLastSeasonRankingListMessage message, ServerSessionMessage requestMessage)
{
AvatarDuelLastSeasonRankingListMessage avatarDuelLastSeasonRankingListMessage = new AvatarDuelLastSeasonRankingListMessage();
avatarDuelLastSeasonRankingListMessage.SetAvatarRankingList(ScoringManager.GetLastSeasonAvatarDuelRankingList(message.RemoveAvatarId()));
avatarDuelLastSeasonRankingListMessage.SetSeasonYear(ScoringManager.GetLastSeasonYear());
avatarDuelLastSeasonRankingListMessage.SetSeasonMonth(ScoringManager.GetLastSeasonMonth());
ServerMessageManager.SendMessage(ScoringMessageManager.CreateForwardLogicMessage(avatarDuelLastSeasonRankingListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
public override void ShareReplay(LogicLong replayId, string message)
{
ServerMessageManager.SendMessage(new AllianceShareReplayMessage
{
AccountId = this.m_playerAvatar.GetAllianceId(),
MemberId = this.m_playerAvatar.GetId(),
ReplayId = replayId,
Message = message
}, 11);
}
private void SendSpectatorCountToStreamService()
{
ServerMessageManager.SendMessage(new AllianceChallengeSpectatorCountMessage
{
AccountId = this.m_allianceId,
StreamId = this.m_allianceStreamId,
Count = this.m_spectatorList[0].Count +
this.m_spectatorList[1].Count
}, 11);
}
public void SendPingMessage()
{
if (this.m_watch.IsRunning)
{
this.Status = ServerPerformanceStatus.OFFLINE;
}
ServerMessageManager.SendMessage(new PingMessage(), this.Socket);
this.m_watch.Restart();
}
public static GameMode LoadMatchedAttackState(HomeSession session, GameMatchedAttackState state)
{
LogicClientHome home = state.Home;
LogicClientAvatar homeOwnerAvatar = state.HomeOwnerAvatar;
LogicClientAvatar attackerLogicClientAvatar = state.PlayerAvatar;
int currentTimestamp = TimeUtil.GetTimestamp();
int secondsSinceLastSave = state.SaveTime != -1 ? currentTimestamp - state.SaveTime : 0;
int secondsSinceLastMaintenance = state.MaintenanceTime != -1 ? currentTimestamp - state.MaintenanceTime : 0;
EnemyHomeDataMessage enemyHomeDataMessage = new EnemyHomeDataMessage();
enemyHomeDataMessage.SetCurrentTimestamp(currentTimestamp);
enemyHomeDataMessage.SetSecondsSinceLastSave(secondsSinceLastSave);
enemyHomeDataMessage.SetSecondsSinceLastMaintenance(secondsSinceLastMaintenance);
enemyHomeDataMessage.SetLogicClientHome(home);
enemyHomeDataMessage.SetLogicClientAvatar(homeOwnerAvatar);
enemyHomeDataMessage.SetAttackerLogicClientAvatar(attackerLogicClientAvatar);
enemyHomeDataMessage.SetAttackSource(3);
enemyHomeDataMessage.Encode();
CompressibleStringHelper.Uncompress(home.GetCompressibleHomeJSON());
CompressibleStringHelper.Uncompress(home.GetCompressibleCalendarJSON());
CompressibleStringHelper.Uncompress(home.GetCompressibleGlobalJSON());
try
{
GameMode gameMode = new GameMode(session);
gameMode.m_avatarChangeListener = new AvatarChangeListener(gameMode, attackerLogicClientAvatar);
attackerLogicClientAvatar.SetChangeListener(gameMode.m_avatarChangeListener);
gameMode.m_logicGameMode.LoadMatchedAttackState(home, homeOwnerAvatar, attackerLogicClientAvatar, currentTimestamp, secondsSinceLastSave, secondsSinceLastMaintenance);
gameMode.m_gameDefenderLocked = state.GameDefenderLocked;
gameMode.m_liveReplayId = state.LiveReplayId;
ZLibHelper.CompressInZLibFormat(LogicStringUtil.GetBytes(LogicJSONParser.CreateJSONString(gameMode.m_logicGameMode.GetReplay().GetJson())), out byte[] streamJSON);
ServerMessageManager.SendMessage(new InitializeLiveReplayMessage
{
AccountId = gameMode.m_liveReplayId,
StreamData = streamJSON
}, 9);
session.SendPiranhaMessage(enemyHomeDataMessage, 1);
return(gameMode);
}
catch (Exception exception)
{
Logging.Error("GameMode.loadMatchedAttackState: exception while the loading of attack state: " + exception);
}
return(null);
}
public void AllowServerCommand(LogicServerCommand serverCommand)
{
foreach (long id in this.Members.Keys)
{
ServerMessageManager.SendMessage(new GameAllowServerCommandMessage
{
AccountId = id,
ServerCommand = serverCommand
}, 9);
}
}
public static void Start(ServerMessageManager messageManager)
{
Logging.SEND_LOGS = true;
ServerMessaging.Init(messageManager);
ServerListenSocket.Init();
if (ServerManager.GetServerCount(0) != 0 && ServerCore.Type != 0)
{
ServerStatus.SetStatus(ServerStatusType.MAINTENANCE, 0, 0);
ServerMessageManager.SendMessage(new AskForServerStatusMessage(), ServerManager.GetSocket(0, 0));
}
}
