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.");
}
}
}
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 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 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 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);
}
}
private void OnChangeAllianceMemberRoleMessageReceived(ChangeAllianceMemberRoleMessage message)
{
if (this.m_session.Alliance != null)
{
LogicLong memberId = message.RemoveMemberId();
if (!this.m_session.Alliance.Members.TryGetValue(memberId, out AllianceMemberEntry memberEntry))
{
return;
}
AllianceMemberEntry eventMemberEntry = this.m_session.Alliance.Members[this.m_session.AccountId];
if (message.GetMemberRole() == LogicAvatarAllianceRole.MEMBER ||
message.GetMemberRole() == LogicAvatarAllianceRole.LEADER ||
message.GetMemberRole() == LogicAvatarAllianceRole.ELDER ||
message.GetMemberRole() == LogicAvatarAllianceRole.CO_LEADER)
{
if (memberEntry.HasLowerRoleThan(eventMemberEntry.GetAllianceRole()) &&
!eventMemberEntry.HasLowerRoleThan(message.GetMemberRole()))
{
if (message.GetMemberRole() == LogicAvatarAllianceRole.LEADER)
{
this.m_session.Alliance.ChangeMemberRole(eventMemberEntry, LogicAvatarAllianceRole.CO_LEADER, eventMemberEntry.GetAvatarId(), eventMemberEntry.GetName());
}
this.m_session.Alliance.ChangeMemberRole(memberEntry, message.GetMemberRole(), memberEntry.GetAvatarId(), memberEntry.GetName());
AllianceManager.Save(this.m_session.Alliance);
}
}
}
}
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);
}
}
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);
}
}
public static void Init()
{
ServerStream.AllianceDatabase = new CouchbaseDatabase("magic-alliances", "data");
ServerStream.StreamDatabase = new CouchbaseDatabase("magic-streams", "stream");
AllianceManager.Init();
StreamManager.Init();
AllianceSessionManager.Init();
WordCensorUtil.Init();
}
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 OnAllianceChallengeSpectatorCountMessageReceived(AllianceChallengeSpectatorCountMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance))
{
ChallengeStreamEntry streamEntry = (ChallengeStreamEntry)StreamManager.GetAllianceStream(message.StreamId);
if (streamEntry != null && streamEntry.GetSpectatorCount() != message.Count)
{
streamEntry.SetSpectatorCount(message.Count);
alliance.UpdateStreamEntry(streamEntry);
}
}
}
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 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 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 static void OnAllianceUnitDonateResponseMessageReceived(AllianceUnitDonateResponseMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance))
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.StreamId);
if (streamEntry != null)
{
DonateStreamEntry donateStreamEntry = (DonateStreamEntry)streamEntry;
if (message.Success)
{
LogicAllianceLevelData allianceLevel = LogicDataTables.GetAllianceLevel(alliance.Header.GetAllianceLevel());
LogicAllianceUnitReceivedCommand logicAllianceUnitReceivedCommand = new LogicAllianceUnitReceivedCommand();
logicAllianceUnitReceivedCommand.SetData(message.MemberName, message.Data,
LogicMath.Clamp(message.UpgradeLevel + allianceLevel.GetTroopDonationUpgrade(), 0, message.Data.GetUpgradeLevelCount() - 1));
ServerMessageManager.SendMessage(new GameAllowServerCommandMessage
{
AccountId = donateStreamEntry.GetSenderAvatarId(),
ServerCommand = logicAllianceUnitReceivedCommand
}, 9);
}
else
{
donateStreamEntry.RemoveDonation(message.MemberId, message.Data, message.UpgradeLevel);
alliance.UpdateStreamEntry(donateStreamEntry);
}
donateStreamEntry.SetDonationPendingRequestCount(donateStreamEntry.GetDonationPendingRequestCount() - 1);
if (donateStreamEntry.IsCastleFull() && donateStreamEntry.GetDonationPendingRequestCount() <= 0)
{
alliance.RemoveStreamEntry(donateStreamEntry.GetId());
AllianceManager.Save(alliance);
}
else
{
StreamManager.Save(donateStreamEntry);
}
}
}
}
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 OnAllianceUpdateAvatarDataMessageReceived(AllianceAvatarChangesMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
bool updateScoring = false;
for (int i = 0; i < message.AvatarChanges.Size(); i++)
{
AvatarChange avatarChange = message.AvatarChanges[i];
avatarChange.ApplyAvatarChange(memberEntry);
if (avatarChange.GetAvatarChangeType() == AvatarChangeType.SCORE || avatarChange.GetAvatarChangeType() == AvatarChangeType.DUEL_SCORE)
{
updateScoring = true;
}
}
AllianceSession currentSession = alliance.GetCurrentOnlineMemberSession(message.MemberId);
if (currentSession != null && currentSession.LogicClientAvatar != null)
{
for (int i = 0; i < message.AvatarChanges.Size(); i++)
{
message.AvatarChanges[i].ApplyAvatarChange(currentSession.LogicClientAvatar);
}
}
if (updateScoring)
{
alliance.UpdateScoring();
}
AllianceManager.Save(alliance);
}
}
private void OnRespondToAllianceJoinRequestMessageReceived(RespondToAllianceJoinRequestMessage 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.MEMBER)
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.NO_RIGHTS);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
return;
}
LogicLong streamId = message.GetStreamEntryId();
if (alliance.StreamEntryList.IndexOf(streamId) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamEntryId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.JOIN_REQUEST)
{
JoinRequestAllianceStreamEntry joinRequestAllianceStreamEntry = (JoinRequestAllianceStreamEntry)streamEntry;
if (joinRequestAllianceStreamEntry.GetState() == 1)
{
if (message.IsAccepted())
{
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = joinRequestAllianceStreamEntry.GetSenderAvatarId(),
AllianceId = alliance.Id,
Invited = true
}, ServerManager.GetDocumentSocket(9, joinRequestAllianceStreamEntry.GetSenderAvatarId())).OnComplete = args =>
{
if (this.m_session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success)
{
if (args.ResponseMessage.Success)
{
joinRequestAllianceStreamEntry.SetState(2);
joinRequestAllianceStreamEntry.SetResponderName(memberEntry.GetName());
alliance.UpdateStreamEntry(joinRequestAllianceStreamEntry);
StreamManager.Save(joinRequestAllianceStreamEntry);
}
else
{
GameJoinAllianceResponseMessage gameJoinAllianceResponseMessage = (GameJoinAllianceResponseMessage)args.ResponseMessage;
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
switch (gameJoinAllianceResponseMessage.ErrorReason)
{
case GameJoinAllianceResponseMessage.Reason.NO_CASTLE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.NO_CASTLE);
if (joinRequestAllianceStreamEntry.GetState() == 1)
{
alliance.RemoveStreamEntry(joinRequestAllianceStreamEntry.GetId());
AllianceManager.Save(alliance);
}
break;
case GameJoinAllianceResponseMessage.Reason.ALREADY_IN_ALLIANCE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.ALREADY_IN_ALLIANCE);
if (joinRequestAllianceStreamEntry.GetState() == 1)
{
alliance.RemoveStreamEntry(joinRequestAllianceStreamEntry.GetId());
AllianceManager.Save(alliance);
}
break;
default:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.GENERIC);
break;
}
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
}
}
else
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
}
};
}
else
{
joinRequestAllianceStreamEntry.SetState(0);
joinRequestAllianceStreamEntry.SetResponderName(memberEntry.GetName());
alliance.UpdateStreamEntry(joinRequestAllianceStreamEntry);
StreamManager.Save(joinRequestAllianceStreamEntry);
JoinAllianceResponseAvatarStreamEntry joinAllianceResponseAvatarStreamEntry = new JoinAllianceResponseAvatarStreamEntry();
joinAllianceResponseAvatarStreamEntry.SetSenderAvatarId(memberEntry.GetAvatarId());
joinAllianceResponseAvatarStreamEntry.SetSenderHomeId(memberEntry.GetHomeId());
joinAllianceResponseAvatarStreamEntry.SetSenderName(memberEntry.GetName());
joinAllianceResponseAvatarStreamEntry.SetSenderLevel(memberEntry.GetExpLevel());
joinAllianceResponseAvatarStreamEntry.SetSenderLeagueType(memberEntry.GetLeagueType());
joinAllianceResponseAvatarStreamEntry.SetAllianceId(alliance.Id);
joinAllianceResponseAvatarStreamEntry.SetAllianceName(alliance.Header.GetAllianceName());
joinAllianceResponseAvatarStreamEntry.SetAllianceBadgeId(alliance.Header.GetAllianceBadgeId());
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = joinRequestAllianceStreamEntry.GetSenderAvatarId(),
Entry = joinAllianceResponseAvatarStreamEntry
}, 9);
}
}
}
}
}
}
private static void ServerMessageReceived(PSMessage psMessage, bool isPusher)
{
if (!isPusher)
{
return;
}
if (psMessage.ActivityType == ActivityType.MembershipChanged && isPusher)
{
if (SingletonManager <UserManager> .Instance.user.Id == psMessage.ToUserId)
{
Debug.LogWarning((object)"Membership Changed", (Object)null);
SingletonManager <UserManager> .Instance.user.AllianceMembership = AllianceManager.MembershipStringToEnum(psMessage.ActivityArgument);
}
if (SingletonManager <UserManager> .Instance.user.AllianceMembership == AllianceMembership.None)
{
Debug.LogWarning((object)"Membership Reset", (Object)null);
SingletonManager <AllianceManager> .Instance.ResetCurrentAlliance();
}
}
if (psMessage.ActivityType == ActivityType.DeviceLogin && !psMessage.ActivityArgument.Equals(UserManager.Md5Sum(SingletonManager <UserManager> .Instance.deviceKey)))
{
AlertController.ShowDisconnectPanel(SingletonManager <LocalizationManager> .Instance.GetLocalizedText("Disconnected"), psMessage.MessageString, SingletonManager <LocalizationManager> .Instance.GetLocalizedText("Reload"));
}
if (psMessage.ActivityType != ActivityType.ModelUpdate || string.IsNullOrEmpty(psMessage.ActivityArgument))
{
return;
}
PSMainRoom room = SingletonManager <RoomManager> .Instance.ParseRoom <PSMainRoom>(Regex.Unescape(psMessage.ActivityArgument));
SingletonManager <ShipManager> .Instance.PlayerShip.GetRoomByRoomId(room.RoomId).ConstructionStartDate = room.ConstructionStartDate;
}
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);
}
