public CraftShopRegion( XmlElement xml, Map map, Region parent )
     : base(xml, map, parent)
 {
     int skill = 0;
     ReadInt32( xml, "skill", ref skill, true );
     m_Skills = (CraftSkillType)skill;
 }

		public static bool CanSpawn( Region region, params Type[] types )
		{
			while ( region != null )
			{
				if ( !region.AllowSpawn() )
					return false;

				BaseRegion br = region as BaseRegion;

				if ( br != null )
				{
					if ( br.Spawns != null )
					{
						for ( int i = 0; i < br.Spawns.Length; i++ )
						{
							SpawnEntry entry = br.Spawns[i];

							if ( entry.Definition.CanSpawn( types ) )
								return true;
						}
					}

					if ( br.ExcludeFromParentSpawns )
						return false;
				}

				region = region.Parent;
			}

			return false;
		}

		public QuestCompleteObjectiveRegion( XmlElement xml, Map map, Region parent ) : base( xml, map, parent )
		{
			XmlElement questEl = xml["quest"];

			ReadType( questEl, "type", ref m_Quest );
			ReadType( questEl, "complete", ref m_Objective );
		}

		public CampfireRegion( Campfire campfire, Region existingRegion ) : base( "", "", campfire.Map )
		{
			Priority = Region.HousePriority;
			LoadFromXml = false;
			m_Campfire = campfire;
			m_ExistingRegion = existingRegion;
		}

        public GuardedRegion( XmlElement xml, Map map, Region parent )
            : base(xml, map, parent)
        {
            XmlElement el = xml["guards"];

            if ( ReadType( el, "type", ref m_GuardType, false ) )
            {
                if ( !typeof( Mobile ).IsAssignableFrom( m_GuardType ) )
                {
                    Console.WriteLine( "Invalid guard type for region '{0}'", this );
                    m_GuardType = DefaultGuardType;
                }
            }
            else
            {
                m_GuardType = DefaultGuardType;
            }

            bool disabled = false;
            if ( ReadBoolean( el, "disabled", ref disabled, false ) )
                this.Disabled = disabled;

            if ( Name != null )
                RuneName = String.Format( "the city of {0}", Name );
        }

 public static bool RegionContains(Region region, Mobile m)
 {
     #if(RunUO_1_Final)
         return region.Mobiles.Contains(m);
     #elif(RunUO_2_RC1)
         return region.GetMobiles().Contains(m);
     #endif
 }

		public QuestNoEntryRegion( XmlElement xml, Map map, Region parent ) : base( xml, map, parent )
		{
			XmlElement questEl = xml["quest"];

			ReadType( questEl, "type", ref m_Quest );
			ReadType( questEl, "min", ref m_MinObjective, false );
			ReadType( questEl, "max", ref m_MaxObjective, false );
			ReadInt32( questEl, "message", ref m_Message, false );
		}

		public DungeonRegion( XmlElement xml, Map map, Region parent ) : base( xml, map, parent )
		{
			XmlElement entrEl = xml["entrance"];

			Map entrMap = map;
			ReadMap( entrEl, "map", ref entrMap, false );

			if ( ReadPoint3D( entrEl, entrMap, ref m_EntranceLocation, false ) )
				m_EntranceMap = entrMap;
		}

        public static void ShowRegionBounds(Region r, Mobile from, bool control, bool active)
        {
            if (r == null)
                return;

            foreach (Rectangle3D rect in r.Area)
            {
                ShowRectBounds(rect, r.Map, from, control, active);
            }
        }

		public static bool IsMLRegion( Region region )
		{
			return region.IsPartOf( "Twisted Weald" )
				|| region.IsPartOf( "Sanctuary" )
				|| region.IsPartOf( "The Prism of Light" )
				|| region.IsPartOf( "The Citadel" )
				|| region.IsPartOf( "Bedlam" )
				|| region.IsPartOf( "Blighted Grove" )
				|| region.IsPartOf( "The Painted Caves" )
				|| region.IsPartOf( "The Palace of Paroxysmus" )
				|| region.IsPartOf( "Labyrinth" );
		}

		//----------------------------------------------------------------------
		//
		//----------------------------------------------------------------------
		public static string RegionCategory( Region currentRegion )
		{
			string str;

			if( currentRegion is GuardedRegion ) { str = "Guarded"; }
			else if( currentRegion is HouseRegion ) { str = "House"; }
			else if( currentRegion is DungeonRegion ) { str = "Dungeon"; }
			else if( currentRegion is Jail ) { str = "Jail"; }
			else if( currentRegion is GreenAcres ) { str = "GreenAcres"; }
			else { str = "Wilderness"; }

			return str;
		}

        public static void ShowRegionBounds( Region r )
        {
            if( r == null || r.Coords == null || r.Coords.Count == 0)
                return;

            ArrayList c = r.Coords;

            for( int i = 0; i < c.Count; i++ )
            {
                if( c[i] is Rectangle2D )
                    ShowRectBounds( (Rectangle2D)c[i], r.Map );
            }
        }

		public static LootCollection GetRegionCollection( Type type, Region region )
		{
			if ( region is BaseRegion )
			{
				LootCollection coll;

				((BaseRegion)region).LootTable.TryGetValue( type, out coll );

				return coll;
			}

			return null;
		}

		public static string GetRuneNameFor( Region region )
		{
			while ( region != null )
			{
				BaseRegion br = region as BaseRegion;

				if ( br != null && br.m_RuneName != null )
					return br.m_RuneName;

				region = region.Parent;
			}

			return null;
		}

        public ApprenticeObjective( SkillName skill, int cap, string region, object enterRegion, object leaveRegion )
            : base(cap)
        {
            m_Skill = skill;

            if ( region != null )
            {
                m_Region = QuestHelper.FindRegion( region );
                m_Enter = enterRegion;
                m_Leave = leaveRegion;

                if ( m_Region == null )
                    Console.WriteLine( String.Format( "Invalid region name ('{0}') in '{1}' objective!", region, GetType() ) );
            }
        }

		public static Town FromRegion( Region reg )
		{
			if ( reg.Map != Faction.Facet )
				return null;

			List<Town> towns = Towns;

			for ( int i = 0; i < towns.Count; ++i )
			{
				Town town = towns[i];

				if ( reg.IsPartOf( town.Definition.Region ) )
					return town;
			}

			return null;
		}

		public static Town FromRegion( Region reg )
		{
			if ( reg.Map != Faction.Facet )
				return null;

			TownCollection towns = Towns;

			for ( int i = 0; i < towns.Count; ++i )
			{
				Town town = towns[i];

				if ( town.Definition.Region == reg.Name )
					return town;
			}

			return null;
		}

        public static Rectangle3D[] RegionArea(Region region)
        {
            #if(RunUO_1_Final)

                Rectangle3D[] rects = new Rectangle3D[region.Coords.Count];
                Rectangle2D rect = new Rectangle2D(Point2D.Zero, Point2D.Zero);

                for (int i = 0; i < rects.Length && i < region.Coords.Count; ++i)
                {
                    rect = (Rectangle2D)region.Coords[i];
                    rects[i] = new Rectangle3D(new Point3D(rect.Start.X, rect.Start.Y, region.MinZ), new Point3D(rect.End.X, rect.End.Y, region.MaxZ));
                }

                return rects;

            #elif(RunUO_2_RC1)
                return region.Area;
            #endif
        }

        public TownRegion( XmlElement xml, Map map, Region parent )
            : base(xml, map, parent)
        {
            string frag = Name.ToLower();
            if (frag == "serpent's hold")
                frag = "serphold";
            else if (frag == "skara brae")
                frag = "skara";
            else if (frag == "nujel'm")
                frag = "nujelm";
            else if (frag == "buccaneer's den")
                frag = "bucden";

            try
            {
                m_Frag = (RegionFragment)Enum.Parse(typeof(RegionFragment), frag, true);
            }
            catch (Exception)
            {
                m_Frag = RegionFragment.Wilderness;
            }
        }

		public bool HasRegionPoints(Region r)
		{
			if (r != null && r.Coords.Count > 0) return true;
			else
				return false;
		}