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 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);
}
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 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 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);
}
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 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 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);
}
}
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);
}
}
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 OnGameCreateAllianceInvitationRequestMessageReceived(GameCreateAllianceInvitationRequestMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar avatar))
{
if (avatar.LogicClientAvatar.IsInAlliance() || avatar.HasServerCommandOfType(LogicCommandType.JOIN_ALLIANCE) || avatar.PendingAllianceJoinResponse)
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.ALREADY_IN_ALLIANCE
}, message);
return;
}
if (!avatar.LogicClientAvatar.HasAllianceCastle())
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.NO_CASTLE
}, message);
return;
}
ServerRequestManager.Create(new LoadAvatarStreamOfTypeRequestMessage
{
StreamIds = avatar.AvatarStreamList,
SenderAvatarId = message.Entry.GetSenderAvatarId(),
Type = AvatarStreamEntryType.ALLIANCE_INVITATION
}, ServerManager.GetDocumentSocket(11, avatar.Id), 5).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
LoadAvatarStreamOfTypeResponseMessage loadAvatarStreamOfTypeResponseMessage = (LoadAvatarStreamOfTypeResponseMessage)args.ResponseMessage;
for (int i = 0; i < loadAvatarStreamOfTypeResponseMessage.StreamList.Size(); i++)
{
AllianceInvitationAvatarStreamEntry allianceInvitationAvatarStreamEntry = (AllianceInvitationAvatarStreamEntry)loadAvatarStreamOfTypeResponseMessage.StreamList[i];
if (allianceInvitationAvatarStreamEntry.GetAllianceId().Equals(message.Entry.GetAllianceId()))
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.ALREADY_HAS_AN_INVITE
}, message);
return;
}
}
if (loadAvatarStreamOfTypeResponseMessage.StreamList.Size() >= 10)
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.HAS_TOO_MANY_INVITES
}, message);
}
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = message.AccountId,
Entry = message.Entry
}, 9);
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
Success = true
}, message);
}
else
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.GENERIC
}, message);
}
};
}
else
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.GENERIC
}, message);
}
}
private static void OnGameJoinAllianceRequestMessageReceived(GameJoinAllianceRequestMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar document))
{
if (document.LogicClientAvatar.IsInAlliance() || document.HasServerCommandOfType(LogicCommandType.JOIN_ALLIANCE))
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.ALREADY_IN_ALLIANCE
}, message);
return;
}
if (!document.LogicClientAvatar.HasAllianceCastle())
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.NO_CASTLE
}, message);
return;
}
if (document.PendingAllianceJoinResponse || message.AvatarStreamId != null && document.AvatarStreamList.IndexOf(message.AvatarStreamId) == -1)
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.GENERIC
}, message);
return;
}
document.PendingAllianceJoinResponse = true;
ServerRequestManager.Create(new AllianceJoinRequestMessage
{
AllianceId = message.AllianceId,
Avatar = document.LogicClientAvatar,
Created = message.Created,
Invited = message.Invited
}, ServerManager.GetDocumentSocket(11, message.AllianceId), 15).OnComplete = args =>
{
document.PendingAllianceJoinResponse = false;
if (args.ErrorCode == ServerRequestError.Success)
{
AllianceJoinResponseMessage allianceJoinResponseMessage = (AllianceJoinResponseMessage)args.ResponseMessage;
if (allianceJoinResponseMessage.Success)
{
if (message.AvatarStreamId != null)
{
document.RemoveAvatarStreamEntry(message.AvatarStreamId);
}
LogicJoinAllianceCommand logicJoinAllianceCommand = new LogicJoinAllianceCommand();
logicJoinAllianceCommand.SetAllianceData(allianceJoinResponseMessage.AllianceId, allianceJoinResponseMessage.AllianceName, allianceJoinResponseMessage.AllianceBadgeId, allianceJoinResponseMessage.AllianceLevel, allianceJoinResponseMessage.Created);
document.AddServerCommand(logicJoinAllianceCommand);
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
Success = true
}, message);
}
else
{
GameJoinAllianceResponseMessage gameJoinAllianceResponseMessage = new GameJoinAllianceResponseMessage();
switch (allianceJoinResponseMessage.ErrorReason)
{
case AllianceJoinResponseMessage.Reason.GENERIC:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.GENERIC;
break;
case AllianceJoinResponseMessage.Reason.FULL:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.FULL;
break;
case AllianceJoinResponseMessage.Reason.CLOSED:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.CLOSED;
break;
case AllianceJoinResponseMessage.Reason.SCORE:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.SCORE;
break;
case AllianceJoinResponseMessage.Reason.BANNED:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.BANNED;
break;
}
ServerRequestManager.SendResponse(gameJoinAllianceResponseMessage, message);
}
}
else
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.GENERIC
}, message);
}
};
}
}
private static void OnRequestAllianceJoinRequestMessageReceived(RequestAllianceJoinRequestMessage message)
{
if (AllianceManager.TryGet(message.AllianceId, out Alliance alliance))
{
LogicLong avatarId = message.Avatar.GetId();
if (alliance.Members.ContainsKey(avatarId) || alliance.Header.GetAllianceType() == AllianceType.OPEN)
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.GENERIC
}, message);
return;
}
if (alliance.Header.GetAllianceType() == AllianceType.CLOSED)
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.CLOSED
}, message);
return;
}
if (alliance.IsBanned(avatarId))
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.BANNED
}, message);
return;
}
int pendingRequestCount = 0;
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.JOIN_REQUEST)
{
JoinRequestAllianceStreamEntry prevJoinRequestStreamEntry = (JoinRequestAllianceStreamEntry)streamEntry;
if (prevJoinRequestStreamEntry.GetState() == 1)
{
pendingRequestCount += 1;
if (prevJoinRequestStreamEntry.GetSenderAvatarId().Equals(avatarId))
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.ALREADY_SENT
}, message);
return;
}
}
else if (prevJoinRequestStreamEntry.GetState() == 0 && prevJoinRequestStreamEntry.GetAgeSeconds() < 3600)
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.ALREADY_SENT
}, message);
return;
}
}
}
if (pendingRequestCount >= 10)
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.TOO_MANY_PENDING_REQUESTS
}, message);
return;
}
if (message.Avatar.GetScore() < alliance.Header.GetRequiredScore())
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.NO_SCORE
}, message);
return;
}
if (message.Avatar.GetDuelScore() < alliance.Header.GetRequiredDuelScore())
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.NO_DUEL_SCORE
}, message);
return;
}
JoinRequestAllianceStreamEntry joinRequestAllianceStreamEntry = new JoinRequestAllianceStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(joinRequestAllianceStreamEntry, message.Avatar);
string requestMessage = message.Message;
if (requestMessage != null && requestMessage.Length >= 128)
{
requestMessage = requestMessage.Substring(0, 128);
}
joinRequestAllianceStreamEntry.SetMessage(requestMessage);
StreamManager.Create(alliance.Id, joinRequestAllianceStreamEntry);
alliance.AddStreamEntry(joinRequestAllianceStreamEntry);
AllianceManager.Save(alliance);
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
Success = true
}, message);
}
else
{
ServerRequestManager.SendResponse(new RequestAllianceJoinResponseMessage
{
ErrorReason = RequestAllianceJoinResponseMessage.Reason.GENERIC
}, message);
}
}
private static void OnAllianceJoinRequestMessageReceived(AllianceJoinRequestMessage message)
{
AllianceJoinResponseMessage joinAllianceResponseMessage = new AllianceJoinResponseMessage();
if (!AllianceManager.TryGet(message.AllianceId, out Alliance alliance))
{
joinAllianceResponseMessage.ErrorReason = AllianceJoinResponseMessage.Reason.GENERIC;
ServerRequestManager.SendResponse(joinAllianceResponseMessage, message);
return;
}
if (!message.Created)
{
if (alliance.IsFull())
{
joinAllianceResponseMessage.ErrorReason = AllianceJoinResponseMessage.Reason.FULL;
ServerRequestManager.SendResponse(joinAllianceResponseMessage, message);
return;
}
if (!message.Invited)
{
if (alliance.Header.GetAllianceType() != AllianceType.OPEN || alliance.Header.GetNumberOfMembers() == 0)
{
joinAllianceResponseMessage.ErrorReason =
alliance.Header.GetAllianceType() == AllianceType.CLOSED ? AllianceJoinResponseMessage.Reason.CLOSED : AllianceJoinResponseMessage.Reason.GENERIC;
ServerRequestManager.SendResponse(joinAllianceResponseMessage, message);
return;
}
if (alliance.IsBanned(message.Avatar.GetId()))
{
joinAllianceResponseMessage.ErrorReason = AllianceJoinResponseMessage.Reason.BANNED;
ServerRequestManager.SendResponse(joinAllianceResponseMessage, message);
return;
}
if (alliance.Header.GetRequiredScore() > message.Avatar.GetScore() || alliance.Header.GetRequiredDuelScore() > message.Avatar.GetDuelScore())
{
joinAllianceResponseMessage.ErrorReason = AllianceJoinResponseMessage.Reason.SCORE;
ServerRequestManager.SendResponse(joinAllianceResponseMessage, message);
return;
}
}
}
else
{
if (alliance.Header.GetNumberOfMembers() != 0)
{
throw new Exception("StreamMessageManager.joinAllianceRequestMessageReceived: A new alliance must be empty!");
}
}
AllianceMemberEntry memberEntry = AllianceMemberUtil.GetAllianceMemberEntryFromAvatar(message.Avatar);
memberEntry.SetAllianceRole(message.Created ? LogicAvatarAllianceRole.LEADER : LogicAvatarAllianceRole.MEMBER);
alliance.AddMember(memberEntry);
if (!message.Created)
{
AllianceEventStreamEntry allianceEventStreamEntry = new AllianceEventStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(allianceEventStreamEntry, memberEntry);
allianceEventStreamEntry.SetEventType(AllianceEventStreamEntryType.JOINED);
allianceEventStreamEntry.SetEventAvatarId(memberEntry.GetAvatarId());
allianceEventStreamEntry.SetEventAvatarName(memberEntry.GetName());
StreamManager.Create(alliance.Id, allianceEventStreamEntry);
alliance.AddStreamEntry(allianceEventStreamEntry);
}
joinAllianceResponseMessage.Success = true;
joinAllianceResponseMessage.AllianceId = alliance.Id;
joinAllianceResponseMessage.AllianceName = alliance.Header.GetAllianceName();
joinAllianceResponseMessage.AllianceBadgeId = alliance.Header.GetAllianceBadgeId();
joinAllianceResponseMessage.AllianceLevel = alliance.Header.GetAllianceLevel();
joinAllianceResponseMessage.Created = message.Created;
AllianceManager.Save(alliance);
ServerRequestManager.SendResponse(joinAllianceResponseMessage, message);
}
