#W# Initial Commit: Avatars Conquest

Scripts/Mobiles/Base/AI/AIControlMobileTarget.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using Server;
+using Server.Mobiles;
+using Server.Targeting;
+
+namespace Server.Targets
+{
+	public class AIControlMobileTarget : Target
+	{
+		private List<BaseAI> m_List;
+		private OrderType m_Order;
+
+		public OrderType Order {
+			get {
+				return m_Order;
+			}
+		}
+
+		public AIControlMobileTarget( BaseAI ai, OrderType order ) : base( -1, false, ( order == OrderType.Attack ? TargetFlags.Harmful : TargetFlags.None ) )
+		{
+			m_List = new List<BaseAI>();
+			m_Order = order;
+
+			AddAI( ai );
+		}
+
+		public void AddAI( BaseAI ai )
+		{
+			if ( !m_List.Contains( ai ) )
+				m_List.Add( ai );
+		}
+
+		protected override void OnTarget( Mobile from, object o )
+		{
+			if ( o is Mobile ) {
+				Mobile m = (Mobile)o;
+				for ( int i = 0; i < m_List.Count; ++i )
+					m_List[i].EndPickTarget( from, m, m_Order );
+			}
+		}
+	}
+}

Scripts/Mobiles/Base/AI/AnimalAI.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+// Ideas
+// When you run on animals the panic
+// When if ( distance < 8 && Utility.RandomDouble() * Math.Sqrt( (8 - distance) / 6 ) >= incoming.Skills[SkillName.AnimalTaming].Value )
+// More your close, the more it can panic
+/*
+ * AnimalHunterAI, AnimalHidingAI, AnimalDomesticAI...
+ * 
+ */ 
+
+namespace Server.Mobiles
+{
+	public class AnimalAI : BaseAI
+	{
+		public AnimalAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			// Old:
+#if false
+			if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, true, false, true))
+			{
+				m_Mobile.DebugSay( "There is something near, I go away" );
+				Action = ActionType.Backoff;
+			}
+			else if ( m_Mobile.IsHurt() || m_Mobile.Combatant != null )
+			{
+				m_Mobile.DebugSay( "I am hurt or being attacked, I flee" );						
+				Action = ActionType.Flee;
+			}
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;
+#endif
+
+			// New, only flee @ 10%
+
+			double hitPercent = (double)m_Mobile.Hits / m_Mobile.HitsMax;
+
+			if ( !m_Mobile.Summoned && !m_Mobile.Controlled && hitPercent < 0.1 ) // Less than 10% health
+			{
+				m_Mobile.DebugSay( "I am low on health!" );
+				Action = ActionType.Flee;
+			}
+			else if ( AcquireFocusMob( m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionCombat()
+		{
+			Mobile combatant = m_Mobile.Combatant;
+
+			if ( combatant == null || combatant.Deleted || combatant.Map != m_Mobile.Map )
+			{
+				m_Mobile.DebugSay( "My combatant is gone.." );
+
+				Action = ActionType.Wander;
+
+				return true;
+			}
+
+			if ( WalkMobileRange( combatant, 1, true, m_Mobile.RangeFight, m_Mobile.RangeFight ) )
+			{
+				m_Mobile.Direction = m_Mobile.GetDirectionTo( combatant );
+			}
+			else
+			{
+				if ( m_Mobile.GetDistanceToSqrt( combatant ) > m_Mobile.RangePerception + 1 )
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "I cannot find {0}", combatant.Name );
+
+					Action = ActionType.Wander;
+
+					return true;
+				}
+				else
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "I should be closer to {0}", combatant.Name );
+				}
+			}
+
+			if ( !m_Mobile.Controlled && !m_Mobile.Summoned )
+			{
+				double hitPercent = (double)m_Mobile.Hits / m_Mobile.HitsMax;
+
+				if ( hitPercent < 0.1 )
+				{
+					m_Mobile.DebugSay( "I am low on health!" );
+					Action = ActionType.Flee;
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionBackoff()
+		{
+			double hitPercent = (double)m_Mobile.Hits / m_Mobile.HitsMax;
+
+			if ( !m_Mobile.Summoned && !m_Mobile.Controlled && hitPercent < 0.1 ) // Less than 10% health
+			{
+				Action = ActionType.Flee;
+			}
+			else
+			{
+				if (AcquireFocusMob(m_Mobile.RangePerception * 2, FightMode.Closest, true, false , true))
+				{
+					if ( WalkMobileRange(m_Mobile.FocusMob, 1, false, m_Mobile.RangePerception, m_Mobile.RangePerception * 2) )
+					{
+						m_Mobile.DebugSay( "Well, here I am safe" );
+						Action = ActionType.Wander;
+					}					
+				}
+				else
+				{
+					m_Mobile.DebugSay( "I have lost my focus, lets relax" );
+					Action = ActionType.Wander;
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionFlee()
+		{
+			AcquireFocusMob(m_Mobile.RangePerception * 2, m_Mobile.FightMode, true, false, true);
+
+			if ( m_Mobile.FocusMob == null )
+				m_Mobile.FocusMob = m_Mobile.Combatant;
+
+			return base.DoActionFlee();
+		}
+	}
+}

Scripts/Mobiles/Base/AI/ArcherAI.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+	public class ArcherAI : BaseAI
+	{
+		public ArcherAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			m_Mobile.DebugSay( "I have no combatant" );
+
+			if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected {0} and I will attack", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				return base.DoActionWander();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionCombat()
+		{
+			if ( m_Mobile.Combatant == null || m_Mobile.Combatant.Deleted || !m_Mobile.Combatant.Alive || m_Mobile.Combatant.IsDeadBondedPet )
+			{
+				m_Mobile.DebugSay("My combatant is deleted");
+				Action = ActionType.Guard;
+				return true;
+			}
+
+			if ( (m_Mobile.LastMoveTime + TimeSpan.FromSeconds( 1.0 )) < DateTime.Now )
+			{
+				if (WalkMobileRange(m_Mobile.Combatant, 1, true, m_Mobile.RangeFight, m_Mobile.Weapon.MaxRange))
+				{
+					// Be sure to face the combatant
+					m_Mobile.Direction = m_Mobile.GetDirectionTo(m_Mobile.Combatant.Location);
+				}
+				else
+				{
+					if ( m_Mobile.Combatant != null )
+					{
+						if ( m_Mobile.Debug )
+							m_Mobile.DebugSay( "I am still not in range of {0}", m_Mobile.Combatant.Name);
+
+						if ( (int) m_Mobile.GetDistanceToSqrt( m_Mobile.Combatant ) > m_Mobile.RangePerception + 1 )
+						{
+							if ( m_Mobile.Debug )
+								m_Mobile.DebugSay( "I have lost {0}", m_Mobile.Combatant.Name);
+
+							m_Mobile.Combatant = null;
+							Action = ActionType.Guard;
+							return true;
+						}
+					}
+				}
+			}
+
+			// When we have no ammo, we flee
+			Container pack = m_Mobile.Backpack;
+
+			if ( pack == null || pack.FindItemByType( typeof( Arrow ) ) == null )
+			{
+				Action = ActionType.Flee;
+				return true;
+			}
+
+			
+			// At 20% we should check if we must leave
+			if ( m_Mobile.Hits < m_Mobile.HitsMax*20/100 )
+			{
+				bool bFlee = false;
+				// if my current hits are more than my opponent, i don't care
+				if ( m_Mobile.Combatant != null && m_Mobile.Hits < m_Mobile.Combatant.Hits)
+				{
+					int iDiff = m_Mobile.Combatant.Hits - m_Mobile.Hits;
+
+					if ( Utility.Random(0, 100) > 10 + iDiff) // 10% to flee + the diff of hits
+					{
+						bFlee = true;
+					}
+				}
+				else if ( m_Mobile.Combatant != null && m_Mobile.Hits >= m_Mobile.Combatant.Hits)
+				{
+					if ( Utility.Random(0, 100) > 10 ) // 10% to flee
+					{
+						bFlee = true;
+					}
+				}
+						
+				if (bFlee)
+				{
+					Action = ActionType.Flee; 
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionGuard()
+		{
+			if ( AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionGuard();
+			}
+
+			return true;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/BerserkAI.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+	public class BerserkAI : BaseAI
+	{
+		public BerserkAI(BaseCreature m) : base (m)
+		{
+		}
+	
+		public override bool DoActionWander()
+		{
+			m_Mobile.DebugSay( "I have No Combatant" );
+			
+			if( AcquireFocusMob( m_Mobile.RangePerception, FightMode.Closest, false, true, true) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected " + m_Mobile.FocusMob.Name + " and I will attack" );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}			
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;			
+		}
+			
+		public override bool DoActionCombat()
+		{
+			if( m_Mobile.Combatant == null || m_Mobile.Combatant.Deleted )
+			{
+				m_Mobile.DebugSay("My combatant is deleted");
+				Action = ActionType.Guard;
+				return true;
+			}
+
+			if( WalkMobileRange( m_Mobile.Combatant, 1, true, m_Mobile.RangeFight, m_Mobile.RangeFight ) )
+			{
+				// Be sure to face the combatant
+				m_Mobile.Direction = m_Mobile.GetDirectionTo( m_Mobile.Combatant.Location );
+			}
+			else
+			{
+				if( m_Mobile.Combatant != null )
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay("I am still not in range of " + m_Mobile.Combatant.Name);
+
+					if( (int) m_Mobile.GetDistanceToSqrt( m_Mobile.Combatant ) > m_Mobile.RangePerception + 1 )
+					{
+						if ( m_Mobile.Debug )
+							m_Mobile.DebugSay( "I have lost " + m_Mobile.Combatant.Name );
+
+						Action = ActionType.Guard;
+						return true;
+					}
+				}
+			}
+			
+			return true;
+		}
+		
+		public override bool DoActionGuard()
+		{
+			if ( AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, true, true ) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionGuard();
+			}
+
+			return true;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/CitizenAI.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+	public class CitizenAI : BaseAI
+	{
+		public CitizenAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			return false;
+		}
+
+		public override bool DoActionCombat()
+		{
+			return false;
+		}
+
+		public override bool DoActionBackoff()
+		{
+			return false;
+		}
+
+		public override bool DoActionFlee()
+		{
+			return false;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/HealerAI.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Spells;
+using Server.Spells.First;
+using Server.Spells.Second;
+using Server.Spells.Fourth;
+
+namespace Server.Mobiles
+{
+	public class HealerAI : BaseAI
+	{
+		private static NeedDelegate m_Cure = new NeedDelegate( NeedCure );
+		private static NeedDelegate m_GHeal = new NeedDelegate( NeedGHeal );
+		private static NeedDelegate m_LHeal = new NeedDelegate( NeedLHeal );
+		private static NeedDelegate[] m_ACure = new NeedDelegate[] { m_Cure };
+		private static NeedDelegate[] m_AGHeal = new NeedDelegate[] { m_GHeal };
+		private static NeedDelegate[] m_ALHeal = new NeedDelegate[] { m_LHeal };
+		private static NeedDelegate[] m_All = new NeedDelegate[] { m_Cure, m_GHeal, m_LHeal };
+
+		public HealerAI( BaseCreature m ) : base( m )
+		{
+		}
+
+		public override bool Think()
+		{
+			if ( m_Mobile.Deleted )
+				return false;
+
+			Target targ = m_Mobile.Target;
+
+			if ( targ != null )
+			{
+				if ( targ is CureSpell.InternalTarget )
+				{
+					ProcessTarget( targ, m_ACure );
+				}
+				else if ( targ is GreaterHealSpell.InternalTarget )
+				{
+					ProcessTarget( targ, m_AGHeal );
+				}
+				else if ( targ is HealSpell.InternalTarget )
+				{
+					ProcessTarget( targ, m_ALHeal );
+				}
+				else
+				{
+					targ.Cancel( m_Mobile, TargetCancelType.Canceled );
+				}
+			}
+			else
+			{
+				Mobile toHelp = Find( m_All );
+
+				if ( toHelp != null )
+				{
+					if ( NeedCure( toHelp ) )
+					{
+						if ( m_Mobile.Debug )
+							m_Mobile.DebugSay( "{0} needs a cure", toHelp.Name );
+
+						if ( !(new CureSpell( m_Mobile, null )).Cast() )
+							new CureSpell( m_Mobile, null ).Cast();
+					}
+					else if ( NeedGHeal( toHelp ) )
+					{
+						if ( m_Mobile.Debug )
+							m_Mobile.DebugSay( "{0} needs a greater heal", toHelp.Name );
+
+						if ( !(new GreaterHealSpell( m_Mobile, null )).Cast() )
+							new HealSpell( m_Mobile, null ).Cast();
+					}
+					else if ( NeedLHeal( toHelp ) )
+					{
+						if ( m_Mobile.Debug )
+							m_Mobile.DebugSay( "{0} needs a lesser heal", toHelp.Name );
+
+						new HealSpell( m_Mobile, null ).Cast();
+					}
+				}
+				else
+				{
+					if ( AcquireFocusMob( m_Mobile.RangePerception, FightMode.Weakest, false, true, false ) )
+					{
+						WalkMobileRange( m_Mobile.FocusMob, 1, false, 4, 7 );
+					}
+					else
+					{
+						WalkRandomInHome( 3, 2, 1 );
+					}
+				}
+			}
+
+			return true;
+		}
+
+		private delegate bool NeedDelegate( Mobile m );
+
+		private void ProcessTarget( Target targ, NeedDelegate[] func )
+		{
+			Mobile toHelp = Find( func );
+
+			if ( toHelp != null )
+			{
+				if ( targ.Range != -1 && !m_Mobile.InRange( toHelp, targ.Range ) )
+				{
+					DoMove( m_Mobile.GetDirectionTo( toHelp ) | Direction.Running );
+				}
+				else
+				{
+					targ.Invoke( m_Mobile, toHelp );
+				}
+			}
+			else
+			{
+				targ.Cancel( m_Mobile, TargetCancelType.Canceled );
+			}
+		}
+
+		private Mobile Find( params NeedDelegate[] funcs )
+		{
+			if ( m_Mobile.Deleted )
+				return null;
+
+			Map map = m_Mobile.Map;
+
+			if ( map != null )
+			{
+				double prio = 0.0;
+				Mobile found = null;
+
+				foreach ( Mobile m in m_Mobile.GetMobilesInRange( m_Mobile.RangePerception ) )
+				{
+					if ( !m_Mobile.CanSee( m ) || !(m is BaseCreature) || ((BaseCreature)m).Team != m_Mobile.Team )
+						continue;
+
+					for ( int i = 0; i < funcs.Length; ++i )
+					{
+						if ( funcs[i]( m ) )
+						{
+							double val = -m_Mobile.GetDistanceToSqrt( m );
+
+							if ( found == null || val > prio )
+							{
+								prio = val;
+								found = m;
+							}
+
+							break;
+						}
+					}
+				}
+
+				return found;
+			}
+
+			return null;
+		}
+
+		private static bool NeedCure( Mobile m )
+		{
+			return m.Poisoned;
+		}
+
+		private static bool NeedGHeal( Mobile m )
+		{
+			return m.Hits < m.HitsMax - 40;
+		}
+
+		private static bool NeedLHeal( Mobile m )
+		{
+			return m.Hits < m.HitsMax - 10;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/MeleeAI.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+//
+// This is a first simple AI
+//
+//
+
+namespace Server.Mobiles
+{
+	public class MeleeAI : BaseAI
+	{
+		public MeleeAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			m_Mobile.DebugSay( "I have no combatant" );
+
+			if ( AcquireFocusMob( m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionCombat()
+		{
+			Mobile combatant = m_Mobile.Combatant;
+
+			if ( combatant == null || combatant.Deleted || combatant.Map != m_Mobile.Map || !combatant.Alive || combatant.IsDeadBondedPet )
+			{
+				m_Mobile.DebugSay( "My combatant is gone, so my guard is up" );
+
+				Action = ActionType.Guard;
+
+				return true;
+			}
+
+			if ( !m_Mobile.InRange( combatant, m_Mobile.RangePerception ) )
+			{
+				// They are somewhat far away, can we find something else?
+
+				if ( AcquireFocusMob( m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+				{
+					m_Mobile.Combatant = m_Mobile.FocusMob;
+					m_Mobile.FocusMob = null;
+				}
+				else if ( !m_Mobile.InRange( combatant, m_Mobile.RangePerception * 3 ) )
+				{
+					m_Mobile.Combatant = null;
+				}
+
+				combatant = m_Mobile.Combatant;
+
+				if ( combatant == null )
+				{
+					m_Mobile.DebugSay( "My combatant has fled, so I am on guard" );
+					Action = ActionType.Guard;
+
+					return true;
+				}
+			}
+
+			/*if ( !m_Mobile.InLOS( combatant ) )
+			{
+				if ( AcquireFocusMob( m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+				{
+					m_Mobile.Combatant = combatant = m_Mobile.FocusMob;
+					m_Mobile.FocusMob = null;
+				}
+			}*/
+
+			if ( MoveTo( combatant, true, m_Mobile.RangeFight ) )
+			{
+				m_Mobile.Direction = m_Mobile.GetDirectionTo( combatant );
+			}
+			else if ( AcquireFocusMob( m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "My move is blocked, so I am going to attack {0}", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+
+				return true;
+			}
+			else if ( m_Mobile.GetDistanceToSqrt( combatant ) > m_Mobile.RangePerception + 1 )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I cannot find {0}, so my guard is up", combatant.Name );
+
+				Action = ActionType.Guard;
+
+				return true;
+			}
+			else
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I should be closer to {0}", combatant.Name );
+			}
+
+			if ( !m_Mobile.Controlled && !m_Mobile.Summoned )
+			{
+				if ( m_Mobile.Hits < m_Mobile.HitsMax * 20/100 )
+				{
+					// We are low on health, should we flee?
+
+					bool flee = false;
+
+					if ( m_Mobile.Hits < combatant.Hits )
+					{
+						// We are more hurt than them
+
+						int diff = combatant.Hits - m_Mobile.Hits;
+
+						flee = ( Utility.Random( 0, 100 ) < (10 + diff) ); // (10 + diff)% chance to flee
+					}
+					else
+					{
+						flee = Utility.Random( 0, 100 ) < 10; // 10% chance to flee
+					}
+
+					if ( flee )
+					{
+						if ( m_Mobile.Debug )
+							m_Mobile.DebugSay( "I am going to flee from {0}", combatant.Name );
+
+						Action = ActionType.Flee;
+					}
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionGuard()
+		{
+			if ( AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionGuard();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionFlee()
+		{
+			if ( m_Mobile.Hits > m_Mobile.HitsMax/2 )
+			{
+				m_Mobile.DebugSay( "I am stronger now, so I will continue fighting" );
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				m_Mobile.FocusMob = m_Mobile.Combatant;
+				base.DoActionFlee();
+			}
+
+			return true;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/PredatorAI.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+
+/*
+ * PredatorAI, its an animal that can attack
+ *	Dont flee but dont attack if not hurt or attacked
+ * 
+ */ 
+
+namespace Server.Mobiles
+{
+	public class PredatorAI : BaseAI
+	{
+		public PredatorAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			if ( m_Mobile.Combatant != null )
+			{
+				m_Mobile.DebugSay( "I am hurt or being attacked, I kill him" );						
+				Action = ActionType.Combat;
+			}
+			else if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, true, false, true))
+			{
+				m_Mobile.DebugSay( "There is something near, I go away" );
+				Action = ActionType.Backoff;
+			}
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionCombat()
+		{
+			Mobile combatant = m_Mobile.Combatant;
+
+			if ( combatant == null || combatant.Deleted || combatant.Map != m_Mobile.Map )
+			{
+				m_Mobile.DebugSay( "My combatant is gone, so my guard is up" );
+				Action = ActionType.Wander;
+				return true;
+			}
+
+			if ( WalkMobileRange( combatant, 1, true, m_Mobile.RangeFight, m_Mobile.RangeFight ) )
+			{
+				m_Mobile.Direction = m_Mobile.GetDirectionTo( combatant );
+			}
+			else
+			{
+				if ( m_Mobile.GetDistanceToSqrt( combatant ) > m_Mobile.RangePerception + 1 )
+				{
+					m_Mobile.DebugSay( "I cannot find {0}", combatant.Name );
+
+					Action = ActionType.Wander;
+					return true;
+				}
+				else
+				{
+					m_Mobile.DebugSay( "I should be closer to {0}", combatant.Name );
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionBackoff()
+		{
+			if ( m_Mobile.IsHurt() || m_Mobile.Combatant != null )
+			{
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				if (AcquireFocusMob(m_Mobile.RangePerception * 2, FightMode.Closest, true, false , true))
+				{
+					if ( WalkMobileRange(m_Mobile.FocusMob, 1, false, m_Mobile.RangePerception, m_Mobile.RangePerception * 2) )
+					{
+						m_Mobile.DebugSay( "Well, here I am safe" );
+						Action = ActionType.Wander;
+					}					
+				}
+				else
+				{
+					m_Mobile.DebugSay( "I have lost my focus, lets relax" );
+					Action = ActionType.Wander;
+				}
+			}
+
+			return true;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/SpeedInfo.cs

@@ -0,0 +1,458 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Mobiles;
+
+namespace Server
+{
+	public class SpeedInfo
+	{
+		// Should we use the new method of speeds?
+		private static bool Enabled = true;
+
+		private double m_ActiveSpeed;
+		private double m_PassiveSpeed;
+		private Type[] m_Types;
+
+		public double ActiveSpeed
+		{
+			get{ return m_ActiveSpeed; }
+			set{ m_ActiveSpeed = value; }
+		}
+
+		public double PassiveSpeed
+		{
+			get{ return m_PassiveSpeed; }
+			set{ m_PassiveSpeed = value; }
+		}
+
+		public Type[] Types
+		{
+			get{ return m_Types; }
+			set{ m_Types = value; }
+		}
+
+		public SpeedInfo( double activeSpeed, double passiveSpeed, Type[] types )
+		{
+			m_ActiveSpeed = activeSpeed;
+			m_PassiveSpeed = passiveSpeed;
+			m_Types = types;
+		}
+
+		public static bool Contains( object obj )
+		{
+			if ( !Enabled )
+				return false;
+
+			if ( m_Table == null )
+				LoadTable();
+
+			SpeedInfo sp = (SpeedInfo)m_Table[obj.GetType()];
+
+			return ( sp != null );
+		}
+
+		public static bool GetSpeeds( object obj, ref double activeSpeed, ref double passiveSpeed )
+		{
+			if ( !Enabled )
+				return false;
+
+			if ( m_Table == null )
+				LoadTable();
+
+			SpeedInfo sp = (SpeedInfo)m_Table[obj.GetType()];
+
+			if ( sp == null )
+				return false;
+
+			activeSpeed = sp.ActiveSpeed;
+			passiveSpeed = sp.PassiveSpeed;
+
+			return true;
+		}
+
+		private static void LoadTable()
+		{
+			m_Table = new Hashtable();
+
+			for ( int i = 0; i < m_Speeds.Length; ++i )
+			{
+				SpeedInfo info = m_Speeds[i];
+				Type[] types = info.Types;
+
+				for ( int j = 0; j < types.Length; ++j )
+					m_Table[types[j]] = info;
+			}
+		}
+
+		private static Hashtable m_Table;
+
+		private static SpeedInfo[] m_Speeds = new SpeedInfo[]
+			{
+				/* Slow */
+				new SpeedInfo( 0.3, 0.6, new Type[]
+				{
+				typeof( RottingDrake ), 
+				typeof( ZombieDragon ),
+				typeof( CarcassWorm ),
+				typeof( Meglasaur ),
+				typeof( Gorceratops ),
+				typeof( Stegosaurus ),
+				typeof( Turtle ),
+				typeof( Shambler ),
+				typeof( ShamblingMound ),
+				typeof( AntLion ),			
+				typeof( ArcticOgreLord ),	
+				typeof( BoneKnight ),		
+				typeof( EarthElemental ),
+				typeof( MeteorElemental ),
+				typeof( StoneGolem ),
+				typeof( StoneStatue ),
+				typeof( Goliath ),
+				typeof( MudElemental ),
+				typeof( MagmaElemental ),
+				typeof( WoodElemental ),
+				typeof( Ettin ),			
+				typeof( SnowEttin ),		
+				typeof( SwampThing ),		
+				typeof( FrostOoze ),		
+				typeof( FrostTroll ),
+				typeof( Ghoul ),
+				typeof( Wight ),
+				typeof( Golem ),
+				typeof( HeadlessOne ),		
+				typeof( Mummy ),
+				typeof( Ogre ),		
+				typeof( Owlbear ),
+				typeof( Sasquatch ),
+				typeof( CorpseGolem ),	
+				typeof( FleshGolem ),		
+				typeof( FleshGoliath ),		
+				typeof( Caveman ),			
+				typeof( OgreLord ),		
+				typeof( ForestGiant ),	
+				typeof( HillGiant ),	
+				typeof( MountainGiant ),	
+				typeof( FrostGiant ),	
+				typeof( Xorn ),			
+				typeof( Rat ),				
+				typeof( RottingCorpse ),
+				typeof( Skeleton ),			
+				typeof( Slime ),
+				typeof( Sludge ),
+				typeof( LargeSlime ),
+				typeof( Zombie ),	
+				typeof( ZombieGargoyle ),	
+				typeof( GargoyleUndead ),			
+				typeof( Walrus )
+				} ),
+				/* Fast */
+				new SpeedInfo( 0.2, 0.4, new Type[]
+				{
+				typeof( BoneClaw ),
+				typeof( ShadowDemon ),
+				typeof( Torax ),
+				typeof( Teradactyl ),
+				typeof( AirElemental ),
+				typeof( Typhoon ),
+				typeof( AncientWyrm ),		
+				typeof( Balron ),
+				typeof( SeaDevil ),
+				typeof( DemonClaw ),
+				typeof( BladeSpirits ),
+				typeof( DreadSpider ),		
+				typeof( Efreet ),
+				typeof( Lich ),
+				typeof( Vampire ),
+				typeof( Nightmare ),
+				typeof( Cerberus ),
+				typeof( Serperus ),
+				typeof( Haderus ),
+				typeof( OphidianArchmage ),
+				typeof( OphidianMage ),		
+				typeof( OphidianWarrior ),	
+				typeof( OphidianMatriarch ),
+				typeof( OphidianKnight ),
+				typeof( Naga ),
+				typeof( NagaWarrior ),
+				typeof( NagaQueen ),
+				typeof( FireNaga ),
+				typeof( Kobra ),
+				typeof( Medusa ), 
+				typeof( PoisonElemental ),
+				typeof( GasCloud ),
+				typeof( StormCloud ),
+				typeof( IceSalamander ),
+				typeof( FireSalamander ),
+				typeof( Raptor ),
+				typeof( SandVortex ),		
+				typeof( SavageShaman ),
+				typeof( SnowElemental ),	
+				typeof( SuccubusQueen ),
+				typeof( WhiteWyrm ),		
+				typeof( Wisp ),		
+				typeof( WidowQueen ),	
+				typeof( Kith ),		
+				typeof( BloodSpider ),	
+				typeof( GiantBlackWidow )
+				} ),
+				/* Very Fast */
+				new SpeedInfo( 0.175, 0.350, new Type[]
+				{
+				typeof( EnergyVortex ),
+				typeof( Pixie ),
+				typeof( Fairy ),
+				typeof( Swarm ),		
+				typeof( SilverSerpent ),
+				typeof( Leviathan ),		
+				} ),
+				/* Medium */
+				new SpeedInfo( 0.25, 0.5, new Type[]
+				{
+				typeof( Demoness ),
+				typeof( Hydra ),
+				typeof( SeaHydra ),
+				typeof( Goblin ),
+				typeof( GoblinArcher ),
+				typeof( GoblinWarrior ),
+				typeof( MummyLord ),
+				typeof( GiantCrab ),
+				typeof( Lobstran ),
+				typeof( Lurker ),
+				typeof( ForestStalker ),
+				typeof( CaveDweller ),
+				typeof( Minotaur ),
+				typeof( MinotaurLord ),
+				typeof( MinotaurChief ),
+				typeof( Ent ),	
+				typeof( Fungal ),	
+				typeof( FungalMage ),	
+				typeof( Sphinx ),
+				typeof( RoyalSphinx ),
+				typeof( AncientSphinx ),
+				typeof( AcidElemental ),	
+				typeof( Alligator ),
+				typeof( AncientLich ),
+				typeof( AncientVampire ),
+				typeof( Bird ),
+				typeof( BlackBear ),		
+				typeof( BloodElemental ),	
+				typeof( BloodElementalElder ),	
+				typeof( PoisonElementalElder ),	
+				typeof( WaterElementalElder ),	
+				typeof( Boar ),				
+				typeof( BoneMagi ),
+				typeof( Brigand ),
+				typeof( BlackKnight ),
+				typeof( BrownBear ),
+				typeof( Bull ),
+				typeof( BullFrog ),
+				typeof( Cat ),				
+				typeof( Centaur ),			
+				typeof( Chicken ),			
+				typeof( Cougar ),			
+				typeof( Cow ),
+				typeof( Cyclops ),
+				typeof( CyclopsChief ),
+				typeof( CyclopsLord ),
+				typeof( Daemon ),
+				typeof( Ktulu ),
+				typeof( Deviless ),
+				typeof( HornedDevil ),
+				typeof( IceDevil ),
+				typeof( DeepSeaSerpent ),
+				typeof( GiantEel ),
+				typeof( GiantSquid ),
+				typeof( DemonicSpirit ),
+				typeof( DireWolf ),			
+				typeof( Dog ),
+				typeof( Dolphin ),		
+				typeof( GreatWhite ),		
+				typeof( Lochasaur ),		
+				typeof( Megalodon ),		
+				typeof( Shark ),	
+				typeof( Seahorse ),
+				typeof( Tyranasaur ),
+				typeof( SeaDragon ),
+				typeof( Dragon ),
+				typeof( Drakkhen ),
+				typeof( DragonTurtle ),			
+				typeof( Drake ),
+				typeof( LavaDrake ),
+				typeof( SeaDrake ),
+				typeof( SwampDragon ),
+				typeof( Dwarf ),
+				typeof( DwarfWarrior ),
+				typeof( DwarfKnight ),
+				typeof( Eagle ),			
+				typeof( ElderGazer ),	
+				typeof( AncientGazer ),
+				typeof( EvilMage ),
+				typeof( EvilMageLord ),
+				typeof( MindFlayer ),
+				typeof( Executioner ),
+				typeof( Savage ),
+				typeof( SavageLeader ),
+				typeof( FireElemental ),	
+				typeof( LightningElemental ),
+				typeof( FireGargoyle ),
+				typeof( FrostSpider ),
+				typeof( Shaclaw ),
+				typeof( Gargoyle ),
+				typeof( GargoyleMage ),
+				typeof( GargoyleKnight ),
+				typeof( GargoyleIce ),
+				typeof( GargoyleStone ),
+				typeof( GargoyleWizard ),
+				typeof( GargoyleCrimson ),
+				typeof( Gazer ),
+				typeof( IceSerpent ),		
+				typeof( GiantRat ),			
+				typeof( GiantSerpent ),	
+				typeof( Viper ),	
+				typeof( Cobra ),
+				typeof( GiantSpider ),
+				typeof( GiantToad ),
+				typeof( IceToad ),
+				typeof( FireToad ),
+				typeof( Goat ),
+				typeof( Gorilla ),	
+				typeof( Ape ),			
+				typeof( GreatDeer ),
+				typeof( GreyWolf ),			
+				typeof( GrizzlyBear ),		
+				typeof( CaveBear ),	
+				typeof( KodiakBear ),	
+				typeof( Lion ),
+				typeof( Tiger ),
+				typeof( Manticore ),	
+				typeof( SnowBear ),	
+				typeof( PandaBear ),	
+				typeof( Harpy ),
+				typeof( ElderHarpy ),
+				typeof( GiantHawk ),
+				typeof( GiantRaven ),
+				typeof( Roc ),
+				typeof( AxeBeak ),
+				typeof( Griffon ),		
+				typeof( Hippogriff ),			
+				typeof( HellHound ),
+				typeof( Deer ),
+				typeof( Hobgoblin ),
+				typeof( HobgoblinChief ),
+				typeof( HobgoblinArcher ),
+				typeof( HobgoblinShaman ),
+				typeof( Horse ),
+				typeof( IceElemental ),		
+				typeof( IceFiend ),
+				typeof( Imp ),
+				typeof( FireImp ), 
+				typeof( IceImp ), 				
+				typeof( Kraken ),			
+				typeof( HellCat ),
+				typeof( LavaLizard ),
+				typeof( GiantLizard ),
+				typeof( LavaSerpent ),		
+				typeof( Lizardman ),
+				typeof( Drasolisk ),
+				typeof( Silisk ),
+				typeof( Sakkhra ),
+				typeof( SakkhraShaman ),
+				typeof( Sahuagin ),
+				typeof( SahuaginMage ),
+				typeof( Llama ),			
+				typeof( Mongbat ),
+				typeof( MountainGoat ),
+				typeof( Dagon ), 
+				typeof( Krakoa ), 
+				typeof( OgreMagi ),
+				typeof( Minion ),
+				typeof( MinionWizard ),
+				typeof( MinionWarrior ),
+				typeof( Orc ),
+				typeof( OrcCaptain ),
+				typeof( OrcishLord ),
+				typeof( OrcishMage ),
+				typeof( PackHorse ),
+				typeof( PackLlama ),
+				typeof( Pirate ),
+				typeof( Panther ),			
+				typeof( Pig ),
+				typeof( PolarBear ),		
+				typeof( Rabbit ),	
+				typeof( Raccoon ),	
+				typeof( Squirrel ),
+				typeof( Ratman ),
+				typeof( RatmanArcher ),
+				typeof( RatmanMage ),		
+				typeof( Satyr ),
+				typeof( FlameCrawler ),
+				typeof( Scorpion ),
+				typeof( Mantis ),
+				typeof( SandScorpion ),		
+				typeof( DeadlyScorpion ),			
+				typeof( SeaSerpent ),
+				typeof( Shade ),			
+				typeof( ShadowWyrm ),		
+				typeof( Sheep ),
+				typeof( BoneDrake ),	
+				typeof( SkeletalDragon ),	
+				typeof( VampiricDragon ),	
+				typeof( VampiricDrake ),	
+				typeof( SkeletalMage ),
+				typeof( SkeletonArcher ),	
+				typeof( Snake ),
+				typeof( SnowLeopard ),		
+				typeof( Spectre ),
+				typeof( StoneGargoyle ),	
+				typeof( StoneHarpy ),
+				typeof( StormGiant ),
+				typeof( ShadowTitan ),
+				typeof( SandGiant ),
+				typeof( JungleGiant ),
+				typeof( Succubus ),
+				typeof( SwampTentacle ),	
+				typeof( AntaurWorker ), 
+				typeof( AntaurSoldier ), 
+				typeof( AntaurLord ), 
+				typeof( AntaurQueen ), 
+				typeof( TerathanAvenger ),
+				typeof( TerathanDrone ),	
+				typeof( TerathanMatriarch ), 
+				typeof( TerathanWarrior ),
+				typeof( TimberWolf ),
+				typeof( Titan ),
+				typeof( Troll ),
+				typeof( Yeti ),
+				typeof( Bugbear ),
+				typeof( Unicorn ),
+				typeof( DreadHorn ),
+				typeof( WaterElemental ),
+				typeof( DeepSeaElemental ),
+				typeof( WhippingVine ),
+				typeof( WhiteWolf ),		
+				typeof( Wraith ),			
+				typeof( AncientWyvern ),	
+				typeof( Wyvern ),
+				typeof( Pharaoh ),
+				typeof( LichLord ),
+				typeof( Nazghoul ), 
+				typeof( Demilich ), 
+				typeof( VampireLord ),
+				typeof( SkeletalKnight ),		
+				typeof( Bat ),		
+				typeof( VampireBat ),	
+				typeof( CaveBat ),		
+				typeof( Stirge ),
+				typeof( ArcaneScarab ),
+				typeof( Werewolf ),		
+				typeof( Scarab ),		
+				typeof( GoraxHorned ),	
+				typeof( GoraxSlicer ),	
+				typeof( GiantScarab ),
+				typeof( IronBeetle ),
+				typeof( Beetle )
+				} )
+			};
+	}
+}

Scripts/Mobiles/Base/AI/ThiefAI.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Items;
+
+//
+// This is a first simple AI
+//
+//
+
+namespace Server.Mobiles
+{
+	public class ThiefAI : BaseAI
+	{
+		public ThiefAI(BaseCreature m) : base (m)
+		{
+		}
+
+		private Item m_toDisarm;
+		public override bool DoActionWander()
+		{
+			m_Mobile.DebugSay( "I have no combatant" );
+
+			if ( AcquireFocusMob( m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionCombat()
+		{
+			Mobile combatant = m_Mobile.Combatant;
+
+			if ( combatant == null || combatant.Deleted || combatant.Map != m_Mobile.Map )
+			{
+				m_Mobile.DebugSay( "My combatant is gone, so my guard is up" );
+
+				Action = ActionType.Guard;
+
+				return true;
+			}
+
+			if ( WalkMobileRange( combatant, 1, true, m_Mobile.RangeFight, m_Mobile.RangeFight ) )
+			{
+				m_Mobile.Direction = m_Mobile.GetDirectionTo( combatant );
+				if ( m_toDisarm == null )
+					m_toDisarm = combatant.FindItemOnLayer( Layer.OneHanded );
+
+				if ( m_toDisarm == null )
+					m_toDisarm = combatant.FindItemOnLayer( Layer.TwoHanded );
+
+				if ( m_toDisarm != null && m_toDisarm.IsChildOf( m_Mobile.Backpack ) )
+				{
+					m_toDisarm = combatant.FindItemOnLayer( Layer.OneHanded );
+					if ( m_toDisarm == null )
+						m_toDisarm = combatant.FindItemOnLayer( Layer.TwoHanded );
+				}
+				if ( !m_Mobile.DisarmReady && m_Mobile.Skills[SkillName.HandToHand].Value >= 80.0 && m_Mobile.Skills[SkillName.Tactics].Value >= 80.0 && m_toDisarm != null )
+					EventSink.InvokeDisarmRequest( new DisarmRequestEventArgs( m_Mobile ) );
+
+				if ( m_toDisarm != null && m_toDisarm.IsChildOf( combatant.Backpack ) && m_Mobile.NextSkillTime <= DateTime.Now && (m_toDisarm.LootType != LootType.Blessed ) )
+				{
+					m_Mobile.DebugSay( "Trying to steal from combatant." );
+					m_Mobile.UseSkill( SkillName.Stealing );
+					if ( m_Mobile.Target != null )
+						m_Mobile.Target.Invoke( m_Mobile, m_toDisarm );
+				}
+				else if ( m_toDisarm == null && m_Mobile.NextSkillTime <= DateTime.Now )
+				{
+					Container cpack = combatant.Backpack;
+
+					if ( cpack != null )
+					{
+						Item steala = cpack.FindItemByType( typeof ( Bandage ) );
+						if ( steala != null ) 
+						{
+							m_Mobile.DebugSay( "Trying to steal from combatant." );
+							m_Mobile.UseSkill( SkillName.Stealing );
+							if ( m_Mobile.Target != null )
+								m_Mobile.Target.Invoke( m_Mobile, steala );
+						}
+						Item stealb = cpack.FindItemByType( typeof ( Nightshade ) );
+						if ( stealb != null ) 
+						{
+							m_Mobile.DebugSay( "Trying to steal from combatant." );
+							m_Mobile.UseSkill( SkillName.Stealing );
+							if ( m_Mobile.Target != null )
+								m_Mobile.Target.Invoke( m_Mobile, stealb );
+						}
+						Item stealc = cpack.FindItemByType( typeof ( BlackPearl ) );
+						if ( stealc != null ) 
+						{
+							m_Mobile.DebugSay( "Trying to steal from combatant." );
+							m_Mobile.UseSkill( SkillName.Stealing );
+							if ( m_Mobile.Target != null )
+								m_Mobile.Target.Invoke( m_Mobile, stealc );
+						}
+
+						Item steald = cpack.FindItemByType( typeof ( MandrakeRoot ) );
+						if ( steald != null ) 
+						{
+							m_Mobile.DebugSay( "Trying to steal from combatant." );
+							m_Mobile.UseSkill( SkillName.Stealing );
+							if ( m_Mobile.Target != null )
+								m_Mobile.Target.Invoke( m_Mobile, steald );
+						}
+						else if ( steala == null && stealb == null && stealc == null && steald == null )
+						{
+							m_Mobile.DebugSay( "I am going to flee from {0}", combatant.Name );
+
+							Action = ActionType.Flee;
+						}
+					}
+				}
+			}
+			else
+			{
+				m_Mobile.DebugSay( "I should be closer to {0}", combatant.Name );
+			}
+
+			if ( m_Mobile.Hits < m_Mobile.HitsMax * 20/100 )
+			{
+				// We are low on health, should we flee?
+
+				bool flee = false;
+
+				if ( m_Mobile.Hits < combatant.Hits )
+				{
+					// We are more hurt than them
+
+					int diff = combatant.Hits - m_Mobile.Hits;
+
+					flee = ( Utility.Random( 0, 100 ) > (10 + diff) ); // (10 + diff)% chance to flee
+				}
+				else
+				{
+					flee = Utility.Random( 0, 100 ) > 10; // 10% chance to flee
+				}
+
+				if ( flee )
+				{
+					m_Mobile.DebugSay( "I am going to flee from {0}", combatant.Name );
+
+					Action = ActionType.Flee;
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionGuard()
+		{
+			if ( AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true ) )
+			{
+				m_Mobile.DebugSay( "I have detected {0}, attacking", m_Mobile.FocusMob.Name );
+
+				m_Mobile.Combatant = m_Mobile.FocusMob;
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				base.DoActionGuard();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionFlee()
+		{
+			if ( m_Mobile.Hits > m_Mobile.HitsMax/2 )
+			{
+				m_Mobile.DebugSay( "I am stronger now, so I will continue fighting" );
+				Action = ActionType.Combat;
+			}
+			else
+			{
+				m_Mobile.FocusMob = m_Mobile.Combatant;
+				base.DoActionFlee();
+			}
+
+			return true;
+		}
+	}
+}

Scripts/Mobiles/Base/AI/TimidAI.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+	public class TimidAI : BaseAI
+	{
+		public TimidAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, true, false, true))
+			{
+				m_Mobile.DebugSay( "There is something near, I go away" );
+				Action = ActionType.Backoff;
+			}
+			else if ( m_Mobile.IsHurt() || m_Mobile.Combatant != null )
+			{
+				m_Mobile.DebugSay( "I am hurt or being attacked, I flee" );						
+				Action = ActionType.Flee;
+			}
+			else
+			{
+				base.DoActionWander();
+			}
+
+			return true;
+		}
+
+		public override bool DoActionCombat()
+		{
+			Mobile combatant = m_Mobile.Combatant;
+
+			if ( combatant == null || combatant.Deleted || combatant.Map != m_Mobile.Map )
+			{
+				m_Mobile.DebugSay( "My combatant is gone.." );
+
+				Action = ActionType.Wander;
+
+				return true;
+			}
+
+			if ( WalkMobileRange( combatant, 1, true, m_Mobile.RangeFight, m_Mobile.RangeFight ) )
+			{
+				m_Mobile.Direction = m_Mobile.GetDirectionTo( combatant );
+			}
+			else
+			{
+				if ( m_Mobile.GetDistanceToSqrt( combatant ) > m_Mobile.RangePerception + 1 )
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "I cannot find {0}", combatant.Name );
+
+					Action = ActionType.Wander;
+
+					return true;
+				}
+				else
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "I should be closer to {0}", combatant.Name );
+				}
+			}
+
+			if ( !m_Mobile.Controlled && !m_Mobile.Summoned )
+			{
+				double hitPercent = (double)m_Mobile.Hits / m_Mobile.HitsMax;
+
+				if ( hitPercent < 0.1 )
+				{
+					m_Mobile.DebugSay( "I am low on health!" );
+					Action = ActionType.Flee;
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionBackoff()
+		{
+			double hitPercent = (double)m_Mobile.Hits / m_Mobile.HitsMax;
+
+			if ( !m_Mobile.Summoned && !m_Mobile.Controlled && hitPercent < 0.1 ) // Less than 10% health
+			{
+				Action = ActionType.Flee;
+			}
+			else
+			{
+				if (AcquireFocusMob(m_Mobile.RangePerception * 2, FightMode.Closest, true, false , true))
+				{
+					if ( WalkMobileRange(m_Mobile.FocusMob, 1, false, m_Mobile.RangePerception, m_Mobile.RangePerception * 2) )
+					{
+						m_Mobile.DebugSay( "Well, here I am safe" );
+						Action = ActionType.Wander;
+					}					
+				}
+				else
+				{
+					m_Mobile.DebugSay( "I have lost my focus, lets relax" );
+					Action = ActionType.Wander;
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionFlee()
+		{
+			AcquireFocusMob(m_Mobile.RangePerception * 2, m_Mobile.FightMode, true, false, true);
+
+			if ( m_Mobile.FocusMob == null )
+				m_Mobile.FocusMob = m_Mobile.Combatant;
+
+			return base.DoActionFlee();
+		}
+	}
+}

Scripts/Mobiles/Base/AI/VendorAI.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+
+//
+// This is a first simple AI
+//
+//
+
+namespace Server.Mobiles
+{
+	public class VendorAI : BaseAI
+	{
+		public VendorAI(BaseCreature m) : base (m)
+		{
+		}
+
+		public override bool DoActionWander()
+		{
+			m_Mobile.DebugSay( "I'm fine" );
+
+			if ( m_Mobile.Combatant != null )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "{0} is attacking me", m_Mobile.Combatant.Name );
+
+				m_Mobile.Say( Utility.RandomList( 1005305, 501603 ) );
+
+				Action = ActionType.Flee;
+			}
+			else
+			{
+				if ( m_Mobile.FocusMob != null )
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "{0} has talked to me", m_Mobile.FocusMob.Name );
+
+					Action = ActionType.Interact;
+				}
+				else
+				{
+					m_Mobile.Warmode = false;
+
+					base.DoActionWander();
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionInteract()
+		{
+			Mobile customer = m_Mobile.FocusMob;
+
+			if ( m_Mobile.Combatant != null )
+			{
+				if ( m_Mobile.Debug )
+					m_Mobile.DebugSay( "{0} is attacking me", m_Mobile.Combatant.Name );
+
+				m_Mobile.Say( Utility.RandomList( 1005305, 501603 ) );
+
+				Action = ActionType.Flee;
+				
+				return true;
+			}
+
+			if ( customer == null || customer.Deleted || customer.Map != m_Mobile.Map )
+			{
+				m_Mobile.DebugSay( "My customer have disapeared" );
+				m_Mobile.FocusMob = null;
+
+				Action = ActionType.Wander;
+			}
+			else
+			{
+				if ( customer.InRange( m_Mobile, m_Mobile.RangeFight ) )
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "I am with {0}", customer.Name );
+
+					m_Mobile.Direction = m_Mobile.GetDirectionTo( customer );
+				}
+				else
+				{
+					if ( m_Mobile.Debug )
+						m_Mobile.DebugSay( "{0} is gone", customer.Name );
+
+					m_Mobile.FocusMob = null;
+
+					Action = ActionType.Wander;	
+				}
+			}
+
+			return true;
+		}
+
+		public override bool DoActionGuard()
+		{
+			m_Mobile.FocusMob = m_Mobile.Combatant;
+			return base.DoActionGuard();
+		}
+
+		public override bool HandlesOnSpeech( Mobile from )
+		{
+			if ( from.InRange( m_Mobile, 4 ) )
+				return true;
+
+			return base.HandlesOnSpeech( from );
+		}
+
+		// Temporary 
+		public override void OnSpeech( SpeechEventArgs e )
+		{
+			base.OnSpeech( e );
+ 
+			Mobile from = e.Mobile;
+ 
+			if ( m_Mobile is BaseVendor && from.InRange( m_Mobile, Core.AOS ? 1 : 4 ) && !e.Handled )
+			{
+				if ( e.HasKeyword( 0x14D ) ) // *vendor sell*
+				{
+					e.Handled = true;
+
+					((BaseVendor)m_Mobile).VendorSell( from );
+					m_Mobile.FocusMob = from;
+				}
+				else if ( e.HasKeyword( 0x3C ) )
+				{
+					e.Handled = true;
+
+					((BaseVendor)m_Mobile).VendorBuy( from );
+					m_Mobile.FocusMob = from;
+				}
+				else if ( WasNamed( e.Speech ) )
+				{
+					e.Handled = true;
+
+					if ( e.HasKeyword( 0x177 ) ) // *sell*
+						((BaseVendor)m_Mobile).VendorSell( from );
+					else if ( e.HasKeyword( 0x171 ) ) // *buy*
+						((BaseVendor)m_Mobile).VendorBuy( from );
+
+					m_Mobile.FocusMob = from;
+				}
+			}
+		}
+	}
+}