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.");
}
}
}
private void OnStartFriendlyChallengeSpectateMessageReceived(StartFriendlyChallengeSpectateMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicLong streamId = message.GetStreamId();
if (alliance.StreamEntryList.IndexOf(streamId) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE)
{
ChallengeStreamEntry challengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (challengeStreamEntry.IsStarted() && challengeStreamEntry.GetLiveReplayId() != null)
{
this.m_session.SendMessage(new GameSpectateLiveReplayMessage
{
LiveReplayId = challengeStreamEntry.GetLiveReplayId(),
IsEnemy = false
}, 9);
return;
}
}
}
}
LiveReplayFailedMessage liveReplayFailedMessage = new LiveReplayFailedMessage();
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(liveReplayFailedMessage, 1);
}
private void OnCancelChallengeMessageReceived(CancelChallengeMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
AllianceMemberEntry memberEntry = alliance.Members[this.m_session.AccountId];
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());
}
}
}
}
private void OnDonateAllianceUnitMessageReceived(DonateAllianceUnitMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicCombatItemData unitData = message.GetAllianceUnitData();
if (!unitData.IsDonationDisabled())
{
if (message.UseQuickDonate())
{
if (!LogicDataTables.GetGlobals().EnableQuickDonate() || this.m_session.LogicClientAvatar.GetDiamonds() < unitData.GetDonateCost())
{
return;
}
}
else
{
if (this.m_session.LogicClientAvatar.GetUnitCount(unitData) <= 0)
{
return;
}
}
if (alliance.StreamEntryList.IndexOf(message.GetStreamId()) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.DONATE)
{
DonateStreamEntry donateStreamEntry = (DonateStreamEntry)streamEntry;
if (donateStreamEntry.CanAddDonation(this.m_session.AccountId, message.GetAllianceUnitData(), alliance.Header.GetAllianceLevel()))
{
donateStreamEntry.AddDonation(this.m_session.AccountId, unitData, this.m_session.LogicClientAvatar.GetUnitUpgradeLevel(unitData));
donateStreamEntry.SetDonationPendingRequestCount(donateStreamEntry.GetDonationPendingRequestCount() + 1);
StreamManager.Save(donateStreamEntry);
alliance.UpdateStreamEntry(donateStreamEntry);
if (message.UseQuickDonate())
{
this.m_session.LogicClientAvatar.CommodityCountChangeHelper(0, unitData, -1);
}
LogicDonateAllianceUnitCommand logicDonateAllianceUnitCommand = new LogicDonateAllianceUnitCommand();
logicDonateAllianceUnitCommand.SetData(unitData, streamEntry.GetId(), message.UseQuickDonate());
ServerMessageManager.SendMessage(new GameAllowServerCommandMessage
{
AccountId = this.m_session.AccountId,
ServerCommand = logicDonateAllianceUnitCommand
}, 9);
}
}
}
}
}
}
private static void OnAllianceChallengeLiveReplayIdMessageReceived(AllianceChallengeLiveReplayIdMessage message)
{
ChallengeStreamEntry streamEntry = (ChallengeStreamEntry)StreamManager.GetAllianceStream(message.AccountId);
if (streamEntry != null)
{
streamEntry.SetLiveReplayId(message.LiveReplayId);
}
}
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 OnAcceptFriendlyBattleMessageReceived(AcceptFriendlyBattleMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
LogicLong streamId = message.GetStreamId();
if (alliance.StreamEntryList.IndexOf(streamId) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.CHALLENGE)
{
ChallengeStreamEntry challengeStreamEntry = (ChallengeStreamEntry)streamEntry;
if (challengeStreamEntry.IsStarted())
{
ChallengeFailedMessage challengeFailedMessage = new ChallengeFailedMessage();
challengeFailedMessage.SetReason(ChallengeFailedMessage.Reason.ALREADY_CLOSED);
this.m_session.SendPiranhaMessage(challengeFailedMessage, 1);
return;
}
this.m_session.SendMessage(new ChangeGameStateMessage
{
StateType = GameStateType.CHALLENGE_ATTACK,
ChallengeAllianceId = alliance.Id,
ChallengeHomeId = challengeStreamEntry.GetSenderAvatarId(),
ChallengeStreamId = challengeStreamEntry.GetId(),
ChallengeHomeJSON = challengeStreamEntry.GetSnapshotHomeJSON(),
ChallengeMapId = challengeStreamEntry.IsWarLayout() ? 1 : 0
}, 9);
challengeStreamEntry.SetStarted(true);
alliance.UpdateStreamEntry(challengeStreamEntry);
return;
}
}
}
ChallengeFailedMessage challengeFailedMessageGeneric = new ChallengeFailedMessage();
challengeFailedMessageGeneric.SetReason(ChallengeFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(challengeFailedMessageGeneric, 1);
}
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 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 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);
}
}
}
}
}
}
