Exemple #1
0
        public void Register()
        {
            if (m_Registered)
            {
                return;
            }

            OnRegister();

            m_Registered = true;

            if (m_Parent != null)
            {
                m_Parent.m_Children.Add(this);
                m_Parent.OnChildAdded(this);
            }

            m_Regions.Add(this);

            m_Map.RegisterRegion(this);

            List <Sector> sectors = new List <Sector>();

            for (int i = 0; i < m_Area.Length; i++)
            {
                Rectangle3D rect = m_Area[i];

                Point2D start = m_Map.Bound(new Point2D(rect.Start));
                Point2D end   = m_Map.Bound(new Point2D(rect.End));

                Sector startSector = m_Map.GetSector(start);
                Sector endSector   = m_Map.GetSector(end);

                for (int x = startSector.X; x <= endSector.X; x++)
                {
                    for (int y = startSector.Y; y <= endSector.Y; y++)
                    {
                        Sector sector = m_Map.GetRealSector(x, y);

                        sector.OnEnter(this, rect);

                        if (!sectors.Contains(sector))
                        {
                            sectors.Add(sector);
                        }
                    }
                }
            }

            m_Sectors = sectors.ToArray();
        }
Exemple #2
0
        public static IEnumerable <Region> FindRegions(Point3D p, Map map)
        {
            if (map == null)
            {
                yield return(Map.Internal.DefaultRegion);
            }
            else
            {
                Sector            sector = map.GetSector(p);
                List <RegionRect> list   = sector.RegionRects;
                bool found = false;

                for (int i = 0; i < list.Count; ++i)
                {
                    RegionRect regRect = list[i];

                    if (regRect.Contains(p))
                    {
                        if (!found)
                        {
                            found = true;
                        }

                        yield return(regRect.Region);
                    }
                }

                if (!found)
                {
                    yield return(map.DefaultRegion);
                }
            }
        }
Exemple #3
0
        public static bool CheckCitiesInRange(Mobile from, Point3D p)
        {
            // Very Speical Thanks To ArteGordon For His Help On This Bool

            Map map = from.Map;

            int offset  = CityRangeOffset;
            int offset2 = offset * 3;

            int x1     = p.X - offset;
            int y1     = p.Y - offset;
            int width  = offset2;
            int height = offset2;

            int depth = p.Z;

            for (int x = x1; x <= x1 + width; x += Map.SectorSize)
            {
                for (int y = y1; y <= y1 + height; y += Map.SectorSize)
                {
                    Sector s = map.GetSector(new Point3D(x, y, depth));

                    foreach (RegionRect rect in s.RegionRects)
                    {
                        Region r = rect.Region;
                        if (r is GuardedRegion || r is PlayerCityRegion)
                        {
                            return(true);
                        }
                    }
                }
            }

            return(false);
        }
		private void BoundingBox_Callback( Mobile from, Map map, Point3D start, Point3D end, object state )
		{
			Utility.FixPoints( ref start, ref end );
			Rectangle2D rect = new Rectangle2D(start, end);

			#region MobileSaver
			from.SendMessage( "Extracting Mobiles" );

			foreach ( Mobile m in map.GetMobilesInBounds( rect ) )
			{
				if ( m != null && m is BaseCreature )
				{
					int saveflag = MobileSaver.GetSaveFlag( m );

					if ( saveflag > 0 )
					{
						DesignItem designItem = new DesignItem();
						designItem.ItemID = (short)0x1;
						designItem.X = m.X;
						designItem.Y = m.Y;
						designItem.Z = m.Z + saveflag;
						designItem.Hue = (short)m.Hue;
					}
				}
			}
			#endregion

			for ( int x = 0; x <= rect.Width; ++x )
			{
				for ( int y = 0; y <= rect.Height; ++y )
				{
					int tileX = rect.Start.X + x;
					int tileY = rect.Start.Y + y;

					Sector sector = map.GetSector( tileX, tileY );

					for ( int i = 0; i < sector.Items.Count; ++i )
					{
						Item item = (Item)sector.Items[i];

						if(_args.UseMinZ && item.Z < _args.MinZ)
							continue;
						else if(_args.UseMaxZ && item.Z > _args.MaxZ)
							continue;

						if ( item.Visible && item.X == tileX && item.Y == tileY && !((item is BaseMulti) || (item is HouseSign)) )
						{
							_itemSerials.Add(item.Serial.Value);
						}
					}
				}
			}

			if(_itemSerials.Count > 0)
				SendResponse(new SelectItemsResponse((int[])_itemSerials.ToArray(typeof(int))));
			else
				SendResponse(null);
		}
        public virtual void Unregister()
        {
            if (m_Coords == null || m_Map == null)
            {
                return;
            }

            for (int i = 0; i < m_Coords.Count; ++i)
            {
                object obj = m_Coords[i];

                Point2D start, end;

                if (obj is Rectangle2D)
                {
                    Rectangle2D r2d = (Rectangle2D)obj;

                    start = m_Map.Bound(r2d.Start);
                    end   = m_Map.Bound(r2d.End);
                }
                else if (obj is Rectangle3D)
                {
                    Rectangle3D r3d = (Rectangle3D)obj;

                    start = m_Map.Bound(new Point2D(r3d.Start));
                    end   = m_Map.Bound(new Point2D(r3d.End));
                }
                else
                {
                    continue;
                }

                Sector startSector = m_Map.GetSector(start);
                Sector endSector   = m_Map.GetSector(end);

                for (int x = startSector.X; x <= endSector.X; ++x)
                {
                    for (int y = startSector.Y; y <= endSector.Y; ++y)
                    {
                        m_Map.GetRealSector(x, y).OnLeave(this);
                    }
                }
            }
        }
