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 OnHomeBattleReplayMessageReceived(HomeBattleReplayMessage message)
{
ServerRequestManager.Create(new LoadReplayStreamRequestMessage
{
Id = message.GetReplayId()
}, ServerManager.GetDocumentSocket(11, this.m_session.AccountId), 5).OnComplete = this.OnHomeBattleReplayLoaded;
}
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 static void OnBindServerSocketRequestMessageReceived(BindServerSocketRequestMessage message)
{
if (ProxySessionManager.TryGet(message.SessionId, out ProxySession session))
{
ServerSocket socket = message.ServerId != -1
? ServerManager.GetSocket(message.ServerType, message.ServerId)
: ServerManager.GetNextSocket(message.ServerType);
if (socket != null)
{
session.SetSocket(socket, message);
}
else
{
ServerRequestManager.SendResponse(new BindServerSocketResponseMessage
{
ServerType = message.ServerType,
ServerId = message.ServerId,
Success = false
}, message);
}
}
else
{
ServerRequestManager.SendResponse(new BindServerSocketResponseMessage
{
ServerType = message.ServerType,
ServerId = message.ServerId,
Success = false
}, message);
}
}
private static void OnCreateAllianceRequestMessageReceived(CreateAllianceRequestMessage message)
{
CreateAllianceResponseMessage createAllianceResponseMessage = new CreateAllianceResponseMessage();
string allianceName = message.AllianceName;
if (allianceName == null || allianceName.Length < 2)
{
createAllianceResponseMessage.ErrorReason = CreateAllianceResponseMessage.Reason.NAME_TOO_SHORT;
ServerRequestManager.SendResponse(createAllianceResponseMessage, message);
return;
}
if (allianceName.Length > 15)
{
createAllianceResponseMessage.ErrorReason = CreateAllianceResponseMessage.Reason.NAME_TOO_LONG;
ServerRequestManager.SendResponse(createAllianceResponseMessage, message);
return;
}
Alliance alliance = AllianceManager.Create();
alliance.Header.SetAllianceName(allianceName);
alliance.SetAllianceSettings(message.AllianceDescription, message.AllianceType, message.AllianceBadgeId, message.RequiredScore, message.RequiredDuelScore, message.WarFrequency,
message.OriginData, message.PublicWarLog, message.ArrangedWarEnabled);
createAllianceResponseMessage.Success = true;
createAllianceResponseMessage.AllianceId = alliance.Id;
AllianceManager.Save(alliance);
ServerRequestManager.SendResponse(createAllianceResponseMessage, message);
}
private static void OnLoadAvatarStreamOfTypeRequestMessageReceived(LoadAvatarStreamOfTypeRequestMessage message)
{
LoadAvatarStreamOfTypeResponseMessage loadAvatarStreamOfTypeResponseMessage = new LoadAvatarStreamOfTypeResponseMessage();
LogicArrayList <AvatarStreamEntry> streamEntryList = new LogicArrayList <AvatarStreamEntry>(message.StreamIds.Size());
for (int i = 0; i < message.StreamIds.Size(); i++)
{
AvatarStreamEntry entry = StreamManager.GetAvatarStream(message.StreamIds[i]);
if (entry != null && entry.GetAvatarStreamEntryType() == message.Type)
{
if (message.SenderAvatarId != null && !entry.GetSenderAvatarId().Equals(message.SenderAvatarId))
{
continue;
}
streamEntryList.Add(entry);
}
}
loadAvatarStreamOfTypeResponseMessage.Success = true;
loadAvatarStreamOfTypeResponseMessage.StreamList = streamEntryList;
ServerRequestManager.SendResponse(loadAvatarStreamOfTypeResponseMessage, message);
}
private static void OnForwardLogicRequestMessageReceived(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 AskForJoinableAlliancesListMessage.MESSAGE_TYPE:
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = message.AccountId
}, ServerManager.GetDocumentSocket(9, message.AccountId), 5).OnComplete = args =>
{
SearchMessageManager.OnAvatarResponseMessageReceivedForJoinableAlliancesList(message, args);
};
break;
case SearchAlliancesMessage.MESSAGE_TYPE:
SearchMessageManager.OnSearchAlliancesMessageReceived((SearchAlliancesMessage)logicMessage, message);
break;
}
}
}
private static void OnLiveReplayAddSpectatorRequestMessageReceived(LiveReplayAddSpectatorRequestMessage message)
{
if (LiveReplayManager.TryGet(message.LiveReplayId, out LiveReplay liveReplay) && !liveReplay.ContainsSession(message.SessionId, message.SlotId) && liveReplay.IsInit())
{
if (liveReplay.IsFull())
{
ServerRequestManager.SendResponse(new LiveReplayAddSpectatorResponseMessage
{
ErrorCode = LiveReplayAddSpectatorResponseMessage.Reason.FULL
}, message);
}
else
{
ServerRequestManager.SendResponse(new LiveReplayAddSpectatorResponseMessage
{
Success = true
}, message);
liveReplay.AddSpectator(message.SessionId, message.SlotId);
}
}
else
{
ServerRequestManager.SendResponse(new LiveReplayAddSpectatorResponseMessage
{
ErrorCode = LiveReplayAddSpectatorResponseMessage.Reason.NOT_EXISTS
}, message);
}
}
private static void OnCreateAvatarStreamRequestMessageReceived(CreateAvatarStreamRequestMessage message)
{
StreamManager.Create(message.OwnerId, message.Entry);
ServerRequestManager.SendResponse(new CreateAvatarStreamResponseMessage
{
Success = true,
Entry = message.Entry
}, message);
}
public AllianceSession(StartServerSessionMessage message) : base(message)
{
this.LogicMessageManager = new LogicMessageManager(this);
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = this.AccountId
}, ServerManager.GetDocumentSocket(9, this.AccountId)).OnComplete = this.OnAvatarReceived;
}
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);
}
};
}
}
private static void OnCreateReplayStreamRequestMessageReceived(CreateReplayStreamRequestMessage message)
{
ZLibHelper.CompressInZLibFormat(LogicStringUtil.GetBytes(message.JSON), out byte[] entry);
StreamManager.Create(entry, out LogicLong id);
ServerRequestManager.SendResponse(new CreateReplayStreamResponseMessage
{
Success = true,
Id = id
}, message);
}
private static void OnNewAvatarStreamMessageReceived(CreateAvatarStreamMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar document))
{
ServerRequestManager.Create(new CreateAvatarStreamRequestMessage
{
OwnerId = document.Id,
Entry = message.Entry
}, ServerManager.GetDocumentSocket(11, document.Id)).OnComplete = document.OnAvatarStreamCreated;
}
}
private void OnCreateAlliance(ServerRequestArgs args)
{
if (args.ErrorCode == ServerRequestError.Success)
{
CreateAllianceResponseMessage createAllianceResponseMessage = (CreateAllianceResponseMessage)args.ResponseMessage;
if (createAllianceResponseMessage.Success)
{
LogicLong avatarId = this.m_session.GameMode.GetPlayerAvatar().GetId();
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = avatarId,
AllianceId = createAllianceResponseMessage.AllianceId,
Created = true
}, ServerManager.GetDocumentSocket(9, avatarId)).OnComplete = this.OnGameAllianceJoin;
}
else
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
switch (createAllianceResponseMessage.ErrorReason)
{
case CreateAllianceResponseMessage.Reason.GENERIC:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
break;
case CreateAllianceResponseMessage.Reason.INVALID_DESCRIPTION:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.INVALID_DESCRIPTION);
break;
case CreateAllianceResponseMessage.Reason.INVALID_NAME:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.INVALID_NAME);
break;
case CreateAllianceResponseMessage.Reason.NAME_TOO_LONG:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.NAME_TOO_LONG);
break;
case CreateAllianceResponseMessage.Reason.NAME_TOO_SHORT:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.NAME_TOO_SHORT);
break;
}
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
}
}
else
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
}
}
private void OnRequestJoinAllianceMessageReceived(RequestJoinAllianceMessage message)
{
if (this.CanJoinAlliance())
{
LogicLong allianceId = message.RemoveAllianceId();
ServerRequestManager.Create(new RequestAllianceJoinRequestMessage
{
Avatar = this.m_session.GameMode.GetPlayerAvatar(),
AllianceId = allianceId,
Message = message.GetMessage()
}, ServerManager.GetDocumentSocket(11, allianceId)).OnComplete = this.OnRequestAlliance;
}
}
public void BindAllianceServer()
{
ServerSocket socket = ServerManager.GetDocumentSocket(11, this.GameAvatar.LogicClientAvatar.GetAllianceId());
if (socket != null)
{
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
ServerType = socket.ServerType,
ServerId = socket.ServerId,
SessionId = this.Id
}, this.m_sockets[1]);
}
}
private static void OnGameAvatarRequestMessageReceived(GameAvatarRequestMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar document))
{
ServerRequestManager.SendResponse(new GameAvatarResponseMessage
{
Document = document,
Success = true
}, message);
}
else
{
ServerRequestManager.SendResponse(new GameAvatarResponseMessage(), message);
}
}
private static void OnAllianceShareReplayMessageReceivedReceived(AllianceShareReplayMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
ServerRequestManager.Create(new LoadAvatarStreamRequestMessage
{
Id = message.ReplayId
}, ServerManager.GetDocumentSocket(11, message.ReplayId)).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
LoadAvatarStreamResponseMessage responseMessage = (LoadAvatarStreamResponseMessage)args.ResponseMessage;
if (responseMessage.Entry.GetAvatarStreamEntryType() == AvatarStreamEntryType.ATTACKER_BATTLE_REPORT ||
responseMessage.Entry.GetAvatarStreamEntryType() == AvatarStreamEntryType.DEFENDER_BATTLE_REPORT)
{
BattleReportStreamEntry battleReportStreamEntry = (BattleReportStreamEntry)responseMessage.Entry;
ReplayStreamEntry replayStreamEntry = new ReplayStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(replayStreamEntry, memberEntry);
replayStreamEntry.SetAttack(responseMessage.Entry.GetAvatarStreamEntryType() == AvatarStreamEntryType.ATTACKER_BATTLE_REPORT);
replayStreamEntry.SetBattleLogJSON(battleReportStreamEntry.GetBattleLogJSON());
replayStreamEntry.SetMajorVersion(battleReportStreamEntry.GetMajorVersion());
replayStreamEntry.SetBuildVersion(battleReportStreamEntry.GetBuildVersion());
replayStreamEntry.SetContentVersion(battleReportStreamEntry.GetContentVersion());
replayStreamEntry.SetReplayId(battleReportStreamEntry.GetReplayId());
replayStreamEntry.SetReplayShardId(battleReportStreamEntry.GetReplayShardId());
replayStreamEntry.SetOpponentName(battleReportStreamEntry.GetSenderName());
string replayMessage = message.Message;
if (replayMessage != null && replayMessage.Length > 128)
{
replayMessage = replayMessage.Substring(0, 128);
}
replayStreamEntry.SetMessage(replayMessage);
StreamManager.Create(alliance.Id, replayStreamEntry);
alliance.AddStreamEntry(replayStreamEntry);
AllianceManager.Save(alliance);
}
}
};
}
}
private void Receive()
{
while (this.m_started)
{
this.m_receiveResetEvent.WaitOne();
while (this.m_receiveQueue.TryDequeue(out ServerMessage message))
{
try
{
switch (message.GetMessageCategory())
{
case ServerMessageCategory.ACCOUNT:
this.m_messageManager.OnReceiveAccountMessage((ServerAccountMessage)message);
break;
case ServerMessageCategory.REQUEST:
this.m_messageManager.OnReceiveRequestMessage((ServerRequestMessage)message);
break;
case ServerMessageCategory.SESSION:
this.m_messageManager.OnReceiveSessionMessage((ServerSessionMessage)message);
break;
case ServerMessageCategory.RESPONSE:
ServerRequestManager.ResponseReceived((ServerResponseMessage)message);
break;
case ServerMessageCategory.CORE:
if (!ServerMessageManager.ReceiveCoreMessage((ServerCoreMessage)message))
{
this.m_messageManager.OnReceiveCoreMessage((ServerCoreMessage)message);
}
break;
default:
Logging.Error("ServerMessageHandler.receive: unknown message category: " + message.GetMessageCategory());
break;
}
}
catch (Exception exception)
{
Logging.Warning("ServerMessageHandler.receive: exception when the handle of message type " + message.GetMessageType() + ", trace: " + exception);
}
}
}
}
private static void OnLoadAvatarStreamRequestMessageReceived(LoadAvatarStreamRequestMessage message)
{
AvatarStreamEntry entry = StreamManager.GetAvatarStream(message.Id);
if (entry != null)
{
ServerRequestManager.SendResponse(new LoadAvatarStreamResponseMessage
{
Entry = entry,
Success = true
}, message);
}
else
{
ServerRequestManager.SendResponse(new LoadAvatarStreamResponseMessage(), message);
}
}
public void LoadGameState(GameState state)
{
if (this.GameState != null)
{
throw new Exception("GameSession.loadGameState: current game state should be NULL");
}
state.Home.GetCompressibleGlobalJSON().Set(ResourceManager.SERVER_SAVE_FILE_GLOBAL);
state.Home.GetCompressibleCalendarJSON().Set(ResourceManager.SERVER_SAVE_FILE_CALENDAR);
this.GameState = state;
if (state.GetSimulationServiceNodeType() == SimulationServiceNodeType.BATTLE)
{
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
SessionId = this.Id,
ServerType = 27,
ServerId = -1
}, this.m_sockets[1], 10).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
BindServerSocketResponseMessage responseMessage = (BindServerSocketResponseMessage)args.ResponseMessage;
this.m_sockets[responseMessage.ServerType] = ServerManager.GetSocket(responseMessage.ServerType, responseMessage.ServerId);
this.SendMessage(new GameStateDataMessage
{
State = state
}, responseMessage.ServerType);
}
else
{
Logging.Error("GameSession.loadGameState: unable to bind a battle server to the session.");
this.SendMessage(new StopSessionMessage(), 1);
}
};
}
else
{
this.SendMessage(new GameStateDataMessage
{
State = state
}, 10);
}
}
private void OnJoinAllianceMessageReceived(JoinAllianceMessage message)
{
if (!this.CanJoinAlliance())
{
AllianceJoinFailedMessage allianceJoinFailedMessage = new AllianceJoinFailedMessage();
allianceJoinFailedMessage.SetReason(AllianceJoinFailedMessage.Reason.ALREADY_IN_ALLIANCE);
this.m_session.SendPiranhaMessage(allianceJoinFailedMessage, 1);
return;
}
LogicLong avatarId = this.m_session.GameMode.GetPlayerAvatar().GetId();
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = avatarId,
AllianceId = message.RemoveAllianceId()
}, ServerManager.GetDocumentSocket(9, avatarId)).OnComplete = this.OnGameAllianceJoin;
}
private void OnCreateAllianceMessageReceived(CreateAllianceMessage message)
{
if (!this.CanJoinAlliance())
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
return;
}
LogicClientAvatar playerAvatar = this.m_session.GameMode.GetPlayerAvatar();
if (playerAvatar.GetResourceCount(LogicDataTables.GetGlobals().GetAllianceCreateResourceData()) < LogicDataTables.GetGlobals().GetAllianceCreateCost())
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
return;
}
ServerSocket allianceServer = ServerManager.GetNextSocket(11);
if (allianceServer != null)
{
ServerRequestManager.Create(new CreateAllianceRequestMessage
{
AllianceName = message.GetAllianceName(),
AllianceDescription = message.GetAllianceDescription(),
AllianceType = (AllianceType)message.GetAllianceType(),
AllianceBadgeId = message.GetAllianceBadgeId(),
RequiredScore = message.GetRequiredScore(),
RequiredDuelScore = message.GetRequiredDuelScore(),
WarFrequency = message.GetWarFrequency(),
PublicWarLog = message.GetPublicWarLog(),
ArrangedWarEnabled = message.GetArrangedWarEnabled()
}, allianceServer).OnComplete = this.OnCreateAlliance;
}
else
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
}
}
public GameSession(StartServerSessionMessage message) : base(message)
{
this.LogicMessageManager = new LogicMessageManager(this);
this.GameAvatar = GameAvatarManager.TryGet(this.AccountId, out GameAvatar document) ? document : GameAvatarManager.Create(this.AccountId);
if (this.GameAvatar.CurrentSession != null)
{
GameSessionManager.Remove(this.GameAvatar.CurrentSession.Id);
}
this.GameAvatar.CurrentSession = this;
GameMatchmakingManager.Dequeue(this.GameAvatar);
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
SessionId = this.Id,
ServerType = 10,
ServerId = -1
}, this.m_sockets[1], 10).OnComplete = this.OnHomeServerBound;
}
private void OnJoinAllianceUsingInvitationMessageReceived(JoinAllianceUsingInvitationMessage message)
{
if (this.CanJoinAlliance())
{
ServerRequestManager.Create(new LoadAvatarStreamRequestMessage
{
Id = message.GetAvatarStreamEntryId()
}, ServerManager.GetDocumentSocket(11, this.m_session.AccountId), 5).OnComplete = args =>
{
if (this.m_session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
LoadAvatarStreamResponseMessage responseMessage = (LoadAvatarStreamResponseMessage)args.ResponseMessage;
AllianceInvitationAvatarStreamEntry allianceInvitationAvatarStreamEntry = (AllianceInvitationAvatarStreamEntry)responseMessage.Entry;
LogicLong allianceId = allianceInvitationAvatarStreamEntry.GetAllianceId();
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = this.m_session.AccountId,
AllianceId = allianceId,
AvatarStreamId = allianceInvitationAvatarStreamEntry.GetId(),
Invited = true
}, ServerManager.GetDocumentSocket(9, this.m_session.AccountId)).OnComplete = this.OnGameAllianceJoin;
}
else
{
AllianceJoinFailedMessage allianceJoinFailedMessage = new AllianceJoinFailedMessage();
allianceJoinFailedMessage.SetReason(AllianceJoinFailedMessage.Reason.ALREADY_IN_ALLIANCE);
this.m_session.SendPiranhaMessage(allianceJoinFailedMessage, 1);
}
};
}
else
{
AllianceJoinFailedMessage allianceJoinFailedMessage = new AllianceJoinFailedMessage();
allianceJoinFailedMessage.SetReason(AllianceJoinFailedMessage.Reason.ALREADY_IN_ALLIANCE);
this.m_session.SendPiranhaMessage(allianceJoinFailedMessage, 1);
}
}
private static void OnLoadReplayStreamRequestMessageReceived(LoadReplayStreamRequestMessage message)
{
Core.Database.Document.ReplayStreamEntry entry = StreamManager.GetReplayStream(message.Id);
if (entry != null)
{
ServerRequestManager.SendResponse(new LoadReplayStreamResponseMessage
{
StreamData = entry.GetStreamData(),
MajorVersion = entry.GetMajorVersion(),
BuildVersion = entry.GetBuildVersion(),
ContentVersion = entry.GetContentVersion(),
Success = true
}, message);
}
else
{
ServerRequestManager.SendResponse(new LoadReplayStreamResponseMessage(), message);
}
}
private static async void OnSearchAlliancesMessageReceived(SearchAlliancesMessage message, ForwardLogicRequestMessage requestMessage)
{
if (message.IsJoinableOnly())
{
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = requestMessage.AccountId
}, ServerManager.GetDocumentSocket(9, requestMessage.AccountId), 5).OnComplete = async args =>
{
LogicClientAvatar playerAvatar = null;
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
playerAvatar = ((AvatarResponseMessage)args.ResponseMessage).LogicClientAvatar;
}
AllianceListMessage allianceListMessage = new AllianceListMessage();
allianceListMessage.SetAlliances(await SearchManager.SearchAlliances(message, playerAvatar));
allianceListMessage.SetBookmarkList(new LogicArrayList <LogicLong>());
allianceListMessage.SetSearchString(message.GetSearchString());
ServerMessageManager.SendMessage(SearchMessageManager.CreateForwardLogicMessage(allianceListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
};
}
else
{
AllianceListMessage allianceListMessage = new AllianceListMessage();
allianceListMessage.SetAlliances(await SearchManager.SearchAlliances(message, null));
allianceListMessage.SetBookmarkList(new LogicArrayList <LogicLong>());
allianceListMessage.SetSearchString(message.GetSearchString());
ServerMessageManager.SendMessage(SearchMessageManager.CreateForwardLogicMessage(allianceListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
}
public ServerSession(StartServerSessionMessage message) : this(message.SessionId, message.AccountId, message.Country)
{
LogicArrayList <int> serverSocketTypeList = message.ServerSocketTypeList;
LogicArrayList <int> serverSocketIdList = message.ServerSocketIdList;
for (int i = 0; i < serverSocketTypeList.Size(); i++)
{
int type = serverSocketTypeList[i];
int id = serverSocketIdList[i];
this.m_sockets[type] = ServerManager.GetSocket(type, id);
}
if (message.BindRequestMessage != null)
{
ServerRequestManager.SendResponse(new BindServerSocketResponseMessage
{
ServerType = ServerCore.Type,
ServerId = ServerCore.Id,
Success = true
}, message.BindRequestMessage);
}
}
private static void OnGameStartFakeAttackMessageReceived(GameStartFakeAttackMessage message)
{
if (GameSessionManager.TryGet(message.SessionId, out GameSession session))
{
if (message.AccountId != null)
{
ServerRequestManager.Create(new GameAvatarRequestMessage
{
AccountId = message.AccountId
}, ServerManager.GetDocumentSocket(9, message.AccountId)).OnComplete = args =>
{
if (session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
GameState currentGameState = session.GameState;
if (currentGameState != null && currentGameState.GetGameStateType() == GameStateType.HOME)
{
GameAvatarResponseMessage gameAvatarResponseMessage = (GameAvatarResponseMessage)args.ResponseMessage;
GameDocument document = gameAvatarResponseMessage.Document;
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicMatchmakingCommand());
session.SendPiranhaMessage(availableServerCommandMessage, 1);
session.FakeAttackState = new GameFakeAttackState
{
Home = document.LogicClientHome,
HomeOwnerAvatar = document.LogicClientAvatar,
PlayerAvatar = session.GameAvatar.LogicClientAvatar,
SaveTime = document.SaveTime,
MaintenanceTime = document.MaintenanceTime
};
}
}
else
{
AttackHomeFailedMessage attackHomeFailedMessage = new AttackHomeFailedMessage();
attackHomeFailedMessage.SetReason(AttackHomeFailedMessage.Reason.GENERIC);
session.SendPiranhaMessage(attackHomeFailedMessage, 1);
}
};
}
else
{
GameState currentGameState = session.GameState;
if (currentGameState != null && currentGameState.GetGameStateType() == GameStateType.HOME)
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicMatchmakingCommand());
session.SendPiranhaMessage(availableServerCommandMessage, 1);
session.FakeAttackState = new GameFakeAttackState
{
Home = GameBaseGenerator.GenerateBase((LogicGameObjectData)message.ArgData),
HomeOwnerAvatar = GameBaseGenerator.HomeOwnerAvatar,
PlayerAvatar = session.GameAvatar.LogicClientAvatar,
SaveTime = TimeUtil.GetTimestamp(),
MaintenanceTime = -1
};
}
}
}
}
private static void OnChangeGameStateMessageReceived(ChangeGameStateMessage message)
{
if (GameSessionManager.TryGet(message.SessionId, out GameSession session))
{
GameAvatar document = session.GameAvatar;
switch (message.StateType)
{
case GameStateType.HOME:
session.DestructGameState();
session.LoadGameState(new GameHomeState
{
PlayerAvatar = document.LogicClientAvatar,
Home = document.LogicClientHome,
SaveTime = document.SaveTime,
MaintenanceTime = document.MaintenanceTime,
ServerCommands = document.ServerCommands,
LayoutId = message.LayoutId,
MapId = message.MapId
});
break;
case GameStateType.NPC_ATTACK:
session.DestructGameState();
session.LoadGameState(new GameNpcAttackState
{
PlayerAvatar = document.LogicClientAvatar,
Home = GameResourceManager.NpcHomes[message.NpcData.GetInstanceID()],
NpcAvatar = LogicNpcAvatar.GetNpcAvatar(message.NpcData),
SaveTime = -1
});
break;
case GameStateType.NPC_DUEL:
session.DestructGameState();
session.LoadGameState(new GameNpcDuelState
{
PlayerAvatar = document.LogicClientAvatar,
Home = GameResourceManager.NpcHomes[message.NpcData.GetInstanceID()],
NpcAvatar = LogicNpcAvatar.GetNpcAvatar(message.NpcData),
SaveTime = -1
});
break;
case GameStateType.VISIT:
ServerRequestManager.Create(new GameAvatarRequestMessage
{
AccountId = message.HomeId
}, ServerManager.GetDocumentSocket(9, message.HomeId), 5).OnComplete = args =>
{
if (!session.IsDestructed())
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
GameAvatarResponseMessage gameAvatarResponseMessage = (GameAvatarResponseMessage)args.ResponseMessage;
session.DestructGameState();
session.LoadGameState(new GameVisitState
{
Home = gameAvatarResponseMessage.Document.LogicClientHome,
HomeOwnerAvatar = gameAvatarResponseMessage.Document.LogicClientAvatar,
SaveTime = gameAvatarResponseMessage.Document.SaveTime,
PlayerAvatar = session.GameAvatar.LogicClientAvatar
});
}
else
{
session.SendPiranhaMessage(new VisitFailedMessage(), 1);
}
}
};
break;
case GameStateType.CHALLENGE_ATTACK:
session.DestructGameState();
LogicLong liveReplayId = LiveReplayManager.Create(session, message.ChallengeAllianceId, message.ChallengeStreamId);
LogicClientHome logicClientHome = new LogicClientHome();
logicClientHome.SetHomeId(message.ChallengeHomeId);
logicClientHome.GetCompressibleHomeJSON().Set(message.ChallengeHomeJSON);
session.LoadGameState(new GameChallengeAttackState
{
Home = logicClientHome,
PlayerAvatar = document.LogicClientAvatar,
SaveTime = -1,
LiveReplayId = liveReplayId,
AllianceId = message.ChallengeAllianceId,
StreamId = message.ChallengeStreamId,
MapId = message.ChallengeMapId
});
ServerMessageManager.SendMessage(new AllianceChallengeLiveReplayIdMessage
{
AccountId = message.ChallengeStreamId,
LiveReplayId = liveReplayId
}, 11);
break;
}
}
}
