private static void OnAllianceRequestAllianceUnitsMessageReceived(AllianceRequestAllianceUnitsMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.DONATE && streamEntry.GetSenderAvatarId().Equals(memberEntry.GetAvatarId()))
{
alliance.RemoveStreamEntry(streamEntry.GetId());
}
}
DonateStreamEntry donateStreamEntry = new DonateStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(donateStreamEntry, memberEntry);
string donateMessage = message.Message;
if (donateMessage.Length > 128)
{
donateMessage = donateMessage.Substring(0, 128);
}
donateStreamEntry.SetMessage(donateMessage);
donateStreamEntry.SetCasteLevel(message.CastleUpgradeLevel, message.CastleUsedCapacity, message.CastleSpellUsedCapacity, message.CastleTotalCapacity, message.CastleSpellTotalCapacity);
StreamManager.Create(alliance.Id, donateStreamEntry);
alliance.AddStreamEntry(donateStreamEntry);
AllianceManager.Save(alliance);
}
}
private static void OnAllianceChallengeReportMessageReceived(AllianceChallengeReportMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance))
{
ChallengeStreamEntry streamEntry = (ChallengeStreamEntry)StreamManager.GetAllianceStream(message.StreamId);
if (streamEntry != null)
{
ChallengeReplayStreamEntry challengeReplayStreamEntry = new ChallengeReplayStreamEntry();
challengeReplayStreamEntry.SetSenderAvatarId(challengeReplayStreamEntry.GetSenderAvatarId());
challengeReplayStreamEntry.SetSenderHomeId(challengeReplayStreamEntry.GetSenderHomeId());
challengeReplayStreamEntry.SetSenderName(challengeReplayStreamEntry.GetSenderName());
challengeReplayStreamEntry.SetSenderLevel(challengeReplayStreamEntry.GetSenderLevel());
challengeReplayStreamEntry.SetSenderLeagueType(challengeReplayStreamEntry.GetSenderLeagueType());
challengeReplayStreamEntry.SetSenderRole(challengeReplayStreamEntry.GetSenderRole());
challengeReplayStreamEntry.SetBattleLogJSON(message.BattleLog);
challengeReplayStreamEntry.SetReplayMajorVersion(LogicVersion.MAJOR_VERSION);
challengeReplayStreamEntry.SetReplayBuildVersion(LogicVersion.BUILD_VERSION);
challengeReplayStreamEntry.SetReplayContentVersion(ResourceManager.GetContentVersion());
challengeReplayStreamEntry.SetReplayId(message.ReplayId);
StreamManager.Create(alliance.Id, challengeReplayStreamEntry);
alliance.RemoveStreamEntry(streamEntry.GetId());
alliance.AddStreamEntry(challengeReplayStreamEntry);
}
else
{
Logging.Warning("StreamMessageManager.onAllianceChallengeReportMessageReceived: pStreamEntry has been deleted. Replay ignored.");
}
}
}
public void OnChatToAllianceStreamMessageReceived(ChatToAllianceStreamMessage message)
{
if (!this.CanSendGlobalChatMessage())
{
return;
}
if (this.m_session.Alliance != null)
{
string chatMessage = message.RemoveMessage();
if (string.IsNullOrEmpty(chatMessage))
{
return;
}
if (chatMessage.Length > 128)
{
chatMessage = chatMessage.Substring(0, 128);
}
AllianceMemberEntry memberEntry = this.m_session.Alliance.Members[this.m_session.AccountId];
ChatStreamEntry chatStreamEntry = new ChatStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(chatStreamEntry, memberEntry);
chatStreamEntry.SetMessage(WordCensorUtil.FilterMessage(chatMessage));
StreamManager.Create(this.m_session.Alliance.Id, chatStreamEntry);
this.m_session.Alliance.AddStreamEntry(chatStreamEntry);
AllianceManager.Save(this.m_session.Alliance);
}
}
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 OnLeaveAllianceMemberMessageReceived(LeaveAllianceMemberMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
if (memberEntry.GetAllianceRole() == LogicAvatarAllianceRole.LEADER)
{
AllianceMemberEntry higherMemberEntry = null;
LogicAvatarAllianceRole higherMemberRole = 0;
foreach (AllianceMemberEntry member in alliance.Members.Values)
{
if (member != memberEntry && (higherMemberEntry == null || !member.HasLowerRoleThan(higherMemberRole)))
{
higherMemberEntry = member;
higherMemberRole = member.GetAllianceRole();
}
}
if (higherMemberEntry != null)
{
alliance.ChangeMemberRole(higherMemberEntry, LogicAvatarAllianceRole.LEADER, memberEntry.GetAvatarId(), memberEntry.GetName());
}
}
alliance.RemoveMember(message.MemberId);
AllianceSession session = alliance.GetCurrentOnlineMemberSession(message.AccountId);
if (session != null)
{
AllianceSessionManager.Remove(session.Id);
}
AllianceEventStreamEntry allianceEventStreamEntry = new AllianceEventStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(allianceEventStreamEntry, memberEntry);
allianceEventStreamEntry.SetEventType(AllianceEventStreamEntryType.LEFT);
allianceEventStreamEntry.SetEventAvatarId(memberEntry.GetAvatarId());
allianceEventStreamEntry.SetEventAvatarName(memberEntry.GetName());
StreamManager.Create(alliance.Id, allianceEventStreamEntry);
alliance.AddStreamEntry(allianceEventStreamEntry);
AllianceManager.Save(alliance);
}
ServerMessageManager.SendMessage(new AllianceLeavedMessage
{
AccountId = message.MemberId,
AllianceId = message.AccountId
}, 9);
}
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 OnLeaveAllianceMessageReceived(LeaveAllianceMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
AllianceMemberEntry memberEntry = alliance.Members[this.m_session.AccountId];
if (memberEntry.GetAllianceRole() == LogicAvatarAllianceRole.LEADER)
{
AllianceMemberEntry higherMemberEntry = null;
LogicAvatarAllianceRole higherMemberRole = 0;
foreach (AllianceMemberEntry member in alliance.Members.Values)
{
if (member != memberEntry && (higherMemberEntry == null || !member.HasLowerRoleThan(higherMemberRole)))
{
higherMemberEntry = member;
higherMemberRole = member.GetAllianceRole();
}
}
if (higherMemberEntry != null)
{
alliance.ChangeMemberRole(higherMemberEntry, LogicAvatarAllianceRole.LEADER, memberEntry.GetAvatarId(), memberEntry.GetName());
}
}
AllianceEventStreamEntry allianceEventStreamEntry = new AllianceEventStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(allianceEventStreamEntry, memberEntry);
allianceEventStreamEntry.SetEventType(AllianceEventStreamEntryType.LEFT);
allianceEventStreamEntry.SetEventAvatarId(memberEntry.GetAvatarId());
allianceEventStreamEntry.SetEventAvatarName(memberEntry.GetName());
StreamManager.Create(alliance.Id, allianceEventStreamEntry);
alliance.AddStreamEntry(allianceEventStreamEntry);
alliance.RemoveMember(this.m_session.AccountId);
ServerMessageManager.SendMessage(new AllianceLeavedMessage
{
AccountId = this.m_session.AccountId,
AllianceId = alliance.Id
}, 9);
AllianceManager.Save(alliance);
}
}
private static void OnAllianceChallengeRequestMessageReceived(AllianceChallengeRequestMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
for (int i = 0; i < alliance.StreamEntryList.Size(); i++)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(alliance.StreamEntryList[i]);
if (streamEntry != null && streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE && streamEntry.GetSenderAvatarId().Equals(memberEntry.GetAvatarId()))
{
ChallengeStreamEntry prevChallengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (prevChallengeStreamEntry.IsStarted())
{
return;
}
alliance.RemoveStreamEntry(streamEntry.GetId());
}
}
ChallengeStreamEntry challengeStreamEntry = new ChallengeStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(challengeStreamEntry, memberEntry);
string challengeMessage = message.Message;
if (challengeMessage.Length > 128)
{
challengeMessage = challengeMessage.Substring(0, 128);
}
challengeStreamEntry.SetMessage(challengeMessage);
challengeStreamEntry.SetSnapshotHomeJSON(message.HomeJSON);
challengeStreamEntry.SetWarLayout(message.WarLayout);
StreamManager.Create(alliance.Id, challengeStreamEntry);
alliance.AddStreamEntry(challengeStreamEntry);
AllianceManager.Save(alliance);
}
}
private void OnChangeAllianceSettingsMessageReceived(ChangeAllianceSettingsMessage message)
{
if (this.m_session.Alliance != null)
{
this.m_session.Alliance.SetAllianceSettings(message.GetAllianceDescription(), (AllianceType)message.GetAllianceType(), message.GetAllianceBadgeId(), message.GetRequiredScore(),
message.GetRequiredDuelScore(), message.GetWarFrequency(), message.GetOriginData(), message.IsPublicWarLog(), message.IsAmicalWarEnabled());
AllianceMemberEntry memberEntry = this.m_session.Alliance.Members[this.m_session.AccountId];
AllianceEventStreamEntry allianceEventStreamEntry = new AllianceEventStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(allianceEventStreamEntry, memberEntry);
allianceEventStreamEntry.SetEventType(AllianceEventStreamEntryType.CHANGED_SETTINGS);
allianceEventStreamEntry.SetEventAvatarId(memberEntry.GetAvatarId());
allianceEventStreamEntry.SetEventAvatarName(memberEntry.GetName());
StreamManager.Create(this.m_session.Alliance.Id, allianceEventStreamEntry);
this.m_session.Alliance.AddStreamEntry(allianceEventStreamEntry);
AllianceManager.Save(this.m_session.Alliance);
}
}
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);
}
