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);
                    }
                };
            }
        }
Beispiel #2
0
        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);
        }