Exemple #6
0
        /// <summary>
        ///     Gets a BaseMulti collection representing all BaseMultis that are within 'range' of 'center' on the given 'map'
        /// </summary>
        public static List <BaseMulti> GetMultisInRange(this IPoint3D center, Map map, int range)
        {
            if (center == null || map == null)
            {
                return(new List <BaseMulti>());
            }

            return
                (map.GetSector(center).Multis.Where(v => v != null && (v.Contains(center) || v.InRange2D(center, range))).ToList());
        }
Exemple #7
0
        /// <summary>
        ///     Gets a BaseMulti collection representing all BaseMultis that are within 'range' of 'center' on the given 'map'
        /// </summary>
        public static IEnumerable <BaseMulti> FindMultisInRange(this IPoint3D center, Map map, int range)
        {
            if (center == null || map == null)
            {
                yield break;
            }

            var scan = map.GetSector(center).Multis.Where(v => v != null && (v.Contains(center) || v.InRange2D(center, range)));

            foreach (var m in scan)
            {
                yield return(m);
            }
        }
Exemple #8
0
		public static BaseBoat FindBoatAt( IPoint2D loc, Map map )
		{
			Sector sector = map.GetSector( loc );

			for ( int i = 0; i < sector.Multis.Count; i++ )
			{
				BaseBoat boat = sector.Multis[i] as BaseBoat;

				if ( boat != null && boat.Contains( loc.X, loc.Y ) )
					return boat;
			}

			return null;
		}
        public static Region Find(Point3D p, Map map)
        {
            if (map == null)
            {
                return(Map.Internal.DefaultRegion);
            }

            Sector    sector = map.GetSector(p);
            ArrayList list   = sector.Regions;

            for (int i = 0; i < list.Count; ++i)
            {
                Region region = (Region)list[i];

                if (region.Contains(p))
                {
                    return(region);
                }
            }

            return(map.DefaultRegion);
        }
Exemple #10
0
        public static Region Find(Point3D p, Map map)
        {
            if (map == null)
            {
                return(Map.Internal.DefaultRegion);
            }

            Sector            sector = map.GetSector(p);
            List <RegionRect> list   = sector.RegionRects;

            for (int i = 0; i < list.Count; ++i)
            {
                RegionRect regRect = list[i];

                if (regRect.Contains(p))
                {
                    return(regRect.Region);
                }
            }

            return(map.DefaultRegion);
        }
Exemple #11
0
        public static Region Find(Point3D p, Map map)
        {
            int    num1;
            Region region1;

            if (map == null)
            {
                return(Map.Internal.DefaultRegion);
            }
            Sector    sector1 = map.GetSector(p);
            ArrayList list1   = sector1.Regions;

            for (num1 = 0; (num1 < list1.Count); ++num1)
            {
                region1 = ((Region)list1[num1]);
                if (region1.Contains(p))
                {
                    return(region1);
                }
            }
            return(map.DefaultRegion);
        }
        private void BoundingBox_Callback( Mobile from, Map map, Point3D start, Point3D end, object state )
        {
            Utility.FixPoints( ref start, ref end );
            Rectangle2D rect = new Rectangle2D(start, end);

            for ( int x = 0; x <= rect.Width; ++x )
            {
                for ( int y = 0; y <= rect.Height; ++y )
                {
                    int tileX = rect.Start.X + x;
                    int tileY = rect.Start.Y + y;

                    Sector sector = map.GetSector( tileX, tileY );

                    for ( int i = 0; i < sector.Items.Count; ++i )
                    {
                        Item item = (Item)sector.Items[i];

                        if(_args.UseMinZ && item.Z < _args.MinZ)
                            continue;
                        else if(_args.UseMaxZ && item.Z > _args.MaxZ)
                            continue;

                        if ( item.Visible && item.X == tileX && item.Y == tileY && !((item is BaseMulti) || (item is HouseSign)) )
                        {
                            _itemSerials.Add(item.Serial.Value);
                        }
                    }
                }
            }

            if(_itemSerials.Count > 0)
                SendResponse(new SelectItemsResponse((int[])_itemSerials.ToArray(typeof(int))));
            else
                SendResponse(null);
        }
Exemple #13
0
		public static bool CheckMulti( Point3D p, Map map, bool houses )
		{
			if( map == null || map == Map.Internal )
				return false;

			Sector sector = map.GetSector( p.X, p.Y );

			for( int i = 0; i < sector.Multis.Count; ++i )
			{
				BaseMulti multi = sector.Multis[i];

				if( multi is BaseHouse )
				{
					if( houses && ((BaseHouse)multi).IsInside( p, 16 ) )
						return true;
				}
				else if( multi.Contains( p ) )
				{
					return true;
				}
			}

			return false;
		}
Exemple #14
0
        public static object GetTopSurface(this Map map, Point3D p, bool multis)
        {
            if (map == Map.Internal)
            {
                return(null);
            }

            object surface  = null;
            var    surfaceZ = int.MinValue;

            var lt = map.Tiles.GetLandTile(p.X, p.Y);

            if (!lt.Ignored)
            {
                var avgZ = map.GetAverageZ(p.X, p.Y);

                if (avgZ <= p.Z)
                {
                    surface  = lt;
                    surfaceZ = avgZ;

                    if (surfaceZ == p.Z)
                    {
                        return(surface);
                    }
                }
            }

            var staticTiles = map.Tiles.GetStaticTiles(p.X, p.Y, multis);

            ItemData id;
            int      tileZ;

            foreach (var tile in staticTiles)
            {
                id = TileData.ItemTable[tile.ID & TileData.MaxItemValue];

                if (!id.Surface && (id.Flags & TileFlag.Wet) == 0)
                {
                    continue;
                }

                tileZ = tile.Z + id.CalcHeight;

                if (tileZ <= surfaceZ || tileZ > p.Z)
                {
                    continue;
                }

                surface  = tile;
                surfaceZ = tileZ;

                if (surfaceZ == p.Z)
                {
                    return(surface);
                }
            }

            var sector = map.GetSector(p.X, p.Y);

            int itemZ;

            var items = sector.Items.Where(
                o => o.ItemID <= TileData.MaxItemValue && !o.Movable && !(o is BaseMulti) && o.AtWorldPoint(p.X, p.Y));

            foreach (var item in items)
            {
                id = item.ItemData;

                if (!id.Surface && (id.Flags & TileFlag.Wet) == 0)
                {
                    continue;
                }

                itemZ = item.Z + id.CalcHeight;

                if (itemZ <= surfaceZ || itemZ > p.Z)
                {
                    continue;
                }

                surface  = item;
                surfaceZ = itemZ;

                if (surfaceZ == p.Z)
                {
                    return(surface);
                }
            }

            return(surface);
        }
