C# GamePlayer.GetPlayersInRadius方法代码示例

		public override void Execute(GameLiving living)
		{
			if (CheckPreconditions(living, DEAD | SITTING | MEZZED | STUNNED)) return;

			GamePlayer player = living as GamePlayer;
			if (player == null)
				return;

			if (player.IsMoving)
			{
				player.Out.SendMessage("You must be standing still to use this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
				return;
			}

			if (player.GroundTarget == null )
            {
                player.Out.SendMessage( "You must set a ground target to use this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow );
                return;
            }
            else if(!player.IsWithinRadius( player.GroundTarget, 1500 ))
			{
				player.Out.SendMessage("Your ground target is too far away to use this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
				return;
			}

			this.player = player;
			if (player.AttackState)
			{
				player.StopAttack();
			}
			player.StopCurrentSpellcast();
			switch (Level)
			{
				case 1: dmgValue = 25; duration = 10; break;
				case 2: dmgValue = 100; duration = 20; break;
				case 3: dmgValue = 250; duration = 30; break;
				default: return;
			}
			foreach (GamePlayer i_player in player.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
			{
				if (i_player == player) i_player.Out.SendMessage("You cast " + this.Name + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
				else i_player.Out.SendMessage(player.Name + " casts a spell!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);

				i_player.Out.SendSpellCastAnimation(player, 7028, 20);
			}

			if (player.RealmAbilityCastTimer != null)
			{
				player.RealmAbilityCastTimer.Stop();
				player.RealmAbilityCastTimer = null;
				player.Out.SendMessage("You cancel your Spell!", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow);
			}

			player.RealmAbilityCastTimer = new RegionTimer(player);
			player.RealmAbilityCastTimer.Callback = new RegionTimerCallback(EndCast);
			player.RealmAbilityCastTimer.Start(2000);
		}

		public override void Execute(GameLiving living)
		{
			if (CheckPreconditions(living, DEAD | SITTING | MEZZED | STUNNED)) return;
			m_caster = living as GamePlayer;
			if (m_caster == null)
				return;

			if (m_caster.TargetObject == null)
			{
				m_caster.Out.SendMessage("You need a target for this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
				m_caster.DisableSkill(this, 3 * 1000);
				return;
			}

			if ( !m_caster.IsWithinRadius( m_caster.TargetObject, (int)( 1500 * m_caster.GetModified(eProperty.SpellRange) * 0.01 ) ) )
			{
				m_caster.Out.SendMessage(m_caster.TargetObject + " is too far away.", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
				return;
			}

			switch (Level)
			{
				case 1: m_dmgValue = 200; break;
				case 2: m_dmgValue = 500; break;
				case 3: m_dmgValue = 750; break;
				default: return;
			}

			foreach (GamePlayer i_player in m_caster.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
			{
				if (i_player == m_caster)
				{
					i_player.MessageToSelf("You cast " + this.Name + "!", eChatType.CT_Spell);
				}
				else
				{
					i_player.MessageFromArea(m_caster, m_caster.Name + " casts a spell!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
				}

				i_player.Out.SendSpellCastAnimation(m_caster, 7025, 20);
			}

			if (m_caster.RealmAbilityCastTimer != null)
			{
				m_caster.RealmAbilityCastTimer.Stop();
				m_caster.RealmAbilityCastTimer = null;
				m_caster.Out.SendMessage("You cancel your Spell!", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow);
			}

			m_caster.RealmAbilityCastTimer = new RegionTimer(m_caster);
			m_caster.RealmAbilityCastTimer.Callback = new RegionTimerCallback(EndCast);
			m_caster.RealmAbilityCastTimer.Start(2000);
		}

        /// <summary>
        /// Action
        /// </summary>
        /// <param name="living"></param>
        public override void Execute(GameLiving living)
        {
            if (CheckPreconditions(living, DEAD | SITTING | MEZZED | STUNNED)) return;

            if (living is GamePlayer)
            {
                player = living as GamePlayer;
                if (player.TargetObject == null)
                {
                    player.Out.SendMessage("You need a target for this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                    player.DisableSkill(this, 3 * 1000);
                    return;
                }
                if (!(player.TargetObject is GamePlayer))
                {
                    player.Out.SendMessage("This work only on players!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                    player.DisableSkill(this, 3 * 1000);
                    return;
                }
                if (!GameServer.ServerRules.IsAllowedToAttack(player, (GamePlayer)player.TargetObject, true))
                {
                    player.Out.SendMessage("This work only on enemies!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
                    player.DisableSkill(this, 3 * 1000);
                    return;
                }
                if ( !player.IsWithinRadius( player.TargetObject, SpellRange ) )
                {
                    player.Out.SendMessage(player.TargetObject + " is too far away!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
                    player.DisableSkill(this, 3 * 1000);
                    return;
                }
                foreach (GamePlayer radiusPlayer in player.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
                {
                    if (radiusPlayer == player) radiusPlayer.Out.SendMessage("You cast " + this.Name + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
                    else radiusPlayer.Out.SendMessage(player.Name + " casts a spell!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);

                    radiusPlayer.Out.SendSpellCastAnimation(player, 7059, 0);
                }

                if (player.RealmAbilityCastTimer != null)
                {
                    player.RealmAbilityCastTimer.Stop();
                    player.RealmAbilityCastTimer = null;
                    player.Out.SendMessage("You cancel your Spell!", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow);
                }

                targetPlayer = player.TargetObject as GamePlayer;

                //[StephenxPimentel]
                //1.108 - this ability is now instant cast.
                EndCast();
            }
        }

        public override void Execute(GameLiving living)
        {
            if (CheckPreconditions(living, DEAD | SITTING | MEZZED | STUNNED)) return;
            GamePlayer player = living as GamePlayer;
            if (player.IsMoving)
            {
                player.Out.SendMessage("You must be standing still to use this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }

            if (player.GroundTarget == null || !player.IsWithinRadius(player.GroundTarget, 1500))
            {
                player.Out.SendMessage("You groundtarget is too far away to use this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }
            if (player.TempProperties.getProperty(IS_CASTING, false))
            {
                player.Out.SendMessage("You are already casting an ability.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }
            this.player = player;
            if (player.AttackState)
            {
                player.StopAttack();
            }
            player.StopCurrentSpellcast();
            switch (Level)
            {
                case 1: dmgValue = 120; break;
                case 2: dmgValue = 240; break;
                case 3: dmgValue = 360; break;
                default: return;
            }
            duration = 30;
            foreach (GamePlayer i_player in player.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
            {
                if (i_player == player) i_player.Out.SendMessage("You cast " + this.Name + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
                else i_player.Out.SendMessage(player.Name + " casts a spell!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);

                i_player.Out.SendSpellCastAnimation(player, 7027, 20);
            }
            player.TempProperties.setProperty(IS_CASTING, true);
            player.TempProperties.setProperty(NM_CAST_SUCCESS, true);
            GameEventMgr.AddHandler(player, GamePlayerEvent.Moving, new DOLEventHandler(CastInterrupted));
            GameEventMgr.AddHandler(player, GamePlayerEvent.AttackFinished, new DOLEventHandler(CastInterrupted));
            GameEventMgr.AddHandler(player, GamePlayerEvent.Dying, new DOLEventHandler(CastInterrupted));
            if (player != null)
            {
                new RegionTimer(player, new RegionTimerCallback(EndCast), 2000);
            }
        }

        public override void Execute(GameLiving living)
        {
            if (CheckPreconditions(living, DEAD | SITTING | MEZZED | STUNNED)) return;
            GamePlayer player = living as GamePlayer;
            if (player.TargetObject == null)
            {
                player.Out.SendMessage("You need a target for this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }

            if (!(player.TargetObject is GameLiving)
                || !GameServer.ServerRules.IsAllowedToAttack(player, (GameLiving)player.TargetObject, true))
            {
                player.Out.SendMessage("You cannot attack " + player.TargetObject.Name + "!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }
            if (!player.TargetInView)
            {
                player.Out.SendMessage("You cannot see " + player.TargetObject.Name + "!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }
            if (!player.IsWithinRadius(player.TargetObject, 1500))
            {
                player.Out.SendMessage("You target is too far away to use this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
                return;
            }
            this.player = player;
            switch (Level)
            {
                case 1: duration = 10; break;
                case 2: duration = 15; break;
                case 3: duration = 30; break;
                default: return;
            }
            stunDuration = 3;
            foreach (GamePlayer i_player in player.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
            {
                if (i_player == player) i_player.Out.SendMessage("You cast " + this.Name + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
                else i_player.Out.SendMessage(player.Name + " casts a spell!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
            }
            Statics.StaticTempestBase st = new Statics.StaticTempestBase(stunDuration);
            Point3D targetSpot = new Point3D(player.TargetObject.X, player.TargetObject.Y, player.TargetObject.Z);
            st.CreateStatic(player, targetSpot, duration, 5, 360);
            DisableSkill(living);
        }

        public override void Start(GameLiving target)
        {
            base.Start(target);
            if (target is GamePlayer)
            {
                EffectOwner = target as GamePlayer;
                foreach (GamePlayer p in EffectOwner.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
                {
                    p.Out.SendSpellEffectAnimation(EffectOwner, EffectOwner, 7093, 0, false, 1);
                }
                EffectOwner.BaseBuffBonusCategory[(int)eProperty.ParryChance] += 50;
                EffectOwner.BaseBuffBonusCategory[(int)eProperty.BlockChance] += 50;

                GameEventMgr.AddHandler(EffectOwner, GamePlayerEvent.Quit, new DOLEventHandler(PlayerLeftWorld));
                GameEventMgr.AddHandler(EffectOwner, GamePlayerEvent.Dying, new DOLEventHandler(PlayerLeftWorld));
                GameEventMgr.AddHandler(EffectOwner, GamePlayerEvent.Linkdeath, new DOLEventHandler(PlayerLeftWorld));
                GameEventMgr.AddHandler(EffectOwner, GamePlayerEvent.RegionChanged, new DOLEventHandler(PlayerLeftWorld));
            }
        }

		/// <summary>
		/// Start guarding the player
		/// </summary>
		/// <param name="Caster"></param>
		/// <param name="CasterTarget"></param>
		public void Start(GamePlayer Caster, GamePlayer CasterTarget)
		{
			if (Caster == null || CasterTarget == null)
				return;

			m_playerGroup = Caster.Group;
			if (m_playerGroup != CasterTarget.Group)
				return;

			EffectCaster = Caster;
			EffectOwner = CasterTarget;
			foreach (GamePlayer p in EffectOwner.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
			{
				p.Out.SendSpellEffectAnimation(EffectCaster, EffectOwner, 7090, 0, false, 1);
			}
			GameEventMgr.AddHandler(EffectOwner, GamePlayerEvent.Quit, new DOLEventHandler(PlayerLeftWorld));
			if (m_playerGroup != null)
				GameEventMgr.AddHandler(m_playerGroup, GroupEvent.MemberDisbanded, new DOLEventHandler(GroupDisbandCallback));
			GameEventMgr.AddHandler(EffectOwner, GamePlayerEvent.AttackFinished, new DOLEventHandler(AttackFinished));
			EffectOwner.Out.SendMessage("Your weapon begins channeling the strength of the vampiir!", DOL.GS.PacketHandler.eChatType.CT_Spell, DOL.GS.PacketHandler.eChatLoc.CL_SystemWindow);
			base.Start(CasterTarget);
		}

		public override void OnEffectStart(GameSpellEffect effect)
		{
			effect.Owner.StartInterruptTimer(effect.Owner.SpellInterruptDuration, AttackData.eAttackType.Spell, Caster);
			player = effect.Owner as GamePlayer;
			if (player == null) return;
			int slot=Util.Random(0, 2);
			m_slot = slots[slot];
			string msg = GlobalConstants.SlotToName((int)m_slot);
			MessageToCaster("You debuff " + effect.Owner.Name + "'s " + msg+"", eChatType.CT_Spell);
			foreach (GamePlayer visPlayer in player.GetPlayersInRadius((ushort)WorldMgr.VISIBILITY_DISTANCE))
				visPlayer.Out.SendSpellEffectAnimation(player, player, (ushort)(13180+slot), 0, false, 0x01);

			item = player.Inventory.GetItem((eInventorySlot)m_slot);
			
			if(item!=null)
			{
				old_item_af=item.DPS_AF;
				old_item_abs=item.SPD_ABS;
				item.DPS_AF -= (int)Spell.Value;
				item.SPD_ABS -= (int)Spell.ResurrectMana;
				if(item.DPS_AF<0) item.DPS_AF=0;
				if(item.SPD_ABS<0) item.SPD_ABS=0;
			
				player.Client.Out.SendInventoryItemsUpdate(new InventoryItem[] { item });
				player.Out.SendCharStatsUpdate();
				player.UpdatePlayerStatus();
				player.Out.SendUpdatePlayer();
				player.Out.SendUpdateWeaponAndArmorStats();
				player.Out.SendCharResistsUpdate();
				
				GameEventMgr.AddHandler(player,GamePlayerEvent.Linkdeath, new DOLEventHandler(EventAction));
				GameEventMgr.AddHandler(player,GamePlayerEvent.Quit, new DOLEventHandler(EventAction));
				GameEventMgr.AddHandler(player,GamePlayerEvent.RegionChanged, new DOLEventHandler(EventAction));
				GameEventMgr.AddHandler(player,GameLivingEvent.Dying, new DOLEventHandler(EventAction));
			}

			base.OnEffectStart(effect);
		}

        public override void Start(GameLiving target)
        {
            base.Start(target);

            owner = target as GamePlayer;
            if (owner == null) return;

            foreach (GamePlayer p in owner.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
                p.Out.SendSpellEffectAnimation(owner, owner, Icon, 0, false, 1);

            m_debuffs = new Dictionary<eProperty, int>(1 + eProperty.Stat_Last - eProperty.Stat_First);

            for (eProperty property = eProperty.Stat_First; property <= eProperty.Stat_Last; property++)
            {
                m_debuffs.Add(property, (int)(owner.GetModified(property) * 0.25));
                owner.DebuffCategory[(int)property] += m_debuffs[property];
            }

            owner.Out.SendCharStatsUpdate();

            m_timer = new RegionTimer(owner, new RegionTimerCallback(HealPulse));
            m_timer.Start(1);
        }

		public override void Execute(GameLiving living)
		{
			if (CheckPreconditions(living, DEAD | SITTING | MEZZED | STUNNED)) return;

			caster = living as GamePlayer;
			if (caster == null)
				return;

			if (caster.TargetObject == null)
			{
				caster.Out.SendMessage("You need a target for this ability!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
				caster.DisableSkill(this, 3 * 1000);
				return;
			}

			if (!caster.TargetInView)
			{
				caster.Out.SendMessage(caster.TargetObject.Name + " is not in view.", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow);
				caster.DisableSkill(this, 3 * 1000);
				return;
			}

			if (!caster.IsWithinRadius( caster.TargetObject, 1875 ))
			{
				caster.Out.SendMessage(caster.TargetObject.Name + " is too far away.", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
				caster.DisableSkill(this, 3 * 1000);
				return;
			}

			if (m_expireTimerID != null && m_expireTimerID.IsAlive)
			{
				caster.Out.SendMessage("You are already casting this ability.", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
				caster.DisableSkill(this, 3 * 1000);
				return;
			}

			if(ServerProperties.Properties.USE_NEW_ACTIVES_RAS_SCALING)
			{
				switch (Level)
				{
						case 1: dmgValue = 150; duration = 10000; break;
						case 2: dmgValue = 275; duration = 15000; break;
						case 3: dmgValue = 400; duration = 20000; break;
						case 4: dmgValue = 500; duration = 25000; break;
						case 5: dmgValue = 600; duration = 30000; break;
						default: return;
				}				
			}
				//150 dam/10 sec || 400/20  || 600/30
				switch (Level)
				{
						case 1: dmgValue = 150; duration = 10000; break;
						case 2: dmgValue = 400; duration = 20000; break;
						case 3: dmgValue = 600; duration = 30000; break;
						default: return;
				}

			#region resist and det
			GameLiving m_target = caster.TargetObject as GameLiving;

			int primaryResistModifier = m_target.GetResist(eDamageType.Spirit);
			int secondaryResistModifier = m_target.SpecBuffBonusCategory[(int)eProperty.Resist_Spirit];
			int rootdet = ((m_target.GetModified(eProperty.SpeedDecreaseDurationReduction) - 100) * -1);

			int ResistModifier = 0;
			ResistModifier += (int)((dmgValue * (double)primaryResistModifier) * -0.01);
			ResistModifier += (int)((dmgValue + (double)ResistModifier) * (double)secondaryResistModifier * -0.01);


			if (m_target is GamePlayer)
			{
				dmgValue += ResistModifier;
			}
			if (m_target is GameNPC)
			{
				dmgValue += ResistModifier;
			}
			
			int rootmodifier = 0;
			rootmodifier += (int)((duration * (double)primaryResistModifier) * -0.01);
			rootmodifier += (int)((duration + (double)primaryResistModifier) * (double)secondaryResistModifier * -0.01);
			rootmodifier += (int)((duration + (double)rootmodifier) * (double)rootdet * -0.01);
			
			duration += rootmodifier;

			if (duration < 1)
				duration = 1;
			#endregion


			foreach (GamePlayer i_player in caster.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
			{
				if (i_player == caster)
				{
					i_player.MessageToSelf("You cast " + this.Name + "!", eChatType.CT_Spell);
				}
				else
				{
					i_player.MessageFromArea(caster, caster.Name + " casts a spell!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
				}
//.........这里部分代码省略.........

		/// <summary>
		/// Used to get into a house
		/// </summary>
		/// <param name="player">the player who wants to get in</param>
		public void Enter(GamePlayer player)
		{
			IList<GamePlayer> list = GetAllPlayersInHouse();
			if (list.Count == 0)
			{
				foreach (GamePlayer pl in player.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
				{
					pl.Out.SendHouseOccupied(this, true);
				}
			}

			ChatUtil.SendSystemMessage(player, "House.Enter.EnteringHouse", HouseNumber);
			player.Out.SendEnterHouse(this);
			player.Out.SendFurniture(this);

			player.InHouse = true;
			player.CurrentHouse = this;

			ushort heading = 0;

			switch (Model)
			{
					//thx to sp4m
				default:
					player.MoveTo(RegionID, X, Y, 25022, heading);
					break;

				case 1:
					player.MoveTo(RegionID, X + 80, Y + 100, ((25025)), heading);
					break;

				case 2:
					player.MoveTo(RegionID, X - 260, Y + 100, ((24910)), heading);
					break;

				case 3:
					player.MoveTo(RegionID, X - 200, Y + 100, ((24800)), heading);
					break;

				case 4:
					player.MoveTo(RegionID, X - 350, Y - 30, ((24660)), heading);
					break;

				case 5:
					player.MoveTo(RegionID, X + 230, Y - 480, ((25100)), heading);
					break;

				case 6:
					player.MoveTo(RegionID, X - 80, Y - 660, ((24700)), heading);
					break;

				case 7:
					player.MoveTo(RegionID, X - 80, Y - 660, ((24700)), heading);
					break;

				case 8:
					player.MoveTo(RegionID, X - 90, Y - 625, ((24670)), heading);
					break;

				case 9:
					player.MoveTo(RegionID, X + 400, Y - 160, ((25150)), heading);
					break;

				case 10:
					player.MoveTo(RegionID, X + 400, Y - 80, ((25060)), heading);
					break;

				case 11:
					player.MoveTo(RegionID, X + 400, Y - 60, ((24900)), heading);
					break;

				case 12:
					player.MoveTo(RegionID, X, Y - 620, ((24595)), heading);
					break;
			}

			ChatUtil.SendSystemMessage(player, "House.Enter.EnteredHouse", HouseNumber);
		}

		/// <summary>
		/// Used to leave a house
		/// </summary>
		/// <param name="player">the player who wants to get in</param>
		/// <param name="silent">text or not</param>
		public void Exit(GamePlayer player, bool silent)
		{
			player.MoveTo(OutdoorJumpPoint);

			if (!silent)
			{
				ChatUtil.SendSystemMessage(player, "House.Exit.LeftHouse", HouseNumber);
			}

			player.Out.SendExitHouse(this);

			IList<GamePlayer> list = GetAllPlayersInHouse();
			if (list.Count == 0)
			{
				foreach (GamePlayer pl in player.GetPlayersInRadius(HousingConstants.HouseViewingDistance))
				{
					pl.Out.SendHouseOccupied(this, false);
				}
			}
		}

        public override void Start(GameLiving target)
        {
            base.Start(target);
            if (target is GamePlayer)
            {
                EffectOwner = target as GamePlayer;
                stun = ScriptMgr.CreateSpellHandler(EffectOwner, spiritSpell, spiritSpellLine);

                int targetCount = 0;
                foreach (GamePlayer targetPlayer in EffectOwner.GetPlayersInRadius((ushort)RealmAbilities.MinionRescueAbility.SpellRadius))
                {
                    if (targetCount == spiritCount) return;
                    if (targetPlayer.IsAlive && GameServer.ServerRules.IsAllowedToAttack(EffectOwner, targetPlayer, true))
                    {
                        SummonSpirit(targetCount, targetPlayer);
                        targetCount++;
                    }
                }
            }
        }

		private void CreateHouse(GamePlayer player, int model)
		{
			DatabaseItem.Model = model;
			DatabaseItem.Name = player.Name;

			if (player.Guild != null)
			{
				DatabaseItem.Emblem = player.Guild.Emblem;
			}

			var house = new House(DatabaseItem);
			HouseMgr.AddHouse(house);

			if (model != 0)
			{
				// move all players outside the mesh
				foreach (GamePlayer p in player.GetPlayersInRadius(500))
				{
					house.Exit(p, true);
				}

				RemoveFromWorld();
				Delete();
			}
		}

		// send emote messages to all players in range
		private void SendEmoteMessages(GamePlayer sourcePlayer, GamePlayer targetPlayer, string messageToSource, string messageToTarget, string messageToOthers)
		{
			SendEmoteMessage(sourcePlayer, messageToSource);

			if (targetPlayer != null)
			{
				if (!targetPlayer.IsIgnoring(sourcePlayer))
					SendEmoteMessage(targetPlayer, messageToTarget);
			}

			foreach (GamePlayer player in sourcePlayer.GetPlayersInRadius(EMOTE_RANGE_TO_OTHERS))
				if (player != sourcePlayer && player != targetPlayer && !player.IsIgnoring(sourcePlayer)) // client and target gets unique messages
					SendEmoteMessage(player, messageToOthers);

			return;
		}