public static AddonFitResult CouldFit(Item item, IPoint3D p, Map map, Mobile from, ref BaseHouse house)
        {
            Point3D p3D = new Point3D(p);

            if (!map.CanFit(p3D.X, p3D.Y, p3D.Z, item.ItemData.Height, false, true, (item.Z == 0)))
            {
                return(AddonFitResult.Blocked);
            }
            else if (!BaseAddon.CheckHouse(from, p3D, map, item.ItemData.Height, ref house))
            {
                return(AddonFitResult.NotInHouse);
            }
            else if (house is HouseFoundation)
            {
                return(AddonFitResult.BadHouse);
            }

            if (house != null)
            {
                var doors = house.Doors;

                for (int i = 0; i < doors.Count; ++i)
                {
                    BaseDoor door = doors[i] as BaseDoor;

                    if (door != null && door.Open)
                    {
                        return(AddonFitResult.DoorsNotClosed);
                    }

                    Point3D doorLoc    = door.GetWorldLocation();
                    int     doorHeight = door.ItemData.CalcHeight;

                    int height = item.ItemData.CalcHeight;

                    if (Utility.InRange(doorLoc, p3D, 1) && (p3D.Z == doorLoc.Z || ((p3D.Z + height) > doorLoc.Z && (doorLoc.Z + doorHeight) > p3D.Z)))
                    {
                        return(AddonFitResult.DoorTooClose);
                    }
                }
            }

            return(AddonFitResult.Valid);
        }
Ejemplo n.º 2
0
            protected override void OnTarget(Mobile from, object targeted)
            {
                IPoint3D p   = targeted as IPoint3D;
                Map      map = from.Map;

                if (p == null || map == null || Deed.Deleted)
                {
                    return;
                }

                AddonFitResult result = AddonFitResult.Valid;

                if (Deed.IsChildOf(from.Backpack))
                {
                    BaseHouse house = null;

                    if (!map.CanFit(p.X, p.Y, p.Z, 16, false, true, false))
                    {
                        result = AddonFitResult.Blocked;
                    }
                    else if (!BaseAddon.CheckHouse(from, new Point3D(p), map, 16, ref house))
                    {
                        result = AddonFitResult.NotInHouse;
                    }
                    else
                    {
                        bool east  = BaseAddon.IsWall(p.X - 1, p.Y, p.Z, map);
                        bool south = BaseAddon.IsWall(p.X, p.Y - 1, p.Z, map);

                        if (!south && !east)
                        {
                            result = AddonFitResult.NoWall;
                        }
                        else if (south && east)
                        {
                            from.SendGump(new AddonInterchangeableGump(from, Deed, p, map));
                        }
                        else
                        {
                            BaseAddon addon = Deed.DeployAddon(east, p, map);
                            house.Addons.Add(addon);

                            Deed.Delete();
                        }
                    }

                    switch (result)
                    {
                    default: break;

                    case AddonFitResult.Blocked: from.SendLocalizedMessage(500269); break;    // You cannot build that there.

                    case AddonFitResult.NotInHouse: from.SendLocalizedMessage(500274); break; // You can only place this in a house that you own!

                    case AddonFitResult.NoWall: from.SendLocalizedMessage(500268); break;     // This object needs to be mounted on something.
                    }
                }
                else
                {
                    from.SendLocalizedMessage(1042001);                       // That must be in your pack for you to use it.
                }
            }
Ejemplo n.º 3
0
        public AddonFitResult CouldFit(IPoint3D p, Map map, Mobile from, ref IHouse house)
        {
            if (Deleted)
            {
                return(AddonFitResult.Blocked);
            }

            foreach (AddonContainerComponent c in m_Components)
            {
                Point3D p3D = new Point3D(p.X + c.Offset.X, p.Y + c.Offset.Y, p.Z + c.Offset.Z);

                if (!map.CanFit(p3D.X, p3D.Y, p3D.Z, c.ItemData.Height, false, true, (c.Z == 0)))
                {
                    return(AddonFitResult.Blocked);
                }
                else if (!BaseAddon.CheckHouse(from, p3D, map, c.ItemData.Height, ref house))
                {
                    return(AddonFitResult.NotInHouse);
                }

                if (c.NeedsWall)
                {
                    Point3D wall = c.WallPosition;

                    if (!BaseAddon.IsWall(p3D.X + wall.X, p3D.Y + wall.Y, p3D.Z + wall.Z, map))
                    {
                        return(AddonFitResult.NoWall);
                    }
                }
            }

            Point3D p3 = new Point3D(p.X, p.Y, p.Z);

            if (!map.CanFit(p3.X, p3.Y, p3.Z, ItemData.Height, false, true, (Z == 0)))
            {
                return(AddonFitResult.Blocked);
            }
            else if (!BaseAddon.CheckHouse(from, p3, map, ItemData.Height, ref house))
            {
                return(AddonFitResult.NotInHouse);
            }

            if (NeedsWall)
            {
                Point3D wall = WallPosition;

                if (!BaseAddon.IsWall(p3.X + wall.X, p3.Y + wall.Y, p3.Z + wall.Z, map))
                {
                    return(AddonFitResult.NoWall);
                }
            }

            ArrayList doors = house.Doors;

            for (int i = 0; i < doors.Count; ++i)
            {
                BaseDoor door = doors[i] as BaseDoor;

                if (door != null && door.Open)
                {
                    return(AddonFitResult.DoorsNotClosed);
                }

                Point3D doorLoc    = door.GetWorldLocation();
                int     doorHeight = door.ItemData.CalcHeight;

                foreach (AddonContainerComponent c in m_Components)
                {
                    Point3D addonLoc    = new Point3D(p.X + c.Offset.X, p.Y + c.Offset.Y, p.Z + c.Offset.Z);
                    int     addonHeight = c.ItemData.CalcHeight;

                    if (doorLoc.InRange(addonLoc, 1) && (addonLoc.Z == doorLoc.Z || ((addonLoc.Z + addonHeight) > doorLoc.Z && (doorLoc.Z + doorHeight) > addonLoc.Z)))
                    {
                        return(AddonFitResult.DoorTooClose);
                    }
                }

                Point3D addonLo    = new Point3D(p.X, p.Y, p.Z);
                int     addonHeigh = ItemData.CalcHeight;

                if (doorLoc.InRange(addonLo, 1) && (addonLo.Z == doorLoc.Z || ((addonLo.Z + addonHeigh) > doorLoc.Z && (doorLoc.Z + doorHeight) > addonLo.Z)))
                {
                    return(AddonFitResult.DoorTooClose);
                }
            }

            return(AddonFitResult.Valid);
        }