public static void HandleGameRolePlayTaxCollectorFightRequestMessage(WorldClient client, GameRolePlayTaxCollectorFightRequestMessage message)
		{
			TaxCollectorNpc actor = client.Character.Map.GetActor<TaxCollectorNpc>(message.taxCollectorId);
			FighterRefusedReasonEnum fighterRefusedReasonEnum = client.Character.CanAttack(actor);
			if (fighterRefusedReasonEnum != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
			{
				ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, fighterRefusedReasonEnum);
			}
			FightPvT fightPvT = Singleton<FightManager>.Instance.CreatePvTFight(client.Character.Map);
			fightPvT.RedTeam.AddFighter(client.Character.CreateFighter(fightPvT.RedTeam));
			fightPvT.BlueTeam.AddFighter(actor.CreateFighter(fightPvT.BlueTeam));
			fightPvT.StartPlacement();
		}
		public static void HandleGuildFightJoinRequestMessage(WorldClient client, GuildFightJoinRequestMessage message)
		{
			if (client.Character.Guild != null)
			{
				TaxCollectorNpc taxCollectorNpc = client.Character.Guild.TaxCollectors.FirstOrDefault((TaxCollectorNpc x) => x.GlobalId == message.taxCollectorId);
				if (taxCollectorNpc != null && taxCollectorNpc.IsFighting)
				{
					FightPvT fightPvT = taxCollectorNpc.Fighter.Fight as FightPvT;
					if (fightPvT != null)
					{
						FighterRefusedReasonEnum fighterRefusedReasonEnum = fightPvT.AddDefender(client.Character);
						if (fighterRefusedReasonEnum != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
						{
							ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, fighterRefusedReasonEnum);
						}
					}
				}
			}
		}
Esempio n. 3
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();
                    }
                }
            }
        }
        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();
                    }
                }
            }
        }
Esempio n. 5
0
 public static void SendChallengeFightJoinRefusedMessage(IPacketReceiver client, Character character,
                                                         FighterRefusedReasonEnum reason)
 {
     client.Send(new ChallengeFightJoinRefusedMessage(character.Id, (sbyte)reason));
 }
 private void OnRefused(Character character, FighterRefusedReasonEnum reason)
 {
     character.Client.Send(new ChallengeFightJoinRefusedMessage((ulong)character.Id, (sbyte)reason));
 }