Esempio n. 1
0
        private void Agression(ulong targetid)
        {
            GameRolePlayPlayerFightRequestMessage packet = new GameRolePlayPlayerFightRequestMessage
            {
                Friendly     = false,
                TargetCellId = -1,
                TargetId     = targetid
            };

            account.SocketManager.Send(packet);
        }
Esempio n. 2
0
        private void Agression(int targetid)
        {
            GameRolePlayPlayerFightRequestMessage packet = new GameRolePlayPlayerFightRequestMessage
            {
                friendly     = false,
                targetCellId = -1,
                targetId     = targetid
            };

            using (BigEndianWriter writer = new BigEndianWriter())
            {
                packet.Serialize(writer);
                MessagePackaging pack = new MessagePackaging(writer);
                pack.Pack((int)packet.ProtocolID);
                account.SocketManager.Send(pack.Writer.Content);
            }
        }
        public static void HandleGameRolePlayPlayerFightRequest(GameRolePlayPlayerFightRequestMessage message, WorldClient client)
        {
            Character target = client.Character.Map.Instance.GetEntity <Character>((long)message.targetId);

            if (target != null)
            {
                if (message.friendly)
                {
                    FighterRefusedReasonEnum fighterRefusedReasonEnum = client.Character.CanRequestFight(target);
                    if (fighterRefusedReasonEnum != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                    {
                        client.Send(new ChallengeFightJoinRefusedMessage((ulong)client.Character.Id, (sbyte)fighterRefusedReasonEnum));
                    }
                    else
                    {
                        target.OpenRequestBox(new DualRequest(client.Character, target));
                    }
                }
                else
                {
                    FighterRefusedReasonEnum fighterRefusedReasonEnum = client.Character.CanAgress(target);
                    if (fighterRefusedReasonEnum != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                    {
                        client.Send(new ChallengeFightJoinRefusedMessage((ulong)client.Character.Id, (sbyte)fighterRefusedReasonEnum));
                    }
                    else
                    {
                        FightAgression fight = FightProvider.Instance.CreateFightAgression(client.Character, target, (short)client.Character.CellId);

                        fight.RedTeam.AddFighter(target.CreateFighter(fight.RedTeam));

                        fight.BlueTeam.AddFighter(client.Character.CreateFighter(fight.BlueTeam));

                        fight.StartPlacement();
                    }
                }
            }
        }
        public static void HandleChallengeRequest(GameRolePlayPlayerFightRequestMessage message, WorldClient client)
        {
            if (client.Character.Map != null && client.Character.Map.HaveZaap)
            {
                client.Character.Reply("Action impossible sur cette carte.");
                return;
            }
            WorldClient target = WorldServer.Instance.GetOnlineClient((int)message.targetId);

            if (target.Character.Busy)
            {
                client.Character.Reply("Impossible car le joueur est occupé.");
                return;
            }
            if (message.friendly)
            {
                FightDual fight = FightProvider.Instance.CreateDualFight(client.Character.Map, client.Character.Record.CellId, message.targetCellId);
                fight.InitiatorId = client.Character.Id;
                fight.AcceptorId  = target.Character.Id;
                Message sMessage = new GameRolePlayPlayerFightFriendlyRequestedMessage(fight.Id, (uint)client.Character.Id, message.targetId);
                client.Send(sMessage);
                target.Send(sMessage);
            }
        }
Esempio n. 5
0
        public static void HandleGameRolePlayPlayerFightRequestMessage(WorldClient client, GameRolePlayPlayerFightRequestMessage message)
        {
            var target = client.Character.Map.GetActor <Character>((int)message.targetId);

            if (target == null)
            {
                return;
            }

            if (message.friendly)
            {
                var reason = client.Character.CanRequestFight(target);
                if (reason != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                {
                    SendChallengeFightJoinRefusedMessage(client, client.Character, reason);
                }
                else
                {
                    var fightRequest = new FightRequest(client.Character, target);
                    fightRequest.Open();
                }
            }
            else // agression
            {
                var reason = client.Character.CanAgress(target);
                if (reason != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                {
                    SendChallengeFightJoinRefusedMessage(client, client.Character, reason);
                }
                else
                {
                    foreach (var character in target.Map.GetAllCharacters().Where(x => x != target && x != client.Character))
                    {
                        ContextRoleplayHandler.SendGameRolePlayAggressionMessage(character.Client, client.Character, target);
                    }
                    //<b>%1</b> agresse <b>%2</b>

                    var fight = FightManager.Instance.CreateAgressionFight(target.Map,
                                                                           client.Character.AlignmentSide, target.AlignmentSide);

                    fight.ChallengersTeam.AddFighter(client.Character.CreateFighter(fight.ChallengersTeam));
                    fight.DefendersTeam.AddFighter(target.CreateFighter(fight.DefendersTeam));

                    fight.StartPlacement();
                }
            }
        }
        public static void HandleChallengeRequest(GameRolePlayPlayerFightRequestMessage message, WorldClient client)
        {
            if (client.Character.Map != null && client.Character.Map.HaveZaap)
            {
                client.Character.Reply("Action impossible sur cette carte.");
                return;
            }
            WorldClient target = WorldServer.Instance.GetOnlineClient((int)message.targetId);
            if (target.Character.Busy)
            {
                client.Character.Reply("Impossible car le joueur est occupé.");
                return;
            }
            if (message.friendly)
            {

                FightDual fight = FightProvider.Instance.CreateDualFight(client.Character.Map, client.Character.Record.CellId, message.targetCellId);
                fight.InitiatorId = client.Character.Id;
                fight.AcceptorId = target.Character.Id;
                Message sMessage = new GameRolePlayPlayerFightFriendlyRequestedMessage(fight.Id, (uint)client.Character.Id, message.targetId);
                client.Send(sMessage);
                target.Send(sMessage);
            }
        }
Esempio n. 7
0
 private void GameRolePlayPlayerFightRequestMessageHandler(DofusClient client,
                                                           GameRolePlayPlayerFightRequestMessage message)
 {
     //
 }
Esempio n. 8
0
        public static void HandleGameRolePlayPlayerFightRequestMessage(WorldClient client, GameRolePlayPlayerFightRequestMessage message)
        {
            Character actor = client.Character.Map.GetActor <Character>((int)message.targetId);

            if (actor != null)
            {
                if (message.friendly)
                {
                    FighterRefusedReasonEnum fighterRefusedReasonEnum = client.Character.CanRequestFight(actor);
                    if (fighterRefusedReasonEnum != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                    {
                        ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, fighterRefusedReasonEnum);
                    }
                    else
                    {
                        FightRequest fightRequest = new FightRequest(client.Character, actor);
                        client.Character.OpenRequestBox(fightRequest);
                        actor.OpenRequestBox(fightRequest);
                        fightRequest.Open();
                    }
                }
                else
                {
                    FighterRefusedReasonEnum fighterRefusedReasonEnum = client.Character.CanAgress(actor);
                    if (fighterRefusedReasonEnum != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                    {
                        ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, fighterRefusedReasonEnum);
                    }
                    else
                    {
                        Fight fight = Singleton <FightManager> .Instance.CreateAgressionFight(actor.Map, client.Character.AlignmentSide, actor.AlignmentSide);

                        fight.RedTeam.AddFighter(client.Character.CreateFighter(fight.RedTeam));
                        fight.BlueTeam.AddFighter(actor.CreateFighter(fight.BlueTeam));
                        fight.StartPlacement();
                    }
                }
            }
        }