Exemple #15
0
		public bool CheckMovement( Mobile m, Map map, Point3D loc, Direction d, out int newZ )
		{
			if ( map == null || map == Map.Internal )
			{
				newZ = 0;
				return false;
			}

			int xStart = loc.X;
			int yStart = loc.Y;
			int xForward = xStart, yForward = yStart;
			int xRight = xStart, yRight = yStart;
			int xLeft = xStart, yLeft = yStart;

			bool checkDiagonals = ((int)d & 0x1) == 0x1;

			Offset( d, ref xForward, ref yForward );
			Offset( (Direction)(((int)d - 1) & 0x7), ref xLeft, ref yLeft );
			Offset( (Direction)(((int)d + 1) & 0x7), ref xRight, ref yRight );

			if ( xForward < 0 || yForward < 0 || xForward >= map.Width || yForward >= map.Height )
			{
				newZ = 0;
				return false;
			}

			int startZ, startTop;

			List<Item> itemsStart = m_Pools[0];
			List<Item> itemsForward = m_Pools[1];
			List<Item> itemsLeft = m_Pools[2];
			List<Item> itemsRight = m_Pools[3];

			bool ignoreMovableImpassables = m_IgnoreMovableImpassables;
			TileFlag reqFlags = ImpassableSurface;

			if ( m.CanSwim )
				reqFlags |= TileFlag.Wet;

			List<Mobile> mobsForward = m_MobPools[0];
			List<Mobile> mobsLeft = m_MobPools[1];
			List<Mobile> mobsRight = m_MobPools[2];

			bool checkMobs = ( m is BaseCreature && !((BaseCreature)m).Controlled && ( xForward != m_Goal.X || yForward != m_Goal.Y ) );

			if ( checkDiagonals )
			{
				Sector sectorStart = map.GetSector( xStart, yStart );
				Sector sectorForward = map.GetSector( xForward, yForward );
				Sector sectorLeft = map.GetSector( xLeft, yLeft );
				Sector sectorRight = map.GetSector( xRight, yRight );

				List<Sector> sectors = m_Sectors;

				sectors.Add( sectorStart );

				if ( !sectors.Contains( sectorForward ) )
					sectors.Add( sectorForward );

				if ( !sectors.Contains( sectorLeft ) )
					sectors.Add( sectorLeft );

				if ( !sectors.Contains( sectorRight ) )
					sectors.Add( sectorRight );

				for ( int i = 0; i < sectors.Count; ++i )
				{
					Sector sector = sectors[i];

					for ( int j = 0; j < sector.Items.Count; ++j )
					{
						Item item = sector.Items[j];

						if ( ignoreMovableImpassables && item.Movable && ( item.ItemData.Flags & ImpassableSurface ) != 0 )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( sector == sectorStart && item.AtWorldPoint( xStart, yStart ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsStart.Add( item );
						else if ( sector == sectorForward && item.AtWorldPoint( xForward, yForward ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsForward.Add( item );
						else if ( sector == sectorLeft && item.AtWorldPoint( xLeft, yLeft ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsLeft.Add( item );
						else if ( sector == sectorRight && item.AtWorldPoint( xRight, yRight ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsRight.Add( item );
					}

					if ( checkMobs )
					{
						for ( int j = 0; j < sector.Mobiles.Count; ++j )
						{
							Mobile mob = sector.Mobiles[j];

							if ( sector == sectorForward && mob.X == xForward && mob.Y == yForward )
								mobsForward.Add( mob );
							else if ( sector == sectorLeft && mob.X == xLeft && mob.Y == yLeft )
								mobsLeft.Add( mob );
							else if ( sector == sectorRight && mob.X == xRight && mob.Y == yRight )
								mobsRight.Add( mob );
						}
					}
				}

				if ( m_Sectors.Count > 0 )
					m_Sectors.Clear();
			}
			else
			{
				Sector sectorStart = map.GetSector( xStart, yStart );
				Sector sectorForward = map.GetSector( xForward, yForward );

				if ( sectorStart == sectorForward )
				{
					for ( int i = 0; i < sectorStart.Items.Count; ++i )
					{
						Item item = sectorStart.Items[i];

						if ( ignoreMovableImpassables && item.Movable && ( item.ItemData.Flags & ImpassableSurface ) != 0 )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( item.AtWorldPoint( xStart, yStart ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsStart.Add( item );
						else if ( item.AtWorldPoint( xForward, yForward ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsForward.Add( item );
					}
				}
				else
				{
					for ( int i = 0; i < sectorForward.Items.Count; ++i )
					{
						Item item = sectorForward.Items[i];

						if ( ignoreMovableImpassables && item.Movable && ( item.ItemData.Flags & ImpassableSurface ) != 0 )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( item.AtWorldPoint( xForward, yForward ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsForward.Add( item );
					}

					for ( int i = 0; i < sectorStart.Items.Count; ++i )
					{
						Item item = sectorStart.Items[i];

						if ( ignoreMovableImpassables && item.Movable && ( item.ItemData.Flags & ImpassableSurface ) != 0 )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( item.AtWorldPoint( xStart, yStart ) && !(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue )
							itemsStart.Add( item );
					}
				}

				if ( checkMobs )
				{
					for ( int i = 0; i < sectorForward.Mobiles.Count; ++i )
					{
						Mobile mob = sectorForward.Mobiles[i];

						if ( mob.X == xForward && mob.Y == yForward )
							mobsForward.Add( mob );
					}
				}
			}

			GetStartZ( m, map, loc, itemsStart, out startZ, out startTop );

			bool moveIsOk = Check( map, m, itemsForward, mobsForward, xForward, yForward, startTop, startZ, m.CanSwim, m.CantWalk, out newZ );

			if ( moveIsOk && checkDiagonals )
			{
				int hold;

				if ( m.Player && m.AccessLevel < AccessLevel.GameMaster ) {
					if ( !Check( map, m, itemsLeft, mobsLeft, xLeft, yLeft, startTop, startZ, m.CanSwim, m.CantWalk, out hold ) || !Check( map, m, itemsRight, mobsRight, xRight, yRight, startTop, startZ, m.CanSwim, m.CantWalk, out hold ) )
						moveIsOk = false;
				} else {
					if ( !Check( map, m, itemsLeft, mobsLeft, xLeft, yLeft, startTop, startZ, m.CanSwim, m.CantWalk, out hold ) && !Check( map, m, itemsRight, mobsRight, xRight, yRight, startTop, startZ, m.CanSwim, m.CantWalk, out hold ) )
						moveIsOk = false;
				}
			}

			for ( int i = 0; i < (checkDiagonals ? 4 : 2); ++i )
			{
				if ( m_Pools[i].Count != 0 )
					m_Pools[i].Clear();
			}

			for ( int i = 0; i < (checkDiagonals ? 3 : 1); ++i )
			{
				if ( m_MobPools[i].Count != 0 )
					m_MobPools[i].Clear();
			}

			if ( !moveIsOk )
				newZ = startZ;

			return moveIsOk;
		}
        private static bool CanFit(Map map, int x, int y, int z)
        {
            bool hasSurface = false;

            Tile lt = map.Tiles.GetLandTile(x, y);
            int  lowZ = 0, avgZ = 0, topZ = 0;

            map.GetAverageZ(x, y, ref lowZ, ref avgZ, ref topZ);
            TileFlag landFlags = TileData.LandTable[lt.ID & 0x3FFF].Flags;

            if ((landFlags & TileFlag.Impassable) != 0 && topZ > z && (z + 16) > lowZ)
            {
                return(false);
            }
            else if ((landFlags & TileFlag.Impassable) == 0 && z == avgZ && !lt.Ignored)
            {
                hasSurface = true;
            }

            Tile[] staticTiles = map.Tiles.GetStaticTiles(x, y);

            bool surface, impassable;

            for (int i = 0; i < staticTiles.Length; ++i)
            {
                if (IsDisplayCase(staticTiles[i].ID))
                {
                    continue;
                }

                ItemData id = TileData.ItemTable[staticTiles[i].ID & 0x3FFF];

                surface    = id.Surface;
                impassable = id.Impassable;

                if ((surface || impassable) && (staticTiles[i].Z + id.CalcHeight) > z && (z + 16) > staticTiles[i].Z)
                {
                    return(false);
                }
                else if (surface && !impassable && z == (staticTiles[i].Z + id.CalcHeight))
                {
                    hasSurface = true;
                }
            }

            Sector sector = map.GetSector(x, y);

            foreach (Item item in sector.Items.Values)
            {
                if (item == null)
                {
                    continue;
                }

                if (item.AtWorldPoint(x, y))
                {
                    ItemData id = item.ItemData;
                    surface    = id.Surface;
                    impassable = id.Impassable;

                    if ((surface || impassable) && (item.Z + id.CalcHeight) > z && (z + 16) > item.Z)
                    {
                        return(false);
                    }
                    else if (surface && !impassable && z == (item.Z + id.CalcHeight))
                    {
                        hasSurface = true;
                    }
                }
            }

            return(hasSurface);
        }
Exemple #17
0
        public static bool CheckTravel(Map map, Point3D loc, TravelCheckType type, Mobile caster, out bool jail)
		{
            jail = false;

			if ( IsInvalid( map, loc ) ) // null, internal, out of bounds
				return false;

			// custom regions
			CustomRegion reg = Region.Find( loc, map ) as CustomRegion;
			CustomRegion reg2 = CustomRegion.FindDRDTRegion(caster);
			if( reg != null ) 
			{
				try
				{
					RegionControl regstone = null;

					//if a custom region does exsist find its controller
					regstone = reg.GetRegionControler(); 

					if (regstone != null && caster.AccessLevel == AccessLevel.Player)
					{
						if(regstone.AllowTravelSpellsInRegion && reg == reg2)
							return true;
						
						if(regstone.NoRecallInto && type == TravelCheckType.RecallTo)
							return false;

						if(regstone.NoGateInto && type == TravelCheckType.GateTo)
							return false;

						Spell spell = new GateTravelSpell(caster, null);

						if(regstone.IsRestrictedSpell(spell, caster) && type == TravelCheckType.GateFrom)
							return false;


						if(regstone.CannotEnter && type == TravelCheckType.TeleportTo)
							return false;
					}

				}
	
				catch(NullReferenceException e)
				{
					LogHelper.LogException(e);
					Console.WriteLine("{0} Caught exception.", e); 
				}
				catch(Exception ex)
				{
                    LogHelper.LogException(ex);
				}
			}

			if( reg2 != null ) 
			{
				try
				{
					RegionControl regstone = null;

					//if a custom region does exsist find its controller
					regstone = reg2.GetRegionControler(); 

					if (regstone != null && caster.AccessLevel == AccessLevel.Player)
					{
						if(regstone.AllowTravelSpellsInRegion && reg == reg2)
							return true;
						

						if(regstone.NoRecallInto && type == TravelCheckType.RecallTo)
							return false;

						if(regstone.NoGateInto && type == TravelCheckType.GateTo)
							return false;

						Spell spell = new GateTravelSpell(caster, null);

						if(regstone.IsRestrictedSpell(spell, caster) && type == TravelCheckType.GateFrom)
							return false;


						if(regstone.CannotEnter && type == TravelCheckType.TeleportTo)
							return false;
					}

				}
	
				catch(NullReferenceException e)
				{
					LogHelper.LogException(e);
					Console.WriteLine("{0} Caught exception.", e); 
				}
				catch(Exception ex)
				{
                    LogHelper.LogException(ex);
				}
			}

			//Deal with house SecurePremises flag
            if ((type == TravelCheckType.GateTo || type == TravelCheckType.RecallTo ||
                type == TravelCheckType.TeleportTo) && caster.AccessLevel == AccessLevel.Player)
			{
				BaseHouse dst_house = null;
				Sector sector = map.GetSector( loc );
				foreach (BaseMulti mx in sector.Multis.Values)
				{
					BaseHouse _house = mx as BaseHouse;
                    if (_house == null)
                        continue;

					if ( _house != null && _house.Region.Contains(loc) )
					{
						dst_house = _house;
					}
				}

				if( dst_house != null )
				{
					if( dst_house.SecurePremises )
					{
						if( !dst_house.IsFriend( caster ) )
						{
							return false;
						}
					}
				}

			}

            // Gate inside a PreviewHouse exploit. Go directally to jail, don't collect $200.0
            if ((type == TravelCheckType.GateTo ||type == TravelCheckType.RecallTo ||
                type == TravelCheckType.TeleportTo) && caster.AccessLevel == AccessLevel.Player)
            {
                if (PreviewHouseAt(caster.Map, loc))
                {
                    LogHelper.Cheater(caster, "Travel inside a PreviewHouse exploit.", true);
                    jail = true;
                    return false;
                }
            }

            // Teleport onto a stack of stuff =\
            if (type == TravelCheckType.TeleportTo  && caster.AccessLevel == AccessLevel.Player)
            {
                // if we are teleporting onto a stack of movable items, and at least 3 reside on different Z planes
                //  then it looks too much like an exploit to allow it.
                if (iStack(caster, loc, 2) == false)
                {
                    LogHelper.Cheater(caster, "Tele onto a stack of movable items.", true);
                    return false;
                }
            }

            // mark on a stack of stuff =\
            // same as teleport above, but different limit and different message
            if (type == TravelCheckType.Mark && caster.AccessLevel == AccessLevel.Player)
            {
                // if we are marking on a stack of movable items, and at least 2 reside on different Z planes
                //  then it looks too much like an exploit to allow it.
                if (iStack(caster, loc, 2) == false)
                {
                    LogHelper.Cheater(caster, "Mark on a stack of movable items.", true);
                    return false;
                }
            }

            // disallow teleporting from outside the house into the inside if the doors are closed (no LOS)
            if ((type == TravelCheckType.TeleportTo) && caster.AccessLevel == AccessLevel.Player)
            {
                BaseHouse dst_house = null;
                Sector sector = map.GetSector(loc);
				foreach (BaseMulti mx in sector.Multis.Values)
                {
					BaseHouse _house = mx as BaseHouse;
                    if (_house == null)
                        continue;

                    if (_house != null && _house.Region.Contains(loc))
                    {
                        dst_house = _house;
                    }
                }

                // is the user trying to shoot through a door without LOS?
                if (dst_house != null)
                {
                    if (!caster.InLOS(loc))
                    {
                        LogHelper.Cheater(caster, "Try to teleport through front door (LOS)", true);
                        return false;
                    }
                }

                // is the user not standing on the ground?
                if (dst_house != null && dst_house.Region != null)
                {   
                    if (!caster.Map.CanSpawnMobile(caster.Location.X, caster.Location.Y, caster.Location.Z, CanFitFlags.requireSurface))
                    {
                        LogHelper.Cheater(caster, "Try to teleport over front door (Z Axis)", true);
                        return false;
                    }
                }

            }

            // special housing region/multi exploit - teleport from multi to castle courtyard
            // stop players from teleporting from one multi to another (includes PreviewHouses)
            if(type == TravelCheckType.TeleportTo && caster.AccessLevel == AccessLevel.Player)
            {
                // if there is a house at the destination, then..
                //  if all the multis and regions do not match between src and dst, fail
                if (HouseAt(caster.Map, loc) && CheckParity(caster.Map, caster.Location, loc) == false)
                {
                    LogHelper.Cheater(caster, "Multi to multi teleport exploit.", true);
                    return false;
                }
            }

            // Replaced by above CheckParity() implementation (delete after 5/1/07)
            // special housing region exploit - teleport from tower roof to castle courtyard
            /*if(type == TravelCheckType.TeleportTo && caster.AccessLevel == AccessLevel.Player)
            {
                BaseHouse src_house = BaseHouse.FindHouseAt( caster );
                BaseHouse dst_house = null;
				
                // add this redundant check here to eliminate the house enumeration
                //	for the cases when it's not needed.
                if (src_house != null)
                {
                    // build super sector that includes both src and dest
                    ArrayList SuperSector = new ArrayList();
                    SuperSector.Add(src_house);
                    Sector sector = map.GetSector( loc );
                    for ( int i = 0; i < sector.Multis.Count; ++i )
                    {
                        BaseHouse _house = sector.Multis[i] as BaseHouse;
                        if ( _house != null  )
                            if (SuperSector.Contains(_house) == false) // disallow duplicates
                                SuperSector.Add(_house);
                    }
					
                    // now add these if the houses are in different sectors
                    if (sector != map.GetSector( caster ))
                    {
                        sector = map.GetSector( caster );
                        for ( int i = 0; i < sector.Multis.Count; ++i )
                        {
                            BaseHouse _house = sector.Multis[i] as BaseHouse;
                            if ( _house != null  )
                                if (SuperSector.Contains(_house) == false) // disallow duplicates
                                    SuperSector.Add(_house);
                        }
                    }

                    // get the destination house
                    for ( int i = 0; i < SuperSector.Count; ++i )
                    {
                        BaseHouse _house = SuperSector[i] as BaseHouse;

                        if ( _house.Region.Contains(loc) )
                        {
                            //Console.WriteLine("dst_house.region{0}, loc{1}", _house.Region.Coords.ToString(), loc.ToString()); 
                            dst_house = _house;
                        }
                    }

                    // okay, if source house and dest house are different, fail
                    bool house = (src_house != null && dst_house != null);
                    if (house == true && src_house != dst_house)
                    {
                        //Console.WriteLine("Caught invalid teleport."); 
                        LogHelper.Cheater(caster, "Tower roof teleport exploit: case(1)", true);
                        return false;
                    }

                    // house region overlap test: possible with the Tower overhang, overhanging
                    //	another house / courtyard
                    int houses = 0;
                    for ( int i = 0; i < SuperSector.Count; ++i )
                    {
                        BaseHouse _house = SuperSector[i] as BaseHouse;
                        if ( _house.Region.Contains(caster.Location) )
                            houses++;
                    }
                    if (houses > 1)
                    {
                        LogHelper.Cheater(caster, "Tower roof teleport exploit: case(2)", true);
                        return false;
                    }
                }
            }*/

            // okay, now check our locale rules table
			int v = (int)type;
			bool isValid = true;

			for ( int i = 0; isValid && i < m_Validators.Length; ++i )
				isValid = ( m_Rules[v, i] || !m_Validators[i]( map, loc ) );

			return isValid;
		}
Exemple #18
0
		public static ArrayList FindAll(Point3D p, Map map)
		{
			ArrayList all = new ArrayList();

			if (map == null)
			{
				all.Add(Map.Internal.DefaultRegion);
				return all;
			}

			Sector sector = map.GetSector(p);
			ArrayList list = sector.Regions;

			for (int i = 0; i < list.Count; ++i)
			{
				if (list[i] is Region)
				{
					Region region = list[i] as Region;
					if (region.Contains(p))
						all.Add(region);
				}
			}

			all.Add(map.DefaultRegion);
			return all;
		}
		private static HousePlacementResult HousePlacementRegionCheck(Mobile from, Map map, Point3D testPoint)
		{
			Sector sector = map.GetSector(testPoint);
			ArrayList list = sector.Regions;

			for (int i = 0; i < list.Count; ++i)
			{
				Region region = (Region)list[i];

				if (region.Contains(testPoint))
				{
					if (region is HouseRegion)
						return HousePlacementResult.BadRegion;

					if (!region.AllowHousing(from, testPoint)) // Cannot place houses in dungeons, towns, treasure map areas etc
					{
						if (region is TreasureRegion)
							return HousePlacementResult.BadRegionHidden;

						return HousePlacementResult.BadRegion;
					}

					if (region is TownshipRegion)
					{
						if (((TownshipRegion)region).CanBuildHouseInTownship(from) == false)
						{
							return HousePlacementResult.BadRegionTownship;
						}
					}

					if (region is NoHousingRegion)
						return HousePlacementResult.BadRegion;
				}
			}

			return HousePlacementResult.Valid;
		}
Exemple #20
0
        private static bool CanFit(Map map, int x, int y, int z)
        {
            var hasSurface = false;

            var lt = map.Tiles.GetLandTile(x, y);
            int lowZ = 0, avgZ = 0, topZ = 0;

            map.GetAverageZ(x, y, ref lowZ, ref avgZ, ref topZ);
            var landFlags = TileData.LandTable[lt.ID & TileData.MaxLandValue].Flags;

            if ((landFlags & TileFlag.Impassable) != 0 && topZ > z && z + 16 > lowZ)
            {
                return(false);
            }
            if ((landFlags & TileFlag.Impassable) == 0 && z == avgZ && !lt.Ignored)
            {
                hasSurface = true;
            }

            var staticTiles = map.Tiles.GetStaticTiles(x, y);

            bool surface, impassable;

            for (var i = 0; i < staticTiles.Length; ++i)
            {
                if (IsDisplayCase(staticTiles[i].ID))
                {
                    continue;
                }

                var id = TileData.ItemTable[staticTiles[i].ID & TileData.MaxItemValue];

                surface    = id.Surface;
                impassable = id.Impassable;

                if ((surface || impassable) && staticTiles[i].Z + id.CalcHeight > z && z + 16 > staticTiles[i].Z)
                {
                    return(false);
                }
                if (surface && !impassable && z == staticTiles[i].Z + id.CalcHeight)
                {
                    hasSurface = true;
                }
            }

            var sector = map.GetSector(x, y);
            var items  = sector.Items;

            for (var i = 0; i < items.Count; ++i)
            {
                var item = items[i];

                if (item.AtWorldPoint(x, y))
                {
                    var id = item.ItemData;
                    surface    = id.Surface;
                    impassable = id.Impassable;

                    if ((surface || impassable) && item.Z + id.CalcHeight > z && z + 16 > item.Z)
                    {
                        return(false);
                    }
                    if (surface && !impassable && z == item.Z + id.CalcHeight)
                    {
                        hasSurface = true;
                    }
                }
            }

            return(hasSurface);
        }
Exemple #21
0
		public static Region Find( Point3D p, Map map )
		{
			if ( map == null )
				return Map.Internal.DefaultRegion;

			Sector sector = map.GetSector( p );
			List<RegionRect> list = sector.RegionRects;

			for ( int i = 0; i < list.Count; ++i )
			{
				RegionRect regRect = list[i];

				if ( regRect.Contains( p ) )
					return regRect.Region;
			}

			return map.DefaultRegion;
		}
Exemple #22
0
		public static BaseHouse FindHouseAt(Point3D loc, Map map, int height)
		{
			if (map == null || map == Map.Internal)
				return null;

			Sector sector = map.GetSector(loc);

            foreach (BaseMulti mult in sector.Multis.Values)
			{
				BaseHouse house = mult as BaseHouse;
				if (house != null && house.IsInside(loc, height))
					return house;
			}

			return null;
		}
        public static List<StaticTile> GetTilesAt(Map map, Point2D p, bool items, bool land, bool statics)
        {
            List<StaticTile> list = new List<StaticTile>();

            if (map == Map.Internal)
                return list;

            if (statics)
                list.AddRange(map.Tiles.GetStaticTiles(p.X, p.Y, true));

            if (items)
            {
                Sector sector = map.GetSector(p);

                foreach (Item item in sector.Items)
                    if (item.AtWorldPoint(p.X, p.Y))
                        list.Add(new StaticTile((ushort)item.ItemID, (sbyte)item.Z));
            }

            return list;
        }
Exemple #24
0
		private static bool IsPointInNoMurderZone(Point3D p, Map map)
		{
			if (map == null)
				return false;

			Sector sector = map.GetSector(p);
			ArrayList list = sector.Regions;

			bool bReturn = false;

			for (int i = 0; i < list.Count; ++i)
			{
				Region region = (Region)list[i];

				if (region.Contains(p))
				{
					if (region.IsNoMurderZone)
					{
						bReturn = true;
					}
				}
			}

			return bReturn;
		}
        public static Region Find( Point3D p, Map map )
        {
            if ( map == null )
                return Map.Internal.DefaultRegion;

            Sector sector = map.GetSector( p );
            ArrayList list = sector.Regions;

            for ( int i = 0; i < list.Count; ++i )
            {
                Region region = (Region)list[i];

                if ( region.Contains( p ) )
                    return region;
            }

            return map.DefaultRegion;
        }
		public static BaseHouse FindHouseAt( Point3D loc, Map map, int height )
		{
			if ( map == null || map == Map.Internal )
				return null;

			Sector sector = map.GetSector( loc );

			for ( int i = 0; i < sector.Multis.Count; ++i )
			{
				BaseHouse house = sector.Multis[i] as BaseHouse;

				if ( house != null && house.IsInside( loc, height ) )
					return house;
			}

			return null;
		}
		public bool CheckMovement( Mobile m, Map map, Point3D loc, Direction d, out int newZ )
		{
			if ( map == null || map == Map.Internal )
			{
				newZ = 0;
				return false;
			}

			int xStart = loc.X;
			int yStart = loc.Y;
			int xForward = xStart, yForward = yStart;
			int xRight = xStart, yRight = yStart;
			int xLeft = xStart, yLeft = yStart;

			bool checkDiagonals = ((int)d & 0x1) == 0x1;

			Offset( d, ref xForward, ref yForward );
			Offset( (Direction)(((int)d - 1) & 0x7), ref xLeft, ref yLeft );
			Offset( (Direction)(((int)d + 1) & 0x7), ref xRight, ref yRight );

			if ( xForward < 0 || yForward < 0 || xForward >= map.Width || yForward >= map.Height )
			{
				newZ = 0;
				return false;
			}

			int startZ, startTop;

			ArrayList itemsStart = m_Pools[0];
			ArrayList itemsForward = m_Pools[1];
			ArrayList itemsLeft = m_Pools[2];
			ArrayList itemsRight = m_Pools[3];
			ArrayList items;

			bool ignoreMovableImpassables = m_IgnoreMovableImpassables;
			TileFlag reqFlags = ImpassableSurface;

			if ( m.CanSwim )
				reqFlags |= TileFlag.Wet;

			if ( checkDiagonals )
			{
				Sector sectorStart = map.GetSector( xStart, yStart );
				Sector sectorForward = map.GetSector( xForward, yForward );
				Sector sectorLeft = map.GetSector( xLeft, yLeft );
				Sector sectorRight = map.GetSector( xRight, yRight );

				ArrayList sectors = m_Pools[4];

				sectors.Add( sectorStart );

				if ( !sectors.Contains( sectorForward ) )
					sectors.Add( sectorForward );

				if ( !sectors.Contains( sectorLeft ) )
					sectors.Add( sectorLeft );

				if ( !sectors.Contains( sectorRight ) )
					sectors.Add( sectorRight );

				for ( int i = 0; i < sectors.Count; ++i )
				{
					Sector sector = (Sector)sectors[i];

					items = sector.Items;

					for ( int j = 0; j < items.Count; ++j )
					{
						Item item = (Item)items[j];

						if ( ignoreMovableImpassables && item.Movable && item.ItemData.Impassable )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( sector == sectorStart && item.AtWorldPoint( xStart, yStart ) && item.ItemID < 0x4000 )
							itemsStart.Add( item );
						else if ( sector == sectorForward && item.AtWorldPoint( xForward, yForward ) && item.ItemID < 0x4000 )
							itemsForward.Add( item );
						else if ( sector == sectorLeft && item.AtWorldPoint( xLeft, yLeft ) && item.ItemID < 0x4000 )
							itemsLeft.Add( item );
						else if ( sector == sectorRight && item.AtWorldPoint( xRight, yRight ) && item.ItemID < 0x4000 )
							itemsRight.Add( item );
					}
				}

				if ( m_Pools[4].Count > 0 )
					m_Pools[4].Clear();
			}
			else
			{
				Sector sectorStart = map.GetSector( xStart, yStart );
				Sector sectorForward = map.GetSector( xForward, yForward );

				if ( sectorStart == sectorForward )
				{
					items = sectorStart.Items;

					for ( int i = 0; i < items.Count; ++i )
					{
						Item item = (Item)items[i];

						if ( ignoreMovableImpassables && item.Movable && item.ItemData.Impassable )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( item.AtWorldPoint( xStart, yStart ) && item.ItemID < 0x4000 )
							itemsStart.Add( item );
						else if ( item.AtWorldPoint( xForward, yForward ) && item.ItemID < 0x4000 )
							itemsForward.Add( item );
					}
				}
				else
				{
					items = sectorForward.Items;

					for ( int i = 0; i < items.Count; ++i )
					{
						Item item = (Item)items[i];

						if ( ignoreMovableImpassables && item.Movable && item.ItemData.Impassable )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( item.AtWorldPoint( xForward, yForward ) && item.ItemID < 0x4000 )
							itemsForward.Add( item );
					}

					items = sectorStart.Items;

					for ( int i = 0; i < items.Count; ++i )
					{
						Item item = (Item)items[i];

						if ( ignoreMovableImpassables && item.Movable && item.ItemData.Impassable )
							continue;

						if ( (item.ItemData.Flags & reqFlags) == 0 )
							continue;

						if ( item.AtWorldPoint( xStart, yStart ) && item.ItemID < 0x4000 )
							itemsStart.Add( item );
					}
				}
			}

			GetStartZ( m, map, loc, itemsStart, out startZ, out startTop );

			bool moveIsOk = Check( map, m, itemsForward, xForward, yForward, startTop, startZ, m.CanSwim, m.CantWalk, out newZ );

			if ( moveIsOk && checkDiagonals )
			{
				int hold;

				if ( !Check( map, m, itemsLeft, xLeft, yLeft, startTop, startZ, m.CanSwim, m.CantWalk, out hold ) && !Check( map, m, itemsRight, xRight, yRight, startTop, startZ, m.CanSwim, m.CantWalk, out hold ) )
					moveIsOk = false;
			}

			for ( int i = 0; i < (checkDiagonals ? 4 : 2); ++i )
			{
				if ( m_Pools[i].Count > 0 )
					m_Pools[i].Clear();
			}

			if ( !moveIsOk )
				newZ = startZ;

			return moveIsOk;
		}
		public static CustomRegion FindDRDTRegion(Map map, Point3D loc)
		{
			Point3D p = loc;

			if (p == Point3D.Zero)
				return null;

			if (map == Map.Internal || map == null)
				return null;

			Sector sector = map.GetSector(p);

			if (sector == null || sector.Owner == null || sector == sector.Owner.InvalidSector)
				return null;

			if (sector.Regions == null) //new check 2/2/07
				return null;

			ArrayList list = sector.Regions;

			if (list == null || list.Count == 0)
				return null;

			ArrayList list2 = new ArrayList();

			for (int i = 0; i < list.Count; ++i)
			{
				if (list[i] is Region) //new check 2/2/07 
				{
					Region region = (Region)list[i];

					if (region == null)
						continue;

					if (region.Contains(p))
						list2.Add(region);
				}

			}
			foreach (Region reg in list2)
			{
				if (reg == null)
					continue;

				CustomRegion test = null;

				if (reg is CustomRegion)
				{
					test = reg as CustomRegion;
					if (test != null)
						return test;
				}

			}
			//no custom region found
			return null;
		}
Exemple #29
0
		private static bool IsMobileCountableAtPoint(Mobile m, Point3D p, Map map)
		{
			if (map == null)
				return true;

			Sector sector = map.GetSector(p);
			ArrayList list = sector.Regions;

			bool bReturn = true;

			for (int i = 0; i < list.Count; ++i)
			{
				Region region = (Region)list[i];

				if (region.Contains(p))
				{
					if (region.IsMobileCountable(m) == false)
					{
						bReturn = false;
					}
				}
			}

			return bReturn;
		}
Exemple #30
0
        private static bool CanFit( Map map, int x, int y, int z )
        {
            bool hasSurface = false;

            LandTile lt = map.Tiles.GetLandTile( x, y );
            int lowZ = 0, avgZ = 0, topZ = 0;

            map.GetAverageZ( x, y, ref lowZ, ref avgZ, ref topZ );
            TileFlag landFlags = TileData.LandTable[lt.ID & TileData.MaxLandValue].Flags;

            if ( (landFlags & TileFlag.Impassable) != 0 && topZ > z && (z + 16) > lowZ )
                return false;
            else if ( (landFlags & TileFlag.Impassable) == 0 && z == avgZ && !lt.Ignored )
                hasSurface = true;

            StaticTile[] staticTiles = map.Tiles.GetStaticTiles( x, y );

            bool surface, impassable;

            for ( int i = 0; i < staticTiles.Length; ++i )
            {
                if ( IsDisplayCase( staticTiles[i].ID ) )
                    continue;

                ItemData id = TileData.ItemTable[staticTiles[i].ID & TileData.MaxItemValue];

                surface = id.Surface;
                impassable = id.Impassable;

                if ( (surface || impassable) && (staticTiles[i].Z + id.CalcHeight) > z && (z + 16) > staticTiles[i].Z )
                    return false;
                else if ( surface && !impassable && z == (staticTiles[i].Z + id.CalcHeight) )
                    hasSurface = true;
            }

            Sector sector = map.GetSector( x, y );
            List<Item> items = sector.Items;

            for ( int i = 0; i < items.Count; ++i )
            {
                Item item = items[i];

                if ( item.AtWorldPoint( x, y ) )
                {
                    ItemData id = item.ItemData;
                    surface = id.Surface;
                    impassable = id.Impassable;

                    if ( (surface || impassable) && (item.Z + id.CalcHeight) > z && (z + 16) > item.Z )
                        return false;
                    else if ( surface && !impassable && z == (item.Z + id.CalcHeight) )
                        hasSurface = true;
                }
            }

            return hasSurface;
        }
		private Region FindRegion( Point3D location, Map map )
		{
			Region reg = Region.Find( location, map );

			if( reg is CustomRegion )
			{
				Sector s = map.GetSector( location );
				int highestPriority = 0;

				for( int i = 0; i < s.RegionRects.Count; i++ )
				{
					if( s.RegionRects[i].Region.Priority > highestPriority )
					{
						highestPriority = s.RegionRects[i].Region.Priority;
						reg = s.RegionRects[i].Region;
					}
				}
			}

			if( reg == null || String.IsNullOrEmpty( reg.Name ) || reg.Name == "world" )
				return null;

			return reg;
		}