#W# Source and Scripts added. Added Scripts/Settings.cs to expose some basic tweak able settings.

Scripts/Engines/Harvest/Core/BonusHarvestResource.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace Server.Engines.Harvest
+{
+	public class BonusHarvestResource
+	{
+		private Type m_Type;
+		private double m_ReqSkill, m_Chance;
+		private TextDefinition m_SuccessMessage;
+
+		public Type Type { get { return m_Type; } set { m_Type = value; } }
+		public double ReqSkill { get { return m_ReqSkill; } set { m_ReqSkill = value; } }
+		public double Chance { get { return m_Chance; } set { m_Chance = value; } }
+
+		public TextDefinition SuccessMessage { get { return m_SuccessMessage; } }
+
+		public void SendSuccessTo( Mobile m )
+		{
+			TextDefinition.SendMessageTo( m, m_SuccessMessage );
+		}
+
+		public BonusHarvestResource( double reqSkill, double chance, TextDefinition message, Type type )
+		{
+			m_ReqSkill = reqSkill;
+
+			m_Chance = chance;
+			m_Type = type;
+			m_SuccessMessage = message;
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestBank.cs

@@ -0,0 +1,102 @@
+using System;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestBank
+	{
+		private int m_Current;
+		private int m_Maximum;
+		private DateTime m_NextRespawn;
+		private HarvestVein m_Vein, m_DefaultVein;
+
+		HarvestDefinition m_Definition;
+
+		public HarvestDefinition Definition
+		{
+			get { return m_Definition; }
+		}
+
+		public int Current
+		{
+			get
+			{
+				CheckRespawn();
+				return m_Current;
+			}
+		}
+
+		public HarvestVein Vein
+		{
+			get
+			{
+				CheckRespawn();
+				return m_Vein;
+			}
+			set
+			{
+				m_Vein = value;
+			}
+		}
+
+		public HarvestVein DefaultVein
+		{
+			get
+			{
+				CheckRespawn();
+				return m_DefaultVein;
+			}
+		}
+
+		public void CheckRespawn()
+		{
+			if ( m_Current == m_Maximum || m_NextRespawn > DateTime.UtcNow )
+				return;
+
+			m_Current = m_Maximum;
+
+			if ( m_Definition.RandomizeVeins )
+			{
+				m_DefaultVein = m_Definition.GetVeinFrom( Utility.RandomDouble() );
+			}
+
+			m_Vein = m_DefaultVein;
+		}
+
+		public void Consume( int amount, Mobile from )
+		{
+			CheckRespawn();
+
+			if ( m_Current == m_Maximum )
+			{
+				double min = m_Definition.MinRespawn.TotalMinutes;
+				double max = m_Definition.MaxRespawn.TotalMinutes;
+				double rnd = Utility.RandomDouble();
+
+				m_Current = m_Maximum - amount;
+
+				double minutes = min + (rnd * (max - min));
+				if ( m_Definition.RaceBonus && from.Race == Race.Elf )	//def.RaceBonus = Core.ML
+					minutes *= .75;	//25% off the time.  
+
+				m_NextRespawn = DateTime.UtcNow + TimeSpan.FromMinutes( minutes );
+			}
+			else
+			{
+				m_Current -= amount;
+			}
+
+			if ( m_Current < 0 )
+				m_Current = 0;
+		}
+
+		public HarvestBank( HarvestDefinition def, HarvestVein defaultVein )
+		{
+			m_Maximum = Utility.RandomMinMax( def.MinTotal, def.MaxTotal );
+			m_Current = m_Maximum;
+			m_DefaultVein = defaultVein;
+			m_Vein = m_DefaultVein;
+
+			m_Definition = def;
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestDefinition.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestDefinition
+	{
+		private int m_BankWidth, m_BankHeight;
+		private int m_MinTotal, m_MaxTotal;
+		private int[] m_Tiles;
+		private bool m_RangedTiles;
+		private TimeSpan m_MinRespawn, m_MaxRespawn;
+		private int m_MaxRange;
+		private int m_ConsumedPerHarvest, m_ConsumedPerFeluccaHarvest;
+		private bool m_PlaceAtFeetIfFull;
+		private SkillName m_Skill;
+		private int[] m_EffectActions;
+		private int[] m_EffectCounts;
+		private int[] m_EffectSounds;
+		private TimeSpan m_EffectSoundDelay;
+		private TimeSpan m_EffectDelay;
+		private object m_NoResourcesMessage, m_OutOfRangeMessage, m_TimedOutOfRangeMessage, m_DoubleHarvestMessage, m_FailMessage, m_PackFullMessage, m_ToolBrokeMessage;
+		private HarvestResource[] m_Resources;
+		private HarvestVein[] m_Veins;
+		private BonusHarvestResource[] m_BonusResources;
+		private bool m_RaceBonus;
+		private bool m_RandomizeVeins;
+
+		public int BankWidth{ get{ return m_BankWidth; } set{ m_BankWidth = value; } }
+		public int BankHeight{ get{ return m_BankHeight; } set{ m_BankHeight = value; } }
+		public int MinTotal{ get{ return m_MinTotal; } set{ m_MinTotal = value; } }
+		public int MaxTotal{ get{ return m_MaxTotal; } set{ m_MaxTotal = value; } }
+		public int[] Tiles{ get{ return m_Tiles; } set{ m_Tiles = value; } }
+		public bool RangedTiles{ get{ return m_RangedTiles; } set{ m_RangedTiles = value; } }
+		public TimeSpan MinRespawn{ get{ return m_MinRespawn; } set{ m_MinRespawn = value; } }
+		public TimeSpan MaxRespawn{ get{ return m_MaxRespawn; } set{ m_MaxRespawn = value; } }
+		public int MaxRange{ get{ return m_MaxRange; } set{ m_MaxRange = value; } }
+		public int ConsumedPerHarvest{ get{ return m_ConsumedPerHarvest; } set{ m_ConsumedPerHarvest = value; } }
+		public int ConsumedPerFeluccaHarvest{ get{ return m_ConsumedPerFeluccaHarvest; } set{ m_ConsumedPerFeluccaHarvest = value; } }
+		public bool PlaceAtFeetIfFull{ get{ return m_PlaceAtFeetIfFull; } set{ m_PlaceAtFeetIfFull = value; } }
+		public SkillName Skill{ get{ return m_Skill; } set{ m_Skill = value; } }
+		public int[] EffectActions{ get{ return m_EffectActions; } set{ m_EffectActions = value; } }
+		public int[] EffectCounts{ get{ return m_EffectCounts; } set{ m_EffectCounts = value; } }
+		public int[] EffectSounds{ get{ return m_EffectSounds; } set{ m_EffectSounds = value; } }
+		public TimeSpan EffectSoundDelay{ get{ return m_EffectSoundDelay; } set{ m_EffectSoundDelay = value; } }
+		public TimeSpan EffectDelay{ get{ return m_EffectDelay; } set{ m_EffectDelay = value; } }
+		public object NoResourcesMessage{ get{ return m_NoResourcesMessage; } set{ m_NoResourcesMessage = value; } }
+		public object OutOfRangeMessage{ get{ return m_OutOfRangeMessage; } set{ m_OutOfRangeMessage = value; } }
+		public object TimedOutOfRangeMessage{ get{ return m_TimedOutOfRangeMessage; } set{ m_TimedOutOfRangeMessage = value; } }
+		public object DoubleHarvestMessage{ get{ return m_DoubleHarvestMessage; } set{ m_DoubleHarvestMessage = value; } }
+		public object FailMessage{ get{ return m_FailMessage; } set{ m_FailMessage = value; } }
+		public object PackFullMessage{ get{ return m_PackFullMessage; } set{ m_PackFullMessage = value; } }
+		public object ToolBrokeMessage{ get{ return m_ToolBrokeMessage; } set{ m_ToolBrokeMessage = value; } }
+		public HarvestResource[] Resources{ get{ return m_Resources; } set{ m_Resources = value; } }
+		public HarvestVein[] Veins{ get{ return m_Veins; } set{ m_Veins = value; } }
+		public BonusHarvestResource[] BonusResources{ get { return m_BonusResources; } set { m_BonusResources = value; } }
+		public bool RaceBonus { get { return m_RaceBonus; } set { m_RaceBonus = value; } }
+		public bool RandomizeVeins { get { return m_RandomizeVeins; } set { m_RandomizeVeins = value; } }
+
+		private Dictionary<Map, Dictionary<Point2D, HarvestBank>> m_BanksByMap;
+
+		public Dictionary<Map, Dictionary<Point2D, HarvestBank>> Banks{ get{ return m_BanksByMap; } set{ m_BanksByMap = value; } }
+
+		public void SendMessageTo( Mobile from, object message )
+		{
+			if ( message is int )
+				from.SendLocalizedMessage( (int)message );
+			else if ( message is string )
+				from.SendMessage( (string)message );
+		}
+
+		public HarvestBank GetBank( Map map, int x, int y )
+		{
+			if ( map == null || map == Map.Internal )
+				return null;
+
+			x /= m_BankWidth;
+			y /= m_BankHeight;
+
+			Dictionary<Point2D, HarvestBank> banks = null;
+			m_BanksByMap.TryGetValue( map, out banks );
+
+			if ( banks == null )
+				m_BanksByMap[map] = banks = new Dictionary<Point2D, HarvestBank>();
+
+			Point2D key = new Point2D( x, y );
+			HarvestBank bank = null;
+			banks.TryGetValue( key, out bank );
+
+			if ( bank == null )
+				banks[key] = bank = new HarvestBank( this, GetVeinAt( map, x, y ) );
+
+			return bank;
+		}
+
+		public HarvestVein GetVeinAt( Map map, int x, int y )
+		{
+			if ( m_Veins.Length == 1 )
+				return m_Veins[0];
+
+			double randomValue;
+
+			if ( m_RandomizeVeins )
+			{
+				randomValue = Utility.RandomDouble();
+			}
+			else
+			{
+				Random random = new Random( ( x * 17 ) + ( y * 11 ) + ( map.MapID * 3 ) );
+				randomValue = random.NextDouble();
+			}
+
+			return GetVeinFrom( randomValue );
+		}
+
+		public HarvestVein GetVeinFrom( double randomValue )
+		{
+			if ( m_Veins.Length == 1 )
+				return m_Veins[0];
+
+			randomValue *= 100;
+
+			for ( int i = 0; i < m_Veins.Length; ++i )
+			{
+				if ( randomValue <= m_Veins[i].VeinChance )
+					return m_Veins[i];
+
+				randomValue -= m_Veins[i].VeinChance;
+			}
+
+			return null;
+		}
+
+		public BonusHarvestResource GetBonusResource()
+		{
+			if ( m_BonusResources == null )
+				return null;
+
+			double randomValue = Utility.RandomDouble() * 100;
+
+			for ( int i = 0; i < m_BonusResources.Length; ++i )
+			{
+				if ( randomValue <= m_BonusResources[i].Chance )
+					return m_BonusResources[i];
+
+				randomValue -= m_BonusResources[i].Chance;
+			}
+
+			return null;
+		}
+
+		public HarvestDefinition()
+		{
+			m_BanksByMap = new Dictionary<Map, Dictionary<Point2D, HarvestBank>>();
+		}
+
+		public bool Validate( int tileID )
+		{
+			if ( m_RangedTiles )
+			{
+				bool contains = false;
+
+				for ( int i = 0; !contains && i < m_Tiles.Length; i += 2 )
+					contains = ( tileID >= m_Tiles[i] && tileID <= m_Tiles[i + 1] );
+
+				return contains;
+			}
+			else
+			{
+				int dist = -1;
+
+				for ( int i = 0; dist < 0 && i < m_Tiles.Length; ++i )
+					dist = ( m_Tiles[i] - tileID );
+
+				return ( dist == 0 );
+			}
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestResource.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestResource
+	{
+		private Type[] m_Types;
+		private double m_ReqSkill, m_MinSkill, m_MaxSkill;
+		private object m_SuccessMessage;
+
+		public Type[] Types{ get{ return m_Types; } set{ m_Types = value; } }
+		public double ReqSkill{ get{ return m_ReqSkill; } set{ m_ReqSkill = value; } }
+		public double MinSkill{ get{ return m_MinSkill; } set{ m_MinSkill = value; } }
+		public double MaxSkill{ get{ return m_MaxSkill; } set{ m_MaxSkill = value; } }
+		public object SuccessMessage{ get{ return m_SuccessMessage; } }
+
+		public void SendSuccessTo( Mobile m )
+		{
+			if ( m_SuccessMessage is int )
+				m.SendLocalizedMessage( (int)m_SuccessMessage );
+			else if ( m_SuccessMessage is string )
+				m.SendMessage( (string)m_SuccessMessage );
+		}
+
+		public HarvestResource( double reqSkill, double minSkill, double maxSkill, object message, params Type[] types )
+		{
+			m_ReqSkill = reqSkill;
+			m_MinSkill = minSkill;
+			m_MaxSkill = maxSkill;
+			m_Types = types;
+			m_SuccessMessage = message;
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestSoundTimer.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestSoundTimer : Timer
+	{
+		private Mobile m_From;
+		private Item m_Tool;
+		private HarvestSystem m_System;
+		private HarvestDefinition m_Definition;
+		private object m_ToHarvest, m_Locked;
+		private bool m_Last;
+
+		public HarvestSoundTimer( Mobile from, Item tool, HarvestSystem system, HarvestDefinition def, object toHarvest, object locked, bool last ) : base( def.EffectSoundDelay )
+		{
+			m_From = from;
+			m_Tool = tool;
+			m_System = system;
+			m_Definition = def;
+			m_ToHarvest = toHarvest;
+			m_Locked = locked;
+			m_Last = last;
+		}
+
+		protected override void OnTick()
+		{
+			m_System.DoHarvestingSound( m_From, m_Tool, m_Definition, m_ToHarvest );
+
+			if ( m_Last )
+				m_System.FinishHarvesting( m_From, m_Tool, m_Definition, m_ToHarvest, m_Locked );
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestSystem.cs

@@ -0,0 +1,506 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Items;
+using Server.Targeting;
+
+namespace Server.Engines.Harvest
+{
+	public abstract class HarvestSystem
+	{
+		private List<HarvestDefinition> m_Definitions;
+
+		public List<HarvestDefinition> Definitions { get { return m_Definitions; } }
+
+		public HarvestSystem()
+		{
+			m_Definitions = new List<HarvestDefinition>();
+		}
+
+		public virtual bool CheckTool( Mobile from, Item tool )
+		{
+			bool wornOut = ( tool == null || tool.Deleted || (tool is IUsesRemaining && ((IUsesRemaining)tool).UsesRemaining <= 0) );
+
+			if ( wornOut )
+				from.SendLocalizedMessage( 1044038 ); // You have worn out your tool!
+
+			return !wornOut;
+		}
+
+		public virtual bool CheckHarvest( Mobile from, Item tool )
+		{
+			return CheckTool( from, tool );
+		}
+
+		public virtual bool CheckHarvest( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			return CheckTool( from, tool );
+		}
+
+		public virtual bool CheckRange( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, bool timed )
+		{
+			bool inRange = ( from.Map == map && from.InRange( loc, def.MaxRange ) );
+
+			if ( !inRange )
+				def.SendMessageTo( from, timed ? def.TimedOutOfRangeMessage : def.OutOfRangeMessage );
+
+			return inRange;
+		}
+
+		public virtual bool CheckResources( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, bool timed )
+		{
+			HarvestBank bank = def.GetBank( map, loc.X, loc.Y );
+			bool available = ( bank != null && bank.Current >= def.ConsumedPerHarvest );
+
+			if ( !available )
+				def.SendMessageTo( from, timed ? def.DoubleHarvestMessage : def.NoResourcesMessage );
+
+			return available;
+		}
+
+		public virtual void OnBadHarvestTarget( Mobile from, Item tool, object toHarvest )
+		{
+		}
+
+		public virtual object GetLock( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			/* Here we prevent multiple harvesting.
+			 * 
+			 * Some options:
+			 *  - 'return tool;' : This will allow the player to harvest more than once concurrently, but only if they use multiple tools. This seems to be as OSI.
+			 *  - 'return GetType();' : This will disallow multiple harvesting of the same type. That is, we couldn't mine more than once concurrently, but we could be both mining and lumberjacking.
+			 *  - 'return typeof( HarvestSystem );' : This will completely restrict concurrent harvesting.
+			 */
+
+			return tool;
+		}
+
+		public virtual void OnConcurrentHarvest( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+		}
+
+		public virtual void OnHarvestStarted( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+		}
+
+		public virtual bool BeginHarvesting( Mobile from, Item tool )
+		{
+			if ( !CheckHarvest( from, tool ) )
+				return false;
+
+			from.Target = new HarvestTarget( tool, this );
+			return true;
+		}
+
+		public virtual void FinishHarvesting( Mobile from, Item tool, HarvestDefinition def, object toHarvest, object locked )
+		{
+			from.EndAction( locked );
+
+			if ( !CheckHarvest( from, tool ) )
+				return;
+
+			int tileID;
+			Map map;
+			Point3D loc;
+
+			if ( !GetHarvestDetails( from, tool, toHarvest, out tileID, out map, out loc ) )
+			{
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return;
+			}
+			else if ( !def.Validate( tileID ) )
+			{
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return;
+			}
+			
+			if ( !CheckRange( from, tool, def, map, loc, true ) )
+				return;
+			else if ( !CheckResources( from, tool, def, map, loc, true ) )
+				return;
+			else if ( !CheckHarvest( from, tool, def, toHarvest ) )
+				return;
+
+			if ( SpecialHarvest( from, tool, def, map, loc ) )
+				return;
+
+			HarvestBank bank = def.GetBank( map, loc.X, loc.Y );
+
+			if ( bank == null )
+				return;
+
+			HarvestVein vein = bank.Vein;
+
+			if ( vein != null )
+				vein = MutateVein( from, tool, def, bank, toHarvest, vein );
+
+			if ( vein == null )
+				return;
+
+			HarvestResource primary = vein.PrimaryResource;
+			HarvestResource fallback = vein.FallbackResource;
+			HarvestResource resource = MutateResource( from, tool, def, map, loc, vein, primary, fallback );
+
+			double skillBase = from.Skills[def.Skill].Base;
+			double skillValue = from.Skills[def.Skill].Value;
+
+			Type type = null;
+
+			if ( skillBase >= resource.ReqSkill && from.CheckSkill( def.Skill, resource.MinSkill, resource.MaxSkill ) )
+			{
+				type = GetResourceType( from, tool, def, map, loc, resource );
+
+				if ( type != null )
+					type = MutateType( type, from, tool, def, map, loc, resource );
+
+				if ( type != null )
+				{
+					Item item = Construct( type, from );
+
+					if ( item == null )
+					{
+						type = null;
+					}
+					else
+					{
+						//The whole harvest system is kludgy and I'm sure this is just adding to it.
+						if ( item.Stackable )
+						{
+							int amount = def.ConsumedPerHarvest;
+							int feluccaAmount = def.ConsumedPerFeluccaHarvest;
+
+							int racialAmount = (int)Math.Ceiling( amount * 1.1 );
+							int feluccaRacialAmount = (int)Math.Ceiling( feluccaAmount * 1.1 );
+
+							bool eligableForRacialBonus = ( def.RaceBonus && from.Race == Race.Human );
+							bool inFelucca = (map == Map.Felucca);
+
+							if( eligableForRacialBonus && inFelucca && bank.Current >= feluccaRacialAmount && 0.1 > Utility.RandomDouble() )
+								item.Amount = feluccaRacialAmount;
+							else if( inFelucca && bank.Current >= feluccaAmount )
+								item.Amount = feluccaAmount;
+							else if( eligableForRacialBonus && bank.Current >= racialAmount && 0.1 > Utility.RandomDouble() )
+								item.Amount = racialAmount;
+							else
+								item.Amount = amount;
+						}
+
+						bank.Consume( item.Amount, from );
+
+						if ( Give( from, item, def.PlaceAtFeetIfFull ) )
+						{
+							SendSuccessTo( from, item, resource );
+						}
+						else
+						{
+							SendPackFullTo( from, item, def, resource );
+							item.Delete();
+						}
+
+						BonusHarvestResource bonus = def.GetBonusResource();
+
+						if ( bonus != null && bonus.Type != null && skillBase >= bonus.ReqSkill )
+						{
+							Item bonusItem = Construct( bonus.Type, from );
+
+							if ( Give( from, bonusItem, true ) )	//Bonuses always allow placing at feet, even if pack is full irregrdless of def
+							{
+								bonus.SendSuccessTo( from );
+							}
+							else
+							{
+								item.Delete();
+							}
+						}
+
+						if ( tool is IUsesRemaining )
+						{
+							IUsesRemaining toolWithUses = (IUsesRemaining)tool;
+
+							toolWithUses.ShowUsesRemaining = true;
+
+							if ( toolWithUses.UsesRemaining > 0 )
+								--toolWithUses.UsesRemaining;
+
+							if ( toolWithUses.UsesRemaining < 1 )
+							{
+								tool.Delete();
+								def.SendMessageTo( from, def.ToolBrokeMessage );
+							}
+						}
+					}
+				}
+			}
+
+			if ( type == null )
+				def.SendMessageTo( from, def.FailMessage );
+
+			OnHarvestFinished( from, tool, def, vein, bank, resource, toHarvest );
+		}
+
+		public virtual void OnHarvestFinished( Mobile from, Item tool, HarvestDefinition def, HarvestVein vein, HarvestBank bank, HarvestResource resource, object harvested )
+		{
+		}
+
+		public virtual bool SpecialHarvest( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc )
+		{
+			return false;
+		}
+
+		public virtual Item Construct( Type type, Mobile from )
+		{
+			try{ return Activator.CreateInstance( type ) as Item; }
+			catch{ return null; }
+		}
+
+		public virtual HarvestVein MutateVein( Mobile from, Item tool, HarvestDefinition def, HarvestBank bank, object toHarvest, HarvestVein vein )
+		{
+			return vein;
+		}
+
+		public virtual void SendSuccessTo( Mobile from, Item item, HarvestResource resource )
+		{
+			resource.SendSuccessTo( from );
+		}
+
+		public virtual void SendPackFullTo( Mobile from, Item item, HarvestDefinition def, HarvestResource resource )
+		{
+			def.SendMessageTo( from, def.PackFullMessage );
+		}
+
+		public virtual bool Give( Mobile m, Item item, bool placeAtFeet )
+		{
+			if ( m.PlaceInBackpack( item ) )
+				return true;
+
+			if ( !placeAtFeet )
+				return false;
+
+			Map map = m.Map;
+
+			if ( map == null )
+				return false;
+
+			List<Item> atFeet = new List<Item>();
+
+			foreach ( Item obj in m.GetItemsInRange( 0 ) )
+				atFeet.Add( obj );
+
+			for ( int i = 0; i < atFeet.Count; ++i )
+			{
+				Item check = atFeet[i];
+
+				if ( check.StackWith( m, item, false ) )
+					return true;
+			}
+
+			item.MoveToWorld( m.Location, map );
+			return true;
+		}
+
+		public virtual Type MutateType( Type type, Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, HarvestResource resource )
+		{
+			return from.Region.GetResource( type );
+		}
+
+		public virtual Type GetResourceType( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, HarvestResource resource )
+		{
+			if ( resource.Types.Length > 0 )
+				return resource.Types[Utility.Random( resource.Types.Length )];
+
+			return null;
+		}
+
+		public virtual HarvestResource MutateResource( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, HarvestVein vein, HarvestResource primary, HarvestResource fallback )
+		{
+			bool racialBonus = (def.RaceBonus && from.Race == Race.Elf );
+
+			if( vein.ChanceToFallback > (Utility.RandomDouble() + (racialBonus ? .20 : 0)) )
+				return fallback;
+
+			double skillValue = from.Skills[def.Skill].Value;
+
+			if ( fallback != null && (skillValue < primary.ReqSkill || skillValue < primary.MinSkill) )
+				return fallback;
+
+			return primary;
+		}
+
+		public virtual bool OnHarvesting( Mobile from, Item tool, HarvestDefinition def, object toHarvest, object locked, bool last )
+		{
+			if ( !CheckHarvest( from, tool ) )
+			{
+				from.EndAction( locked );
+				return false;
+			}
+
+			int tileID;
+			Map map;
+			Point3D loc;
+
+			if ( !GetHarvestDetails( from, tool, toHarvest, out tileID, out map, out loc ) )
+			{
+				from.EndAction( locked );
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return false;
+			}
+			else if ( !def.Validate( tileID ) )
+			{
+				from.EndAction( locked );
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return false;
+			}
+			else if ( !CheckRange( from, tool, def, map, loc, true ) )
+			{
+				from.EndAction( locked );
+				return false;
+			}
+			else if ( !CheckResources( from, tool, def, map, loc, true ) )
+			{
+				from.EndAction( locked );
+				return false;
+			}
+			else if ( !CheckHarvest( from, tool, def, toHarvest ) )
+			{
+				from.EndAction( locked );
+				return false;
+			}
+
+			DoHarvestingEffect( from, tool, def, map, loc );
+
+			new HarvestSoundTimer( from, tool, this, def, toHarvest, locked, last ).Start();
+
+			return !last;
+		}
+
+		public virtual void DoHarvestingSound( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			if ( def.EffectSounds.Length > 0 )
+				from.PlaySound( Utility.RandomList( def.EffectSounds ) );
+		}
+
+		public virtual void DoHarvestingEffect( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc )
+		{
+			from.Direction = from.GetDirectionTo( loc );
+
+			if ( !from.Mounted )
+				from.Animate( Utility.RandomList( def.EffectActions ), 5, 1, true, false, 0 );
+		}
+
+		public virtual HarvestDefinition GetDefinition( int tileID )
+		{
+			HarvestDefinition def = null;
+
+			for ( int i = 0; def == null && i < m_Definitions.Count; ++i )
+			{
+				HarvestDefinition check = m_Definitions[i];
+
+				if ( check.Validate( tileID ) )
+					def = check;
+			}
+
+			return def;
+		}
+
+		public virtual void StartHarvesting( Mobile from, Item tool, object toHarvest )
+		{
+			if ( !CheckHarvest( from, tool ) )
+				return;
+
+			int tileID;
+			Map map;
+			Point3D loc;
+
+			if ( !GetHarvestDetails( from, tool, toHarvest, out tileID, out map, out loc ) )
+			{
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return;
+			}
+
+			HarvestDefinition def = GetDefinition( tileID );
+
+			if ( def == null )
+			{
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return;
+			}
+
+			if ( !CheckRange( from, tool, def, map, loc, false ) )
+				return;
+			else if ( !CheckResources( from, tool, def, map, loc, false ) )
+				return;
+			else if ( !CheckHarvest( from, tool, def, toHarvest ) )
+				return;
+
+			object toLock = GetLock( from, tool, def, toHarvest );
+
+			if ( !from.BeginAction( toLock ) )
+			{
+				OnConcurrentHarvest( from, tool, def, toHarvest );
+				return;
+			}
+
+			new HarvestTimer( from, tool, this, def, toHarvest, toLock ).Start();
+			OnHarvestStarted( from, tool, def, toHarvest );
+		}
+
+		public virtual bool GetHarvestDetails( Mobile from, Item tool, object toHarvest, out int tileID, out Map map, out Point3D loc )
+		{
+			if ( toHarvest is Static && !((Static)toHarvest).Movable )
+			{
+				Static obj = (Static)toHarvest;
+
+				tileID = (obj.ItemID & 0x3FFF) | 0x4000;
+				map = obj.Map;
+				loc = obj.GetWorldLocation();
+			}
+			else if ( toHarvest is StaticTarget )
+			{
+				StaticTarget obj = (StaticTarget)toHarvest;
+
+				tileID = (obj.ItemID & 0x3FFF) | 0x4000;
+				map = from.Map;
+				loc = obj.Location;
+			}
+			else if ( toHarvest is LandTarget )
+			{
+				LandTarget obj = (LandTarget)toHarvest;
+
+				tileID = obj.TileID;
+				map = from.Map;
+				loc = obj.Location;
+			}
+			else
+			{
+				tileID = 0;
+				map = null;
+				loc = Point3D.Zero;
+				return false;
+			}
+
+			return ( map != null && map != Map.Internal );
+		}
+	}
+}
+
+namespace Server
+{
+	public interface IChopable
+	{
+		void OnChop( Mobile from );
+	}
+
+	[AttributeUsage( AttributeTargets.Class )]
+	public class FurnitureAttribute : Attribute
+	{
+		public static bool Check( Item item )
+		{
+			return ( item != null && item.GetType().IsDefined( typeof( FurnitureAttribute ), false ) );
+		}
+
+		public FurnitureAttribute()
+		{
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestTarget.cs

@@ -0,0 +1,107 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Targeting;
+using Server.Multis;
+using Server.Mobiles;
+using Server.Engines.Quests;
+using Server.Engines.Quests.Hag;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestTarget : Target
+	{
+		private Item m_Tool;
+		private HarvestSystem m_System;
+
+		public HarvestTarget( Item tool, HarvestSystem system ) : base( -1, true, TargetFlags.None )
+		{
+			m_Tool = tool;
+			m_System = system;
+
+			DisallowMultis = true;
+		}
+
+		protected override void OnTarget( Mobile from, object targeted )
+		{
+			if ( m_System is Mining && targeted is StaticTarget )
+			{
+				int itemID = ((StaticTarget)targeted).ItemID;
+
+				// grave
+				if ( itemID == 0xED3 || itemID == 0xEDF || itemID == 0xEE0 || itemID == 0xEE1 || itemID == 0xEE2 || itemID == 0xEE8 )
+				{
+					PlayerMobile player = from as PlayerMobile;
+
+					if ( player != null )
+					{
+						QuestSystem qs = player.Quest;
+
+						if ( qs is WitchApprenticeQuest )
+						{
+							FindIngredientObjective obj = qs.FindObjective( typeof( FindIngredientObjective ) ) as FindIngredientObjective;
+
+							if ( obj != null && !obj.Completed && obj.Ingredient == Ingredient.Bones )
+							{
+								player.SendLocalizedMessage( 1055037 ); // You finish your grim work, finding some of the specific bones listed in the Hag's recipe.
+								obj.Complete();
+
+								return;
+							}
+						}
+					}
+				}
+			}
+
+			if ( m_System is Lumberjacking && targeted is IChopable )
+				((IChopable)targeted).OnChop( from );
+			else if ( m_System is Lumberjacking && targeted is IAxe && m_Tool is BaseAxe )
+			{
+				IAxe obj = (IAxe)targeted;
+				Item item = (Item)targeted;
+					
+				if ( !item.IsChildOf( from.Backpack ) )
+					from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.
+				else if ( obj.Axe( from, (BaseAxe)m_Tool ) )
+					from.PlaySound( 0x13E );
+			}
+			else if ( m_System is Lumberjacking && targeted is ICarvable )
+				((ICarvable)targeted).Carve( from, (Item)m_Tool );
+			else if ( m_System is Lumberjacking && FurnitureAttribute.Check( targeted as Item ) )
+				DestroyFurniture( from, (Item)targeted );
+			else if ( m_System is Mining && targeted is TreasureMap )
+				((TreasureMap)targeted).OnBeginDig( from );
+			else
+				m_System.StartHarvesting( from, m_Tool, targeted );
+		}
+
+		private void DestroyFurniture( Mobile from, Item item )
+		{
+			if ( !from.InRange( item.GetWorldLocation(), 3 ) )
+			{
+				from.SendLocalizedMessage( 500446 ); // That is too far away.
+				return;
+			}
+			else if ( !item.IsChildOf( from.Backpack ) && !item.Movable )
+			{
+				from.SendLocalizedMessage( 500462 ); // You can't destroy that while it is here.
+				return;
+			}
+
+			from.SendLocalizedMessage( 500461 ); // You destroy the item.
+			Effects.PlaySound( item.GetWorldLocation(), item.Map, 0x3B3 );
+
+			if ( item is Container )
+			{
+				if ( item is TrapableContainer )
+					(item as TrapableContainer).ExecuteTrap( from );
+
+				((Container)item).Destroy();
+			}
+			else
+			{
+				item.Delete();
+			}
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestTimer.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestTimer : Timer
+	{
+		private Mobile m_From;
+		private Item m_Tool;
+		private HarvestSystem m_System;
+		private HarvestDefinition m_Definition;
+		private object m_ToHarvest, m_Locked;
+		private int m_Index, m_Count;
+
+		public HarvestTimer( Mobile from, Item tool, HarvestSystem system, HarvestDefinition def, object toHarvest, object locked ) : base( TimeSpan.Zero, def.EffectDelay )
+		{
+			m_From = from;
+			m_Tool = tool;
+			m_System = system;
+			m_Definition = def;
+			m_ToHarvest = toHarvest;
+			m_Locked = locked;
+			m_Count = Utility.RandomList( def.EffectCounts );
+		}
+
+		protected override void OnTick()
+		{
+			if ( !m_System.OnHarvesting( m_From, m_Tool, m_Definition, m_ToHarvest, m_Locked, ++m_Index == m_Count ) )
+				Stop();
+		}
+	}
+}

Scripts/Engines/Harvest/Core/HarvestVein.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace Server.Engines.Harvest
+{
+	public class HarvestVein
+	{
+		private double m_VeinChance;
+		private double m_ChanceToFallback;
+		private HarvestResource m_PrimaryResource;
+		private HarvestResource m_FallbackResource;
+
+		public double VeinChance{ get{ return m_VeinChance; } set{ m_VeinChance = value; } }
+		public double ChanceToFallback{ get{ return m_ChanceToFallback; } set{ m_ChanceToFallback = value; } }
+		public HarvestResource PrimaryResource{ get{ return m_PrimaryResource; } set{ m_PrimaryResource = value; } }
+		public HarvestResource FallbackResource{ get{ return m_FallbackResource; } set{ m_FallbackResource = value; } }
+
+		public HarvestVein( double veinChance, double chanceToFallback, HarvestResource primaryResource, HarvestResource fallbackResource )
+		{
+			m_VeinChance = veinChance;
+			m_ChanceToFallback = chanceToFallback;
+			m_PrimaryResource = primaryResource;
+			m_FallbackResource = fallbackResource;
+		}
+	}
+}

Scripts/Engines/Harvest/Fishing.cs

@@ -0,0 +1,570 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Server.Network;
+using Server.Engines.Quests;
+using Server.Engines.Quests.Collector;
+using System.Collections.Generic;
+
+namespace Server.Engines.Harvest
+{
+	public class Fishing : HarvestSystem
+	{
+		private static Fishing m_System;
+
+		public static Fishing System
+		{
+			get
+			{
+				if ( m_System == null )
+					m_System = new Fishing();
+
+				return m_System;
+			}
+		}
+
+		private HarvestDefinition m_Definition;
+
+		public HarvestDefinition Definition
+		{
+			get{ return m_Definition; }
+		}
+
+		private Fishing()
+		{
+			HarvestResource[] res;
+			HarvestVein[] veins;
+
+			#region Fishing
+			HarvestDefinition fish = new HarvestDefinition();
+
+			// Resource banks are every 8x8 tiles
+			fish.BankWidth = 8;
+			fish.BankHeight = 8;
+
+			// Every bank holds from 5 to 15 fish
+			fish.MinTotal = 5;
+			fish.MaxTotal = 15;
+
+			// A resource bank will respawn its content every 10 to 20 minutes
+			fish.MinRespawn = TimeSpan.FromMinutes( 10.0 );
+			fish.MaxRespawn = TimeSpan.FromMinutes( 20.0 );
+
+			// Skill checking is done on the Fishing skill
+			fish.Skill = SkillName.Fishing;
+
+			// Set the list of harvestable tiles
+			fish.Tiles = m_WaterTiles;
+			fish.RangedTiles = true;
+
+			// Players must be within 4 tiles to harvest
+			fish.MaxRange = 4;
+
+			// One fish per harvest action
+			fish.ConsumedPerHarvest = 1;
+			fish.ConsumedPerFeluccaHarvest = 1;
+
+			// The fishing
+			fish.EffectActions = new int[]{ 12 };
+			fish.EffectSounds = new int[0];
+			fish.EffectCounts = new int[]{ 1 };
+			fish.EffectDelay = TimeSpan.Zero;
+			fish.EffectSoundDelay = TimeSpan.FromSeconds( 8.0 );
+
+			fish.NoResourcesMessage = 503172; // The fish don't seem to be biting here.
+			fish.FailMessage = 503171; // You fish a while, but fail to catch anything.
+			fish.TimedOutOfRangeMessage = 500976; // You need to be closer to the water to fish!
+			fish.OutOfRangeMessage = 500976; // You need to be closer to the water to fish!
+			fish.PackFullMessage = 503176; // You do not have room in your backpack for a fish.
+			fish.ToolBrokeMessage = 503174; // You broke your fishing pole.
+
+			res = new HarvestResource[]
+				{
+					new HarvestResource( 00.0, 00.0, 100.0, 1043297, typeof( Fish ) )
+				};
+
+			veins = new HarvestVein[]
+				{
+					new HarvestVein( 100.0, 0.0, res[0], null )
+				};
+
+			fish.Resources = res;
+			fish.Veins = veins;
+
+			if ( Core.ML )
+			{
+				fish.BonusResources = new BonusHarvestResource[]
+				{
+					new BonusHarvestResource( 0, 99.4, null, null ), //set to same chance as mining ml gems
+					new BonusHarvestResource( 80.0, .6, 1072597, typeof( WhitePearl ) )
+				};
+			}
+
+			m_Definition = fish;
+			Definitions.Add( fish );
+			#endregion
+		}
+
+		public override void OnConcurrentHarvest( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			from.SendLocalizedMessage( 500972 ); // You are already fishing.
+		}
+
+		private class MutateEntry
+		{
+			public double m_ReqSkill, m_MinSkill, m_MaxSkill;
+			public bool m_DeepWater;
+			public Type[] m_Types;
+
+			public MutateEntry( double reqSkill, double minSkill, double maxSkill, bool deepWater, params Type[] types )
+			{
+				m_ReqSkill = reqSkill;
+				m_MinSkill = minSkill;
+				m_MaxSkill = maxSkill;
+				m_DeepWater = deepWater;
+				m_Types = types;
+			}
+		}
+
+		private static MutateEntry[] m_MutateTable = new MutateEntry[]
+			{
+				new MutateEntry(  80.0,  80.0,  4080.0,  true, typeof( SpecialFishingNet ) ),
+				new MutateEntry(  80.0,  80.0,  4080.0,  true, typeof( BigFish ) ),
+				new MutateEntry(  90.0,  80.0,  4080.0,  true, typeof( TreasureMap ) ),
+				new MutateEntry( 100.0,  80.0,  4080.0,  true, typeof( MessageInABottle ) ),
+				new MutateEntry(   0.0, 125.0, -2375.0, false, typeof( PrizedFish ), typeof( WondrousFish ), typeof( TrulyRareFish ), typeof( PeculiarFish ) ),
+				new MutateEntry(   0.0, 105.0,  -420.0, false, typeof( Boots ), typeof( Shoes ), typeof( Sandals ), typeof( ThighBoots ) ),
+				new MutateEntry(   0.0, 200.0,  -200.0, false, new Type[1]{ null } )
+			};
+
+		public override bool SpecialHarvest( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc )
+		{
+			PlayerMobile player = from as PlayerMobile;
+
+			if ( player != null )
+			{
+				QuestSystem qs = player.Quest;
+
+				if ( qs is CollectorQuest )
+				{
+					QuestObjective obj = qs.FindObjective( typeof( FishPearlsObjective ) );
+
+					if ( obj != null && !obj.Completed )
+					{
+						if ( Utility.RandomDouble() < 0.5 )
+						{
+							player.SendLocalizedMessage( 1055086, "", 0x59 ); // You pull a shellfish out of the water, and find a rainbow pearl inside of it.
+
+							obj.CurProgress++;
+						}
+						else
+						{
+							player.SendLocalizedMessage( 1055087, "", 0x2C ); // You pull a shellfish out of the water, but it doesn't have a rainbow pearl.
+						}
+
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
+		public override Type MutateType( Type type, Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, HarvestResource resource )
+		{
+			bool deepWater = SpecialFishingNet.FullValidation( map, loc.X, loc.Y );
+
+			double skillBase = from.Skills[SkillName.Fishing].Base;
+			double skillValue = from.Skills[SkillName.Fishing].Value;
+
+			for ( int i = 0; i < m_MutateTable.Length; ++i )
+			{
+				MutateEntry entry = m_MutateTable[i];
+
+				if ( !deepWater && entry.m_DeepWater )
+					continue;
+
+				if ( skillBase >= entry.m_ReqSkill )
+				{
+					double chance = (skillValue - entry.m_MinSkill) / (entry.m_MaxSkill - entry.m_MinSkill);
+
+					if ( chance > Utility.RandomDouble() )
+						return entry.m_Types[Utility.Random( entry.m_Types.Length )];
+				}
+			}
+
+			return type;
+		}
+
+		private static Map SafeMap( Map map )
+		{
+			if ( map == null || map == Map.Internal )
+				return Map.Trammel;
+
+			return map;
+		}
+
+		public override bool CheckResources( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, bool timed )
+		{
+			Container pack = from.Backpack;
+
+			if ( pack != null )
+			{
+				List<SOS> messages = pack.FindItemsByType<SOS>();
+
+				for ( int i = 0; i < messages.Count; ++i )
+				{
+					SOS sos = messages[i];
+
+					if ( ( from.Map == Map.Felucca || from.Map == Map.Trammel ) && from.InRange( sos.TargetLocation, 60 ) )
+						return true;
+				}
+			}
+
+			return base.CheckResources( from, tool, def, map, loc, timed );
+		}
+
+		public override Item Construct( Type type, Mobile from )
+		{
+			if ( type == typeof( TreasureMap ) )
+			{
+				int level;
+				if ( from is PlayerMobile && ((PlayerMobile)from).Young && from.Map == Map.Trammel && TreasureMap.IsInHavenIsland( from ) )
+					level = 0;
+				else
+					level = 1;
+
+				return new TreasureMap( level, from.Map == Map.Felucca ? Map.Felucca : Map.Trammel );
+			}
+			else if ( type == typeof( MessageInABottle ) )
+			{
+				return new MessageInABottle( from.Map == Map.Felucca ? Map.Felucca : Map.Trammel );
+			}
+
+			Container pack = from.Backpack;
+
+			if ( pack != null )
+			{
+				List<SOS> messages = pack.FindItemsByType<SOS>();
+
+				for ( int i = 0; i < messages.Count; ++i )
+				{
+					SOS sos = messages[i];
+
+					if ( ( from.Map == Map.Felucca || from.Map == Map.Trammel ) && from.InRange( sos.TargetLocation, 60 ) )
+					{
+						Item preLoot = null;
+
+						switch ( Utility.Random( 8 ) )
+						{
+							case 0: // Body parts
+							{
+								int[] list = new int[]
+									{
+										0x1CDD, 0x1CE5, // arm
+										0x1CE0, 0x1CE8, // torso
+										0x1CE1, 0x1CE9, // head
+										0x1CE2, 0x1CEC // leg
+									};
+
+								preLoot = new ShipwreckedItem( Utility.RandomList( list ) );
+								break;
+							}
+							case 1: // Bone parts
+							{
+								int[] list = new int[]
+									{
+										0x1AE0, 0x1AE1, 0x1AE2, 0x1AE3, 0x1AE4, // skulls
+										0x1B09, 0x1B0A, 0x1B0B, 0x1B0C, 0x1B0D, 0x1B0E, 0x1B0F, 0x1B10, // bone piles
+										0x1B15, 0x1B16 // pelvis bones
+									};
+
+								preLoot = new ShipwreckedItem( Utility.RandomList( list ) );
+								break;
+							}
+							case 2: // Paintings and portraits
+							{
+								preLoot = new ShipwreckedItem( Utility.Random( 0xE9F, 10 ) );
+								break;
+							}
+							case 3: // Pillows
+							{
+								preLoot = new ShipwreckedItem( Utility.Random( 0x13A4, 11 ) );
+								break;
+							}
+							case 4: // Shells
+							{
+								preLoot = new ShipwreckedItem( Utility.Random( 0xFC4, 9 ) );
+								break;
+							}
+							case 5:	//Hats
+							{
+								if ( Utility.RandomBool() )
+									preLoot = new SkullCap();
+								else
+									preLoot = new TricorneHat();
+
+								break;
+							}
+							case 6: // Misc
+							{
+								int[] list = new int[]
+									{
+										0x1EB5, // unfinished barrel
+										0xA2A, // stool
+										0xC1F, // broken clock
+										0x1047, 0x1048, // globe
+										0x1EB1, 0x1EB2, 0x1EB3, 0x1EB4 // barrel staves
+									};
+
+								if ( Utility.Random( list.Length + 1 ) == 0 )
+									preLoot = new Candelabra();
+								else
+									preLoot = new ShipwreckedItem( Utility.RandomList( list ) );
+
+								break;
+							}
+						}
+
+						if ( preLoot != null )
+						{
+							if ( preLoot is IShipwreckedItem )
+								( (IShipwreckedItem)preLoot ).IsShipwreckedItem = true;
+
+							return preLoot;
+						}
+
+						LockableContainer chest;
+						
+						if ( Utility.RandomBool() )
+							chest = new MetalGoldenChest();
+						else
+							chest = new WoodenChest();
+
+						if ( sos.IsAncient )
+							chest.Hue = 0x481;
+
+						TreasureMapChest.Fill( chest, Math.Max( 1, Math.Min( 4, sos.Level ) ) );
+
+						if ( sos.IsAncient )
+							chest.DropItem( new FabledFishingNet() );
+						else
+							chest.DropItem( new SpecialFishingNet() );
+
+						chest.Movable = true;
+						chest.Locked = false;
+						chest.TrapType = TrapType.None;
+						chest.TrapPower = 0;
+						chest.TrapLevel = 0;
+
+						sos.Delete();
+
+						return chest;
+					}
+				}
+			}
+
+			return base.Construct( type, from );
+		}
+
+		public override bool Give( Mobile m, Item item, bool placeAtFeet )
+		{
+			if ( item is TreasureMap || item is MessageInABottle || item is SpecialFishingNet )
+			{
+				BaseCreature serp;
+
+				if ( 0.25 > Utility.RandomDouble() )
+					serp = new DeepSeaSerpent();
+				else
+					serp = new SeaSerpent();
+
+				int x = m.X, y = m.Y;
+
+				Map map = m.Map;
+
+				for ( int i = 0; map != null && i < 20; ++i )
+				{
+					int tx = m.X - 10 + Utility.Random( 21 );
+					int ty = m.Y - 10 + Utility.Random( 21 );
+
+					LandTile t = map.Tiles.GetLandTile( tx, ty );
+
+					if ( t.Z == -5 && ( (t.ID >= 0xA8 && t.ID <= 0xAB) || (t.ID >= 0x136 && t.ID <= 0x137) ) && !Spells.SpellHelper.CheckMulti( new Point3D( tx, ty, -5 ), map ) )
+					{
+						x = tx;
+						y = ty;
+						break;
+					}
+				}
+
+				serp.MoveToWorld( new Point3D( x, y, -5 ), map );
+
+				serp.Home = serp.Location;
+				serp.RangeHome = 10;
+
+				serp.PackItem( item );
+
+				m.SendLocalizedMessage( 503170 ); // Uh oh! That doesn't look like a fish!
+
+				return true; // we don't want to give the item to the player, it's on the serpent
+			}
+
+			if ( item is BigFish || item is WoodenChest || item is MetalGoldenChest )
+				placeAtFeet = true;
+
+			return base.Give( m, item, placeAtFeet );
+		}
+
+		public override void SendSuccessTo( Mobile from, Item item, HarvestResource resource )
+		{
+			if ( item is BigFish )
+			{
+				from.SendLocalizedMessage( 1042635 ); // Your fishing pole bends as you pull a big fish from the depths!
+
+				((BigFish)item).Fisher = from;
+			}
+			else if ( item is WoodenChest || item is MetalGoldenChest )
+			{
+				from.SendLocalizedMessage( 503175 ); // You pull up a heavy chest from the depths of the ocean!
+			}
+			else
+			{
+				int number;
+				string name;
+
+				if ( item is BaseMagicFish )
+				{
+					number = 1008124;
+					name = "a mess of small fish";
+				}
+				else if ( item is Fish )
+				{
+					number = 1008124;
+					name = item.ItemData.Name;
+				}
+				else if ( item is BaseShoes )
+				{
+					number = 1008124;
+					name = item.ItemData.Name;
+				}
+				else if ( item is TreasureMap )
+				{
+					number = 1008125;
+					name = "a sodden piece of parchment";
+				}
+				else if ( item is MessageInABottle )
+				{
+					number = 1008125;
+					name = "a bottle, with a message in it";
+				}
+				else if ( item is SpecialFishingNet )
+				{
+					number = 1008125;
+					name = "a special fishing net"; // TODO: this is just a guess--what should it really be named?
+				}
+				else
+				{
+					number = 1043297;
+
+					if ( (item.ItemData.Flags & TileFlag.ArticleA) != 0 )
+						name = "a " + item.ItemData.Name;
+					else if ( (item.ItemData.Flags & TileFlag.ArticleAn) != 0 )
+						name = "an " + item.ItemData.Name;
+					else
+						name = item.ItemData.Name;
+				}
+
+				NetState ns = from.NetState;
+
+				if ( ns == null )
+					return;
+
+				if ( number == 1043297 || ns.HighSeas )
+					from.SendLocalizedMessage( number, name );
+				else
+					from.SendLocalizedMessage( number, true, name );
+			}
+		}
+
+		public override void OnHarvestStarted( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			base.OnHarvestStarted( from, tool, def, toHarvest );
+
+			int tileID;
+			Map map;
+			Point3D loc;
+
+			if ( GetHarvestDetails( from, tool, toHarvest, out tileID, out map, out loc ) )
+				Timer.DelayCall( TimeSpan.FromSeconds( 1.5 ), 
+					delegate
+					{
+						if( Core.ML )
+							from.RevealingAction();
+
+						Effects.SendLocationEffect( loc, map, 0x352D, 16, 4 );
+						Effects.PlaySound( loc, map, 0x364 );
+					} );
+		}
+
+		public override void OnHarvestFinished( Mobile from, Item tool, HarvestDefinition def, HarvestVein vein, HarvestBank bank, HarvestResource resource, object harvested )
+		{
+			base.OnHarvestFinished( from, tool, def, vein, bank, resource, harvested );
+
+			if ( Core.ML )
+				from.RevealingAction();
+		}
+
+		public override object GetLock( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			return this;
+		}
+
+		public override bool BeginHarvesting( Mobile from, Item tool )
+		{
+			if ( !base.BeginHarvesting( from, tool ) )
+				return false;
+
+			from.SendLocalizedMessage( 500974 ); // What water do you want to fish in?
+			return true;
+		}
+
+		public override bool CheckHarvest( Mobile from, Item tool )
+		{
+			if ( !base.CheckHarvest( from, tool ) )
+				return false;
+
+			if ( from.Mounted )
+			{
+				from.SendLocalizedMessage( 500971 ); // You can't fish while riding!
+				return false;
+			}
+
+			return true;
+		}
+
+		public override bool CheckHarvest( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			if ( !base.CheckHarvest( from, tool, def, toHarvest ) )
+				return false;
+
+			if ( from.Mounted )
+			{
+				from.SendLocalizedMessage( 500971 ); // You can't fish while riding!
+				return false;
+			}
+
+			return true;
+		}
+
+		private static int[] m_WaterTiles = new int[]
+			{
+				0x00A8, 0x00AB,
+				0x0136, 0x0137,
+				0x5797, 0x579C,
+				0x746E, 0x7485,
+				0x7490, 0x74AB,
+				0x74B5, 0x75D5
+			};
+	}
+}

Scripts/Engines/Harvest/Lumberjacking.cs

@@ -0,0 +1,215 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Engines.Harvest
+{
+	public class Lumberjacking : HarvestSystem
+	{
+		private static Lumberjacking m_System;
+
+		public static Lumberjacking System
+		{
+			get
+			{
+				if ( m_System == null )
+					m_System = new Lumberjacking();
+
+				return m_System;
+			}
+		}
+
+		private HarvestDefinition m_Definition;
+
+		public HarvestDefinition Definition
+		{
+			get{ return m_Definition; }
+		}
+
+		private Lumberjacking()
+		{
+			HarvestResource[] res;
+			HarvestVein[] veins;
+
+			#region Lumberjacking
+			HarvestDefinition lumber = new HarvestDefinition();
+
+			// Resource banks are every 4x3 tiles
+			lumber.BankWidth = 4;
+			lumber.BankHeight = 3;
+
+			// Every bank holds from 20 to 45 logs
+			lumber.MinTotal = 20;
+			lumber.MaxTotal = 45;
+
+			// A resource bank will respawn its content every 20 to 30 minutes
+			lumber.MinRespawn = TimeSpan.FromMinutes( 20.0 );
+			lumber.MaxRespawn = TimeSpan.FromMinutes( 30.0 );
+
+			// Skill checking is done on the Lumberjacking skill
+			lumber.Skill = SkillName.Lumberjacking;
+
+			// Set the list of harvestable tiles
+			lumber.Tiles = m_TreeTiles;
+
+			// Players must be within 2 tiles to harvest
+			lumber.MaxRange = 2;
+
+			// Ten logs per harvest action
+			lumber.ConsumedPerHarvest = 10;
+			lumber.ConsumedPerFeluccaHarvest = 20;
+
+			// The chopping effect
+			lumber.EffectActions = new int[]{ 13 };
+			lumber.EffectSounds = new int[]{ 0x13E };
+			lumber.EffectCounts = (Core.AOS ? new int[]{ 1 } : new int[]{ 1, 2, 2, 2, 3 });
+			lumber.EffectDelay = TimeSpan.FromSeconds( 1.6 );
+			lumber.EffectSoundDelay = TimeSpan.FromSeconds( 0.9 );
+
+			lumber.NoResourcesMessage = 500493; // There's not enough wood here to harvest.
+			lumber.FailMessage = 500495; // You hack at the tree for a while, but fail to produce any useable wood.
+			lumber.OutOfRangeMessage = 500446; // That is too far away.
+			lumber.PackFullMessage = 500497; // You can't place any wood into your backpack!
+			lumber.ToolBrokeMessage = 500499; // You broke your axe.
+
+			if ( Core.ML )
+			{
+				res = new HarvestResource[]
+				{
+					new HarvestResource(  00.0, 00.0, 100.0, 1072540, typeof( Log ) ),
+					new HarvestResource(  65.0, 25.0, 105.0, 1072541, typeof( OakLog ) ),
+					new HarvestResource(  80.0, 40.0, 120.0, 1072542, typeof( AshLog ) ),
+					new HarvestResource(  95.0, 55.0, 135.0, 1072543, typeof( YewLog ) ),
+					new HarvestResource( 100.0, 60.0, 140.0, 1072544, typeof( HeartwoodLog ) ),
+					new HarvestResource( 100.0, 60.0, 140.0, 1072545, typeof( BloodwoodLog ) ),
+					new HarvestResource( 100.0, 60.0, 140.0, 1072546, typeof( FrostwoodLog ) ),
+				};
+
+
+				veins = new HarvestVein[]
+				{
+					new HarvestVein( 49.0, 0.0, res[0], null ),	// Ordinary Logs
+					new HarvestVein( 30.0, 0.5, res[1], res[0] ), // Oak
+					new HarvestVein( 10.0, 0.5, res[2], res[0] ), // Ash
+					new HarvestVein( 05.0, 0.5, res[3], res[0] ), // Yew
+					new HarvestVein( 03.0, 0.5, res[4], res[0] ), // Heartwood
+					new HarvestVein( 02.0, 0.5, res[5], res[0] ), // Bloodwood
+					new HarvestVein( 01.0, 0.5, res[6], res[0] ), // Frostwood
+				};
+
+				lumber.BonusResources = new BonusHarvestResource[]
+				{
+					new BonusHarvestResource( 0, 83.9, null, null ),	//Nothing
+					new BonusHarvestResource( 100, 10.0, 1072548, typeof( BarkFragment ) ),
+					new BonusHarvestResource( 100, 03.0, 1072550, typeof( LuminescentFungi ) ),
+					new BonusHarvestResource( 100, 02.0, 1072547, typeof( SwitchItem ) ),
+					new BonusHarvestResource( 100, 01.0, 1072549, typeof( ParasiticPlant ) ),
+					new BonusHarvestResource( 100, 00.1, 1072551, typeof( BrilliantAmber ) )
+				};
+			}
+			else
+			{
+				res = new HarvestResource[]
+				{
+					new HarvestResource( 00.0, 00.0, 100.0, 500498, typeof( Log ) )
+				};
+
+				veins = new HarvestVein[]
+				{
+					new HarvestVein( 100.0, 0.0, res[0], null )
+				};
+			}
+
+			lumber.Resources = res;
+			lumber.Veins = veins;
+
+			lumber.RaceBonus = Core.ML;
+			lumber.RandomizeVeins = Core.ML;
+
+			m_Definition = lumber;
+			Definitions.Add( lumber );
+			#endregion
+		}
+
+		public override bool CheckHarvest( Mobile from, Item tool )
+		{
+			if ( !base.CheckHarvest( from, tool ) )
+				return false;
+
+			if ( tool.Parent != from )
+			{
+				from.SendLocalizedMessage( 500487 ); // The axe must be equipped for any serious wood chopping.
+				return false;
+			}
+
+			return true;
+		}
+
+		public override bool CheckHarvest( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			if ( !base.CheckHarvest( from, tool, def, toHarvest ) )
+				return false;
+
+			if ( tool.Parent != from )
+			{
+				from.SendLocalizedMessage( 500487 ); // The axe must be equipped for any serious wood chopping.
+				return false;
+			}
+
+			return true;
+		}
+
+		public override void OnBadHarvestTarget( Mobile from, Item tool, object toHarvest )
+		{
+			if ( toHarvest is Mobile )
+				( (Mobile)toHarvest ).PrivateOverheadMessage( MessageType.Regular, 0x3B2, 500450, from.NetState ); // You can only skin dead creatures.
+			else if ( toHarvest is Item )
+				( (Item)toHarvest ).LabelTo( from, 500464 ); // Use this on corpses to carve away meat and hide
+			else if ( toHarvest is Targeting.StaticTarget || toHarvest is Targeting.LandTarget )
+				from.SendLocalizedMessage( 500489 ); // You can't use an axe on that.
+			else
+				from.SendLocalizedMessage( 1005213 ); // You can't do that
+		}
+
+		public override void OnHarvestStarted( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			base.OnHarvestStarted( from, tool, def, toHarvest );
+			
+			if( Core.ML )
+				from.RevealingAction();
+		}
+
+		public static void Initialize()
+		{
+			Array.Sort( m_TreeTiles );
+		}
+
+		#region Tile lists
+		private static int[] m_TreeTiles = new int[]
+			{
+				0x4CCA, 0x4CCB, 0x4CCC, 0x4CCD, 0x4CD0, 0x4CD3, 0x4CD6, 0x4CD8,
+				0x4CDA, 0x4CDD, 0x4CE0, 0x4CE3, 0x4CE6, 0x4CF8, 0x4CFB, 0x4CFE,
+				0x4D01, 0x4D41, 0x4D42, 0x4D43, 0x4D44, 0x4D57, 0x4D58, 0x4D59,
+				0x4D5A, 0x4D5B, 0x4D6E, 0x4D6F, 0x4D70, 0x4D71, 0x4D72, 0x4D84,
+				0x4D85, 0x4D86, 0x52B5, 0x52B6, 0x52B7, 0x52B8, 0x52B9, 0x52BA,
+				0x52BB, 0x52BC, 0x52BD,
+
+				0x4CCE, 0x4CCF, 0x4CD1, 0x4CD2, 0x4CD4, 0x4CD5, 0x4CD7, 0x4CD9,
+				0x4CDB, 0x4CDC, 0x4CDE, 0x4CDF, 0x4CE1, 0x4CE2, 0x4CE4, 0x4CE5,
+				0x4CE7, 0x4CE8, 0x4CF9, 0x4CFA, 0x4CFC, 0x4CFD, 0x4CFF, 0x4D00,
+				0x4D02, 0x4D03, 0x4D45, 0x4D46, 0x4D47, 0x4D48, 0x4D49, 0x4D4A,
+				0x4D4B, 0x4D4C, 0x4D4D, 0x4D4E, 0x4D4F, 0x4D50, 0x4D51, 0x4D52,
+				0x4D53, 0x4D5C, 0x4D5D, 0x4D5E, 0x4D5F, 0x4D60, 0x4D61, 0x4D62,
+				0x4D63, 0x4D64, 0x4D65, 0x4D66, 0x4D67, 0x4D68, 0x4D69, 0x4D73,
+				0x4D74, 0x4D75, 0x4D76, 0x4D77, 0x4D78, 0x4D79, 0x4D7A, 0x4D7B,
+				0x4D7C, 0x4D7D, 0x4D7E, 0x4D7F, 0x4D87, 0x4D88, 0x4D89, 0x4D8A,
+				0x4D8B, 0x4D8C, 0x4D8D, 0x4D8E, 0x4D8F, 0x4D90, 0x4D95, 0x4D96,
+				0x4D97, 0x4D99, 0x4D9A, 0x4D9B, 0x4D9D, 0x4D9E, 0x4D9F, 0x4DA1,
+				0x4DA2, 0x4DA3, 0x4DA5, 0x4DA6, 0x4DA7, 0x4DA9, 0x4DAA, 0x4DAB,
+				0x52BE, 0x52BF, 0x52C0, 0x52C1, 0x52C2, 0x52C3, 0x52C4, 0x52C5,
+				0x52C6, 0x52C7
+			};
+		#endregion
+	}
+}

Scripts/Engines/Harvest/Mining.cs

@@ -0,0 +1,433 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Server.Targeting;
+
+namespace Server.Engines.Harvest
+{
+	public class Mining : HarvestSystem
+	{
+		private static Mining m_System;
+
+		public static Mining System
+		{
+			get
+			{
+				if ( m_System == null )
+					m_System = new Mining();
+
+				return m_System;
+			}
+		}
+
+		private HarvestDefinition m_OreAndStone, m_Sand;
+
+		public HarvestDefinition OreAndStone
+		{
+			get{ return m_OreAndStone; }
+		}
+
+		public HarvestDefinition Sand
+		{
+			get{ return m_Sand; }
+		}
+
+		private Mining()
+		{
+			HarvestResource[] res;
+			HarvestVein[] veins;
+
+			#region Mining for ore and stone
+			HarvestDefinition oreAndStone = m_OreAndStone = new HarvestDefinition();
+
+			// Resource banks are every 8x8 tiles
+			oreAndStone.BankWidth = 8;
+			oreAndStone.BankHeight = 8;
+
+			// Every bank holds from 10 to 34 ore
+			oreAndStone.MinTotal = 10;
+			oreAndStone.MaxTotal = 34;
+
+			// A resource bank will respawn its content every 10 to 20 minutes
+			oreAndStone.MinRespawn = TimeSpan.FromMinutes( 10.0 );
+			oreAndStone.MaxRespawn = TimeSpan.FromMinutes( 20.0 );
+
+			// Skill checking is done on the Mining skill
+			oreAndStone.Skill = SkillName.Mining;
+
+			// Set the list of harvestable tiles
+			oreAndStone.Tiles = m_MountainAndCaveTiles;
+
+			// Players must be within 2 tiles to harvest
+			oreAndStone.MaxRange = 2;
+
+			// One ore per harvest action
+			oreAndStone.ConsumedPerHarvest = 1;
+			oreAndStone.ConsumedPerFeluccaHarvest = 2;
+
+			// The digging effect
+			oreAndStone.EffectActions = new int[]{ 11 };
+			oreAndStone.EffectSounds = new int[]{ 0x125, 0x126 };
+			oreAndStone.EffectCounts = new int[]{ 1 };
+			oreAndStone.EffectDelay = TimeSpan.FromSeconds( 1.6 );
+			oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds( 0.9 );
+
+			oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine.
+			oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you.
+			oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
+			oreAndStone.OutOfRangeMessage = 500446; // That is too far away.
+			oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore.
+			oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost.
+			oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool!
+
+			res = new HarvestResource[]
+				{
+					new HarvestResource( 00.0, 00.0, 100.0, 1007072, typeof( IronOre ),			typeof( Granite ) ),
+					new HarvestResource( 65.0, 25.0, 105.0, 1007073, typeof( DullCopperOre ),	typeof( DullCopperGranite ),	typeof( DullCopperElemental ) ),
+					new HarvestResource( 70.0, 30.0, 110.0, 1007074, typeof( ShadowIronOre ),	typeof( ShadowIronGranite ),	typeof( ShadowIronElemental ) ),
+					new HarvestResource( 75.0, 35.0, 115.0, 1007075, typeof( CopperOre ),		typeof( CopperGranite ),		typeof( CopperElemental ) ),
+					new HarvestResource( 80.0, 40.0, 120.0, 1007076, typeof( BronzeOre ),		typeof( BronzeGranite ),		typeof( BronzeElemental ) ),
+					new HarvestResource( 85.0, 45.0, 125.0, 1007077, typeof( GoldOre ),			typeof( GoldGranite ),			typeof( GoldenElemental ) ),
+					new HarvestResource( 90.0, 50.0, 130.0, 1007078, typeof( AgapiteOre ),		typeof( AgapiteGranite ),		typeof( AgapiteElemental ) ),
+					new HarvestResource( 95.0, 55.0, 135.0, 1007079, typeof( VeriteOre ),		typeof( VeriteGranite ),		typeof( VeriteElemental ) ),
+					new HarvestResource( 99.0, 59.0, 139.0, 1007080, typeof( ValoriteOre ),		typeof( ValoriteGranite ),		typeof( ValoriteElemental ) )
+				};
+
+			veins = new HarvestVein[]
+				{
+					new HarvestVein( 49.6, 0.0, res[0], null   ), // Iron
+					new HarvestVein( 11.2, 0.5, res[1], res[0] ), // Dull Copper
+					new HarvestVein( 09.8, 0.5, res[2], res[0] ), // Shadow Iron
+					new HarvestVein( 08.4, 0.5, res[3], res[0] ), // Copper
+					new HarvestVein( 07.0, 0.5, res[4], res[0] ), // Bronze
+					new HarvestVein( 05.6, 0.5, res[5], res[0] ), // Gold
+					new HarvestVein( 04.2, 0.5, res[6], res[0] ), // Agapite
+					new HarvestVein( 02.8, 0.5, res[7], res[0] ), // Verite
+					new HarvestVein( 01.4, 0.5, res[8], res[0] )  // Valorite
+				};
+
+			oreAndStone.Resources = res;
+			oreAndStone.Veins = veins;
+
+			if ( Core.ML )
+			{
+				oreAndStone.BonusResources = new BonusHarvestResource[]
+				{
+					new BonusHarvestResource( 0, 99.4, null, null ),	//Nothing
+					new BonusHarvestResource( 100, .1, 1072562, typeof( BlueDiamond ) ),
+					new BonusHarvestResource( 100, .1, 1072567, typeof( DarkSapphire ) ),
+					new BonusHarvestResource( 100, .1, 1072570, typeof( EcruCitrine ) ),
+					new BonusHarvestResource( 100, .1, 1072564, typeof( FireRuby ) ),
+					new BonusHarvestResource( 100, .1, 1072566, typeof( PerfectEmerald ) ),
+					new BonusHarvestResource( 100, .1, 1072568, typeof( Turquoise ) )
+				};
+			}
+
+			oreAndStone.RaceBonus = Core.ML;
+			oreAndStone.RandomizeVeins = Core.ML;
+
+			Definitions.Add( oreAndStone );
+			#endregion
+
+			#region Mining for sand
+			HarvestDefinition sand = m_Sand = new HarvestDefinition();
+
+			// Resource banks are every 8x8 tiles
+			sand.BankWidth = 8;
+			sand.BankHeight = 8;
+
+			// Every bank holds from 6 to 12 sand
+			sand.MinTotal = 6;
+			sand.MaxTotal = 12;
+
+			// A resource bank will respawn its content every 10 to 20 minutes
+			sand.MinRespawn = TimeSpan.FromMinutes( 10.0 );
+			sand.MaxRespawn = TimeSpan.FromMinutes( 20.0 );
+
+			// Skill checking is done on the Mining skill
+			sand.Skill = SkillName.Mining;
+
+			// Set the list of harvestable tiles
+			sand.Tiles = m_SandTiles;
+
+			// Players must be within 2 tiles to harvest
+			sand.MaxRange = 2;
+
+			// One sand per harvest action
+			sand.ConsumedPerHarvest = 1;
+			sand.ConsumedPerFeluccaHarvest = 1;
+
+			// The digging effect
+			sand.EffectActions = new int[]{ 11 };
+			sand.EffectSounds = new int[]{ 0x125, 0x126 };
+			sand.EffectCounts = new int[]{ 6 };
+			sand.EffectDelay = TimeSpan.FromSeconds( 1.6 );
+			sand.EffectSoundDelay = TimeSpan.FromSeconds( 0.9 );
+
+			sand.NoResourcesMessage = 1044629; // There is no sand here to mine.
+			sand.DoubleHarvestMessage = 1044629; // There is no sand here to mine.
+			sand.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining.
+			sand.OutOfRangeMessage = 500446; // That is too far away.
+			sand.FailMessage = 1044630; // You dig for a while but fail to find any of sufficient quality for glassblowing.
+			sand.PackFullMessage = 1044632; // Your backpack can't hold the sand, and it is lost!
+			sand.ToolBrokeMessage = 1044038; // You have worn out your tool!
+
+			res = new HarvestResource[]
+				{
+					new HarvestResource( 100.0, 70.0, 400.0, 1044631, typeof( Sand ) )
+				};
+
+			veins = new HarvestVein[]
+				{
+					new HarvestVein( 100.0, 0.0, res[0], null )
+				};
+
+			sand.Resources = res;
+			sand.Veins = veins;
+
+			Definitions.Add( sand );
+			#endregion
+		}
+
+		public override Type GetResourceType( Mobile from, Item tool, HarvestDefinition def, Map map, Point3D loc, HarvestResource resource )
+		{
+			if ( def == m_OreAndStone )
+			{
+				PlayerMobile pm = from as PlayerMobile;
+				if ( pm != null && pm.StoneMining && pm.ToggleMiningStone && from.Skills[SkillName.Mining].Base >= 100.0 && 0.1 > Utility.RandomDouble() )
+					return resource.Types[1];
+
+				return resource.Types[0];
+			}
+
+			return base.GetResourceType( from, tool, def, map, loc, resource );
+		}
+
+		public override bool CheckHarvest( Mobile from, Item tool )
+		{
+			if ( !base.CheckHarvest( from, tool ) )
+				return false;
+
+			if ( from.Mounted )
+			{
+				from.SendLocalizedMessage( 501864 ); // You can't mine while riding.
+				return false;
+			}
+			else if ( from.IsBodyMod && !from.Body.IsHuman )
+			{
+				from.SendLocalizedMessage( 501865 ); // You can't mine while polymorphed.
+				return false;
+			}
+
+			return true;
+		}
+
+		public override void SendSuccessTo( Mobile from, Item item, HarvestResource resource )
+		{
+			if ( item is BaseGranite )
+				from.SendLocalizedMessage( 1044606 ); // You carefully extract some workable stone from the ore vein!
+			else
+				base.SendSuccessTo( from, item, resource );
+		}
+
+		public override bool CheckHarvest( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			if ( !base.CheckHarvest( from, tool, def, toHarvest ) )
+				return false;
+
+			if ( def == m_Sand && !(from is PlayerMobile && from.Skills[SkillName.Mining].Base >= 100.0 && ((PlayerMobile)from).SandMining) )
+			{
+				OnBadHarvestTarget( from, tool, toHarvest );
+				return false;
+			}
+			else if ( from.Mounted )
+			{
+				from.SendLocalizedMessage( 501864 ); // You can't mine while riding.
+				return false;
+			}
+			else if ( from.IsBodyMod && !from.Body.IsHuman )
+			{
+				from.SendLocalizedMessage( 501865 ); // You can't mine while polymorphed.
+				return false;
+			}
+
+			return true;
+		}
+
+		public override HarvestVein MutateVein( Mobile from, Item tool, HarvestDefinition def, HarvestBank bank, object toHarvest, HarvestVein vein )
+		{
+			if ( tool is GargoylesPickaxe && def == m_OreAndStone )
+			{
+				int veinIndex = Array.IndexOf( def.Veins, vein );
+
+				if ( veinIndex >= 0 && veinIndex < (def.Veins.Length - 1) )
+					return def.Veins[veinIndex + 1];
+			}
+
+			return base.MutateVein( from, tool, def, bank, toHarvest, vein );
+		}
+
+		private static int[] m_Offsets = new int[]
+			{
+				-1, -1,
+				-1,  0,
+				-1,  1,
+				 0, -1,
+				 0,  1,
+				 1, -1,
+				 1,  0,
+				 1,  1
+			};
+
+		public override void OnHarvestFinished( Mobile from, Item tool, HarvestDefinition def, HarvestVein vein, HarvestBank bank, HarvestResource resource, object harvested )
+		{
+			if ( tool is GargoylesPickaxe && def == m_OreAndStone && 0.1 > Utility.RandomDouble() )
+			{
+				HarvestResource res = vein.PrimaryResource;
+
+				if ( res == resource && res.Types.Length >= 3 )
+				{
+					try
+					{
+						Map map = from.Map;
+
+						if ( map == null )
+							return;
+
+						BaseCreature spawned = Activator.CreateInstance( res.Types[2], new object[]{ 25 } ) as BaseCreature;
+
+						if ( spawned != null )
+						{
+							int offset = Utility.Random( 8 ) * 2;
+
+							for ( int i = 0; i < m_Offsets.Length; i += 2 )
+							{
+								int x = from.X + m_Offsets[(offset + i) % m_Offsets.Length];
+								int y = from.Y + m_Offsets[(offset + i + 1) % m_Offsets.Length];
+
+								if ( map.CanSpawnMobile( x, y, from.Z ) )
+								{
+									spawned.OnBeforeSpawn( new Point3D( x, y, from.Z ), map );
+									spawned.MoveToWorld( new Point3D( x, y, from.Z ), map );
+									spawned.Combatant = from;
+									return;
+								}
+								else
+								{
+									int z = map.GetAverageZ( x, y );
+
+									if ( Math.Abs( z - from.Z ) < 10 && map.CanSpawnMobile( x, y, z ) )
+									{
+										spawned.OnBeforeSpawn( new Point3D( x, y, z ), map );
+										spawned.MoveToWorld( new Point3D( x, y, z ), map );
+										spawned.Combatant = from;
+										return;
+									}
+								}
+							}
+
+							spawned.OnBeforeSpawn( from.Location, from.Map );
+							spawned.MoveToWorld( from.Location, from.Map );
+							spawned.Combatant = from;
+						}
+					}
+					catch
+					{
+					}
+				}
+			}
+		}
+
+		public override bool BeginHarvesting( Mobile from, Item tool )
+		{
+			if ( !base.BeginHarvesting( from, tool ) )
+				return false;
+
+			from.SendLocalizedMessage( 503033 ); // Where do you wish to dig?
+			return true;
+		}
+
+		public override void OnHarvestStarted( Mobile from, Item tool, HarvestDefinition def, object toHarvest )
+		{
+			base.OnHarvestStarted( from, tool, def, toHarvest );
+
+			if ( Core.ML )
+				from.RevealingAction();
+		}
+
+		public override void OnBadHarvestTarget( Mobile from, Item tool, object toHarvest )
+		{
+			if ( toHarvest is LandTarget )
+				from.SendLocalizedMessage( 501862 ); // You can't mine there.
+			else
+				from.SendLocalizedMessage( 501863 ); // You can't mine that.
+		}
+
+		#region Tile lists
+		private static int[] m_MountainAndCaveTiles = new int[]
+			{
+				220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
+				230, 231, 236, 237, 238, 239, 240, 241, 242, 243,
+				244, 245, 246, 247, 252, 253, 254, 255, 256, 257,
+				258, 259, 260, 261, 262, 263, 268, 269, 270, 271,
+				272, 273, 274, 275, 276, 277, 278, 279, 286, 287,
+				288, 289, 290, 291, 292, 293, 294, 296, 296, 297,
+				321, 322, 323, 324, 467, 468, 469, 470, 471, 472,
+				473, 474, 476, 477, 478, 479, 480, 481, 482, 483,
+				484, 485, 486, 487, 492, 493, 494, 495, 543, 544,
+				545, 546, 547, 548, 549, 550, 551, 552, 553, 554,
+				555, 556, 557, 558, 559, 560, 561, 562, 563, 564,
+				565, 566, 567, 568, 569, 570, 571, 572, 573, 574,
+				575, 576, 577, 578, 579, 581, 582, 583, 584, 585,
+				586, 587, 588, 589, 590, 591, 592, 593, 594, 595,
+				596, 597, 598, 599, 600, 601, 610, 611, 612, 613,
+
+				1010, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749,
+				1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1771, 1772,
+				1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782,
+				1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1801, 1802,
+				1803, 1804, 1805, 1806, 1807, 1808, 1809, 1811, 1812, 1813,
+				1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823,
+				1824, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839,
+				1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849,
+				1850, 1851, 1852, 1853, 1854, 1861, 1862, 1863, 1864, 1865,
+				1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875,
+				1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1981,
+				1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991,
+				1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+				2002, 2003, 2004, 2028, 2029, 2030, 2031, 2032, 2033, 2100,
+				2101, 2102, 2103, 2104, 2105,
+
+				0x453B, 0x453C, 0x453D, 0x453E, 0x453F, 0x4540, 0x4541,
+				0x4542, 0x4543, 0x4544,	0x4545, 0x4546, 0x4547, 0x4548,
+				0x4549, 0x454A, 0x454B, 0x454C, 0x454D, 0x454E,	0x454F
+			};
+
+		private static int[] m_SandTiles = new int[]
+			{
+				22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+				32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+				42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+				52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+				62, 68, 69, 70, 71, 72, 73, 74, 75,
+
+				286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
+				296, 297, 298, 299, 300, 301, 402, 424, 425, 426,
+				427, 441, 442, 443, 444, 445, 446, 447, 448, 449,
+				450, 451, 452, 453, 454, 455, 456, 457, 458, 459,
+				460, 461, 462, 463, 464, 465, 642, 643, 644, 645,
+				650, 651, 652, 653, 654, 655, 656, 657, 821, 822,
+				823, 824, 825, 826, 827, 828, 833, 834, 835, 836,
+				845, 846, 847, 848, 849, 850, 851, 852, 857, 858,
+				859, 860, 951, 952, 953, 954, 955, 956, 957, 958,
+				967, 968, 969, 970,
+
+				1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455,
+				1456, 1457, 1458, 1611, 1612, 1613, 1614, 1615, 1616,
+				1617, 1618, 1623, 1624, 1625, 1626, 1635, 1636, 1637,
+				1638, 1639, 1640, 1641, 1642, 1647, 1648, 1649, 1650
+			};
+		#endregion
+	}
+}