warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(houses): Converts house packets (1 of 2) (#502)

Browse source 
- [X] Adds `ToSpan()` for SpanWriter.
- [X] Moves house files to UOContent/Multis/Houses
- [X] Adds house packets

### SpanWriter.ToSpan()
`ToSpan()` returns an `SpanOwner` struct which allows access to the buffer as a Span by calling `Span`.

Example:
```cs
public SpanOwner CreatePacket()
{
  var writer = new SpanWriter(0x400);
  // write some stuff
  return writer.ToSpan();
}
```
In this example, we are creating a packet and returning the `SpanOwner` for caching. This means in the future we can do something like this:
```cs
ns.Send(_cachedPacket.Span);
```
Where `_cachedPacket` is the `SpanOwner`

Notes:
Do not use a SpanWriter, or attempt to dispose of it after calling `ToSpan()`. Doing so will probably cause an NPE.
This commit is contained in:
Kamron Batman 2021-02-13 09:18:12 -08:00 • committed by GitHub
parent 952a3e0265
commit d070efeab3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 267 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

4336
Projects/UOContent/Multis/Houses/BaseHouse.cs Normal file
View file

File diff suppressed because it is too large Load diff

756
Projects/UOContent/Multis/Houses/ContestHouses.cs Normal file
View file

@ -0,0 +1,756 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Server.Items;
namespace Server.Multis
{
public enum ContestHouseType
{
Keep,
Castle,
Other
}
public class BaseContestHouse : BaseHouse
{
public BaseContestHouse(ContestHouseType type, int multiID, Mobile owner, int maxLockDown, int maxSecure)
: base(multiID, owner, maxLockDown, maxSecure)
{
HouseType = type;
AutoAddFixtures();
}
public BaseContestHouse(Serial serial) : base(serial)
{
}
public ContestHouseType HouseType { get; set; }
public List<Item> Fixtures { get; private set; }
public virtual int SignPostID => 9;
public override Point3D BaseBanLocation => new(
Components.Min.X,
Components.Height - 1 - Components.Center.Y,
0
);
public override Rectangle2D[] Area
{
get
{
var mcl = Components;
return new[] { new Rectangle2D(mcl.Min.X, mcl.Min.Y, mcl.Width, mcl.Height) };
}
}
protected void SetSign(int xOffset, int yOffset, int zOffset, bool post)
{
SetSign(xOffset, yOffset, zOffset);
var hanger = new Static(0xB9E);
hanger.MoveToWorld(new Point3D(X + xOffset, Y + yOffset, Z + zOffset), Map);
AddFixture(hanger);
if (post)
{
var signPost = new Static(SignPostID);
signPost.MoveToWorld(new Point3D(X + xOffset, Y + yOffset - 1, Z + zOffset), Map);
AddFixture(signPost);
}
}
public override void OnAfterDelete()
{
base.OnAfterDelete();
if (Fixtures == null)
{
return;
}
foreach (var item in Fixtures)
{
item.Delete();
}
}
public override void OnLocationChange(Point3D oldLocation)
{
base.OnLocationChange(oldLocation);
var x = Location.X - oldLocation.X;
var y = Location.Y - oldLocation.Y;
var z = Location.Z - oldLocation.Z;
if (Fixtures == null)
{
return;
}
foreach (var item in Fixtures)
{
item.Location = new Point3D(item.X + x, item.Y + y, item.Z + z);
}
}
public override void OnMapChange()
{
base.OnMapChange();
if (Fixtures == null)
{
return;
}
foreach (var item in Fixtures)
{
item.Map = Map;
}
}
public void AddTeleporters(int id, Point3D offset1, Point3D offset2)
{
var tele1 = new HouseTeleporter(id);
var tele2 = new HouseTeleporter(id);
tele1.Target = tele2;
tele2.Target = tele1;
tele1.MoveToWorld(new Point3D(X + offset1.X, Y + offset1.Y, offset1.Z), Map);
tele2.MoveToWorld(new Point3D(X + offset2.X, Y + offset2.Y, offset2.Z), Map);
AddFixture(tele1);
AddFixture(tele2);
}
public void AddFixture(Item item)
{
Fixtures ??= new List<Item>();
Fixtures.Add(item);
}
public override bool IsInside(Point3D p, int height) =>
base.IsInside(p, height) || Fixtures?.OfType<HouseTeleporter>().Any(fix => fix.Location == p) == true;
public virtual void AutoAddFixtures()
{
var components = MultiData.GetComponents(ItemID);
var teleporters = new Dictionary<int, List<MultiTileEntry>>();
foreach (var entry in components.List.Where(e => e.Flags == 0))
// Teleporters
{
if (entry.ItemId >= 0x181D && entry.ItemId <= 0x1828)
{
if (teleporters.TryGetValue(entry.ItemId, out var result))
{
result.Add(entry);
}
else
{
teleporters.Add(entry.ItemId, new List<MultiTileEntry> { entry });
}
}
else
{
var data = TileData.ItemTable[entry.ItemId & TileData.MaxItemValue];
// door
if ((data.Flags & TileFlag.Door) != 0)
{
AddDoor(entry.ItemId, entry.OffsetX, entry.OffsetY, entry.OffsetZ);
}
else
{
Item st = new Static((int)entry.ItemId);
st.MoveToWorld(new Point3D(X + entry.OffsetX, Y + entry.OffsetY, entry.OffsetZ), Map);
AddFixture(st);
}
}
}
foreach (var door in Doors)
{
foreach (var check in Doors.Where(d => d != door))
{
if (door.InRange(check.Location, 1))
{
door.Link = check;
check.Link = door;
}
}
}
foreach (var (key, value) in teleporters)
{
if (value.Count > 2)
{
Console.WriteLine("Warning: More than 2 teleporters detected for {0:X}!", key);
}
else if (value.Count <= 1)
{
Console.WriteLine("Warning: 1 or less teleporters detected for {0:X}!", key);
continue;
}
AddTeleporters(
key,
new Point3D(value[0].OffsetX, value[0].OffsetY, value[0].OffsetZ),
new Point3D(value[1].OffsetX, value[1].OffsetY, value[1].OffsetZ)
);
}
teleporters.Clear();
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
writer.Write((int)HouseType);
if (Fixtures != null)
{
Fixtures.Tidy();
writer.Write(Fixtures);
}
else
{
writer.Write(0);
}
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
HouseType = (ContestHouseType)reader.ReadInt();
var count = reader.ReadInt();
for (var i = 0; i < count; i++)
{
AddFixture(reader.ReadEntity<Item>());
}
}
}
public class TrinsicKeep : BaseContestHouse
{
public static Rectangle2D[] AreaArray =
{
new(-11, -11, 23, 23), new(-10, 13, 6, 1),
new(-2, 13, 6, 1), new(6, 13, 7, 1)
};
public TrinsicKeep(Mobile owner)
: base(ContestHouseType.Keep, 0x147E, owner, 2113, 18)
{
SetSign(-11, 13, 7, false);
}
public TrinsicKeep(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class GothicRoseCastle : BaseContestHouse
{
public static Rectangle2D[] AreaArray =
{
new(-15, -15, 31, 31),
new(-14, 16, 11, 1),
new(-2, 16, 6, 1),
new(5, 16, 11, 1)
};
public GothicRoseCastle(Mobile owner)
: base(ContestHouseType.Castle, 0x147F, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public GothicRoseCastle(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class ElsaCastle : BaseContestHouse
{
public ElsaCastle(Mobile owner)
: base(ContestHouseType.Castle, 0x1480, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public ElsaCastle(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class Spires : BaseContestHouse
{
public Spires(Mobile owner)
: base(ContestHouseType.Castle, 0x1481, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public Spires(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class CastleOfOceania : BaseContestHouse
{
public CastleOfOceania(Mobile owner)
: base(ContestHouseType.Castle, 0x1482, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public CastleOfOceania(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class FeudalCastle : BaseContestHouse
{
public static Rectangle2D[] AreaArray =
{
new(-15, -15, 31, 31),
new(5, 16, 1, 1),
new(7, 16, 4, 1),
new(12, 16, 1, 1)
};
public FeudalCastle(Mobile owner)
: base(ContestHouseType.Castle, 0x1483, owner, 3281, 28)
{
SetSign(-15, 16, 7, true);
}
public FeudalCastle(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class RobinsNest : BaseContestHouse
{
public RobinsNest(Mobile owner)
: base(ContestHouseType.Keep, 0x1484, owner, 2113, 18)
{
SetSign(-11, 13, 7, false);
}
public RobinsNest(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class TraditionalKeep : BaseContestHouse
{
public static Rectangle2D[] AreaArray =
{
new(-11, -11, 23, 23),
new(-10, 13, 6, 1),
new(-2, 13, 6, 1),
new(6, 13, 7, 1)
};
public TraditionalKeep(Mobile owner)
: base(ContestHouseType.Keep, 0x1485, owner, 2113, 18)
{
SetSign(-11, 13, 7, false);
}
public TraditionalKeep(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class VillaCrowley : BaseContestHouse
{
public VillaCrowley(Mobile owner)
: base(ContestHouseType.Keep, 0x1486, owner, 2113, 18)
{
SetSign(-11, 13, 7, true);
}
public VillaCrowley(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class DarkthornKeep : BaseContestHouse
{
public DarkthornKeep(Mobile owner)
: base(ContestHouseType.Keep, 0x1487, owner, 2113, 18)
{
SetSign(-11, 13, 7, false);
}
public DarkthornKeep(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class SandalwoodKeep : BaseContestHouse
{
public SandalwoodKeep(Mobile owner)
: base(ContestHouseType.Keep, 0x1488, owner, 2113, 18)
{
SetSign(-11, 13, 7, true);
}
public SandalwoodKeep(Serial serial) : base(serial)
{
}
public override int SignPostID => 353;
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class CasaMoga : BaseContestHouse
{
public CasaMoga(Mobile owner)
: base(ContestHouseType.Keep, 0x1489, owner, 2113, 18)
{
SetSign(-11, 13, 7, false);
}
public CasaMoga(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class RobinsRoost : BaseContestHouse
{
public RobinsRoost(Mobile owner)
: base(ContestHouseType.Castle, 0x148A, owner, 3281, 28)
{
SetSign(-15, 16, 7, true);
}
public RobinsRoost(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class Camelot : BaseContestHouse
{
public Camelot(Mobile owner)
: base(ContestHouseType.Castle, 0x148B, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public Camelot(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class LacrimaeInCaelo : BaseContestHouse
{
public LacrimaeInCaelo(Mobile owner)
: base(ContestHouseType.Castle, 0x148C, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public LacrimaeInCaelo(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class OkinawaSweetDreamCastle : BaseContestHouse
{
public static Rectangle2D[] AreaArray =
{
new(-15, -15, 31, 31),
new(-14, 16, 6, 1),
new(-7, 16, 8, 1),
new(10, 16, 5, 1)
};
public OkinawaSweetDreamCastle(Mobile owner)
: base(ContestHouseType.Castle, 0x148D, owner, 3281, 28)
{
SetSign(-15, 16, 7, true);
}
public OkinawaSweetDreamCastle(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class TheSandstoneCastle : BaseContestHouse
{
public TheSandstoneCastle(Mobile owner)
: base(ContestHouseType.Castle, 0x148E, owner, 3281, 28)
{
SetSign(-15, 16, 7, true);
}
public TheSandstoneCastle(Serial serial) : base(serial)
{
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class GrimswindSisters : BaseContestHouse
{
public static Rectangle2D[] AreaArray =
{
new(-15, -15, 31, 31),
new(-14, 16, 9, 1),
new(-3, 16, 8, 1),
new(7, 16, 9, 1)
};
public GrimswindSisters(Mobile owner)
: base(ContestHouseType.Castle, 0x148F, owner, 3281, 28)
{
SetSign(-15, 16, 7, false);
}
public GrimswindSisters(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
}

2691
Projects/UOContent/Multis/Houses/HouseFoundation.cs Normal file
View file

File diff suppressed because it is too large Load diff

84
Projects/UOContent/Multis/Houses/HousePackets.cs Normal file
View file

@ -0,0 +1,84 @@
/*************************************************************************
* ModernUO *
* Copyright (C) 2019-2021 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: HousePackets.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System.Buffers;
using Server.Network;
namespace Server.Multis
{
public static class HousePackets
{
private const int MaxItemsPerStairBuffer = 750;
public static void SendBeginHouseCustomization(this NetState ns, Serial house)
{
if (ns == null)
{
return;
}
var writer = new SpanWriter(stackalloc byte[17]);
writer.Write((byte)0xBF); // Packet Id
writer.Write((ushort)17);
writer.Write((short)0x20); // Sub-packet
writer.Write(house);
writer.Write((byte)0x04); // command
writer.Write((ushort)0x0000);
writer.Write((ushort)0xFFFF);
writer.Write((ushort)0xFFFF);
writer.Write((byte)0xFF);
ns.Send(writer.Span);
}
public static void SendEndHouseCustomization(this NetState ns, Serial house)
{
if (ns == null)
{
return;
}
var writer = new SpanWriter(stackalloc byte[17]);
writer.Write((byte)0xBF); // Packet Id
writer.Write((ushort)17);
writer.Write((short)0x20); // Sub-packet
writer.Write(house);
writer.Write((byte)0x05); // command
writer.Write((ushort)0x0000);
writer.Write((ushort)0xFFFF);
writer.Write((ushort)0xFFFF);
writer.Write((byte)0xFF);
ns.Send(writer.Span);
}
public static void SendDesignStateGeneral(this NetState ns, Serial house, int revision)
{
if (ns == null)
{
return;
}
var writer = new SpanWriter(stackalloc byte[13]);
writer.Write((byte)0xBF); // Packet Id
writer.Write((ushort)13);
writer.Write((short)0x1D); // Sub-packet
writer.Write(house);
writer.Write(revision);
ns.Send(writer.Span);
}
}
}

449
Projects/UOContent/Multis/Houses/HousePlacement.cs Normal file
View file

@ -0,0 +1,449 @@
using System.Collections.Generic;
using Server.Regions;
using Server.Spells;
namespace Server.Multis
{
public enum HousePlacementResult
{
Valid,
BadRegion,
BadLand,
BadStatic,
BadItem,
NoSurface,
BadRegionHidden,
BadRegionTemp,
InvalidCastleKeep,
BadRegionRaffle
}
public static class HousePlacement
{
private const int YardSize = 5;
// Any land tile which matches one of these ID numbers is considered a road and cannot be placed over.
private static readonly int[] m_RoadIDs =
{
0x0071, 0x0078,
0x00E8, 0x00EB,
0x07AE, 0x07B1,
0x3FF4, 0x3FF4,
0x3FF8, 0x3FFB,
0x0442, 0x0479, // Sand stones
0x0501, 0x0510, // Sand stones
0x0009, 0x0015, // Furrows
0x0150, 0x015C // Furrows
};
public static HousePlacementResult Check(Mobile from, int multiID, Point3D center, out List<IEntity> toMove)
{
// If this spot is considered valid, every item and mobile in this list will be moved under the house sign
toMove = new List<IEntity>();
var map = from.Map;
if (map == null || map == Map.Internal)
{
return HousePlacementResult.BadLand; // A house cannot go here
}
if (from.AccessLevel >= AccessLevel.GameMaster)
{
return HousePlacementResult.Valid; // Staff can place anywhere
}
if (map == Map.Ilshenar || SpellHelper.IsFeluccaT2A(map, center))
{
return HousePlacementResult.BadRegion; // No houses in Ilshenar/T2A
}
if (map == Map.Malas && (multiID == 0x007C || multiID == 0x007E))
{
return HousePlacementResult.InvalidCastleKeep;
}
if (Region.Find(center, map).IsPartOf<NoHousingRegion>())
{
return HousePlacementResult.BadRegion;
}
// This holds data describing the internal structure of the house
var mcl = MultiData.GetComponents(multiID);
if (multiID >= 0x13EC && multiID < 0x1D00)
{
HouseFoundation.AddStairsTo(ref mcl); // this is a AOS house, add the stairs
}
// Location of the nortwest-most corner of the house
var start = new Point3D(center.X + mcl.Min.X, center.Y + mcl.Min.Y, center.Z);
// These are storage lists. They hold items and mobiles found in the map for further processing
var items = new List<Item>();
var mobiles = new List<Mobile>();
// These are also storage lists. They hold location values indicating the yard and border locations.
List<Point2D> yard = new(), borders = new();
/* RULES:
*
* 1) All tiles which are around the -outside- of the foundation must not have anything impassable.
* 2) No impassable object or land tile may come in direct contact with any part of the house.
* 3) Five tiles from the front and back of the house must be completely clear of all house tiles.
* 4) The foundation must rest flatly on a surface. Any bumps around the foundation are not allowed.
* 5) No foundation tile may reside over terrain which is viewed as a road.
*/
for (var x = 0; x < mcl.Width; ++x)
{
for (var y = 0; y < mcl.Height; ++y)
{
var tileX = start.X + x;
var tileY = start.Y + y;
var addTiles = mcl.Tiles[x][y];
if (addTiles.Length == 0)
{
continue; // There are no tiles here, continue checking somewhere else
}
var testPoint = new Point3D(tileX, tileY, center.Z);
var reg = Region.Find(testPoint, map);
if (!reg.AllowHousing(from, testPoint)) // Cannot place houses in dungeons, towns, treasure map areas etc
{
if (reg.IsPartOf<TempNoHousingRegion>())
{
return HousePlacementResult.BadRegionTemp;
}
if (reg.IsPartOf<TreasureRegion>() || reg.IsPartOf<HouseRegion>())
{
return HousePlacementResult.BadRegionHidden;
}
if (reg.IsPartOf<HouseRaffleRegion>())
{
return HousePlacementResult.BadRegionRaffle;
}
return HousePlacementResult.BadRegion;
}
var landTile = map.Tiles.GetLandTile(tileX, tileY);
var landID = landTile.ID & TileData.MaxLandValue;
var oldTiles = map.Tiles.GetStaticTiles(tileX, tileY, true);
var sector = map.GetSector(tileX, tileY);
items.Clear();
for (var i = 0; i < sector.Items.Count; ++i)
{
var item = sector.Items[i];
if (item.Visible && item.X == tileX && item.Y == tileY)
{
items.Add(item);
}
}
mobiles.Clear();
for (var i = 0; i < sector.Mobiles.Count; ++i)
{
var m = sector.Mobiles[i];
if (m.X == tileX && m.Y == tileY)
{
mobiles.Add(m);
}
}
int landStartZ = 0, landAvgZ = 0, landTopZ = 0;
map.GetAverageZ(tileX, tileY, ref landStartZ, ref landAvgZ, ref landTopZ);
var hasFoundation = false;
for (var i = 0; i < addTiles.Length; ++i)
{
var addTile = addTiles[i];
if (addTile.ID == 0x1) // Nodraw
{
continue;
}
var addTileFlags = TileData.ItemTable[addTile.ID & TileData.MaxItemValue].Flags;
var isFoundation = addTile.Z == 0 && (addTileFlags & TileFlag.Wall) != 0;
var hasSurface = false;
if (isFoundation)
{
hasFoundation = true;
}
var addTileZ = center.Z + addTile.Z;
var addTileTop = addTileZ + addTile.Height;
if ((addTileFlags & TileFlag.Surface) != 0)
{
addTileTop += 16;
}
if (addTileTop > landStartZ && landAvgZ > addTileZ)
{
return HousePlacementResult.BadLand; // Broke rule #2
}
if (isFoundation &&
(TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags & TileFlag.Impassable) == 0 &&
landAvgZ == center.Z)
{
hasSurface = true;
}
for (var j = 0; j < oldTiles.Length; ++j)
{
var oldTile = oldTiles[j];
var id = TileData.ItemTable[oldTile.ID & TileData.MaxItemValue];
if ((id.Impassable || id.Surface && (id.Flags & TileFlag.Background) == 0) &&
addTileTop > oldTile.Z && oldTile.Z + id.CalcHeight > addTileZ)
{
return HousePlacementResult.BadStatic; // Broke rule #2
}
/*else if (isFoundation && !hasSurface && (id.Flags & TileFlag.Surface) != 0 && (oldTile.Z + id.CalcHeight) == center.Z)
hasSurface = true;*/
}
for (var j = 0; j < items.Count; ++j)
{
var item = items[j];
var id = item.ItemData;
if (addTileTop > item.Z && item.Z + id.CalcHeight > addTileZ)
{
if (item.Movable)
{
toMove.Add(item);
}
else if (id.Impassable || id.Surface && (id.Flags & TileFlag.Background) == 0)
{
return HousePlacementResult.BadItem; // Broke rule #2
}
}
/*else if (isFoundation && !hasSurface && (id.Flags & TileFlag.Surface) != 0 && (item.Z + id.CalcHeight) == center.Z)
{
hasSurface = true;
}*/
}
if (isFoundation && !hasSurface)
{
return HousePlacementResult.NoSurface; // Broke rule #4
}
for (var j = 0; j < mobiles.Count; ++j)
{
var m = mobiles[j];
if (addTileTop > m.Z && m.Z + 16 > addTileZ)
{
toMove.Add(m);
}
}
}
for (var i = 0; i < m_RoadIDs.Length; i += 2)
{
if (landID >= m_RoadIDs[i] && landID <= m_RoadIDs[i + 1])
{
return HousePlacementResult.BadLand; // Broke rule #5
}
}
if (hasFoundation)
{
for (var xOffset = -1; xOffset <= 1; ++xOffset)
{
for (var yOffset = -YardSize; yOffset <= YardSize; ++yOffset)
{
var yardPoint = new Point2D(tileX + xOffset, tileY + yOffset);
if (!yard.Contains(yardPoint))
{
yard.Add(yardPoint);
}
}
}
for (var xOffset = -1; xOffset <= 1; ++xOffset)
{
for (var yOffset = -1; yOffset <= 1; ++yOffset)
{
if (xOffset == 0 && yOffset == 0)
{
continue;
}
// To ease this rule, we will not add to the border list if the tile here is under a base floor (z<=8)
var vx = x + xOffset;
var vy = y + yOffset;
if (vx >= 0 && vx < mcl.Width && vy >= 0 && vy < mcl.Height)
{
var breakTiles = mcl.Tiles[vx][vy];
var shouldBreak = false;
for (var i = 0; !shouldBreak && i < breakTiles.Length; ++i)
{
var breakTile = breakTiles[i];
if (breakTile.Height == 0 && breakTile.Z <= 8 &&
TileData.ItemTable[breakTile.ID & TileData.MaxItemValue].Surface)
{
shouldBreak = true;
}
}
if (shouldBreak)
{
continue;
}
}
var borderPoint = new Point2D(tileX + xOffset, tileY + yOffset);
if (!borders.Contains(borderPoint))
{
borders.Add(borderPoint);
}
}
}
}
}
}
for (var i = 0; i < borders.Count; ++i)
{
var borderPoint = borders[i];
var landTile = map.Tiles.GetLandTile(borderPoint.X, borderPoint.Y);
var landID = landTile.ID & TileData.MaxLandValue;
if ((TileData.LandTable[landID].Flags & TileFlag.Impassable) != 0)
{
return HousePlacementResult.BadLand;
}
for (var j = 0; j < m_RoadIDs.Length; j += 2)
{
if (landID >= m_RoadIDs[j] && landID <= m_RoadIDs[j + 1])
{
return HousePlacementResult.BadLand; // Broke rule #5
}
}
var tiles = map.Tiles.GetStaticTiles(borderPoint.X, borderPoint.Y, true);
for (var j = 0; j < tiles.Length; ++j)
{
var tile = tiles[j];
var id = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
if (id.Impassable || id.Surface && (id.Flags & TileFlag.Background) == 0 &&
tile.Z + id.CalcHeight > center.Z + 2)
{
return HousePlacementResult.BadStatic; // Broke rule #1
}
}
var sector = map.GetSector(borderPoint.X, borderPoint.Y);
var sectorItems = sector.Items;
for (var j = 0; j < sectorItems.Count; ++j)
{
var item = sectorItems[j];
if (item.X != borderPoint.X || item.Y != borderPoint.Y || item.Movable)
{
continue;
}
var id = item.ItemData;
if (id.Impassable || id.Surface && (id.Flags & TileFlag.Background) == 0 &&
item.Z + id.CalcHeight > center.Z + 2)
{
return HousePlacementResult.BadItem; // Broke rule #1
}
}
}
var _sectors = new List<Sector>();
var _houses = new List<BaseHouse>();
for (var i = 0; i < yard.Count; i++)
{
var sector = map.GetSector(yard[i]);
if (!_sectors.Contains(sector))
{
_sectors.Add(sector);
for (var j = 0; j < sector.Multis?.Count; j++)
{
if (sector.Multis[j] is BaseHouse)
{
var _house = (BaseHouse)sector.Multis[j];
if (!_houses.Contains(_house))
{
_houses.Add(_house);
}
}
}
}
}
for (var i = 0; i < yard.Count; ++i)
{
foreach (var b in _houses)
{
if (b.Contains(yard[i]))
{
return HousePlacementResult.BadStatic; // Broke rule #3
}
}
}
/*Point2D yardPoint = yard[i];
IPooledEnumerable eable = map.GetMultiTilesAt( yardPoint.X, yardPoint.Y );
foreach ( StaticTile[] tile in eable )
{
for ( int j = 0; j < tile.Length; ++j )
{
if ((TileData.ItemTable[tile[j].ID & TileData.MaxItemValue].Flags & (TileFlag.Impassable | TileFlag.Surface)) != 0)
{
eable.Free();
return HousePlacementResult.BadStatic; // Broke rule #3
}
}
}
eable.Free();*/
return HousePlacementResult.Valid;
}
}
}

2315
Projects/UOContent/Multis/Houses/HousePlacementTool.cs Normal file
View file

File diff suppressed because it is too large Load diff

290
Projects/UOContent/Multis/Houses/HouseSign.cs Normal file
View file

@ -0,0 +1,290 @@
using System;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Gumps;
namespace Server.Multis
{
public class HouseSign : Item
{
public HouseSign(BaseHouse owner) : base(0xBD2)
{
Owner = owner;
OriginalOwner = Owner.Owner;
Movable = false;
}
public HouseSign(Serial serial) : base(serial)
{
}
public BaseHouse Owner { get; private set; }
[CommandProperty(AccessLevel.GameMaster)]
public bool RestrictDecay
{
get => Owner?.RestrictDecay == true;
set
{
if (Owner != null)
{
Owner.RestrictDecay = value;
}
}
}
[CommandProperty(AccessLevel.GameMaster)]
public Mobile OriginalOwner { get; private set; }
public override bool ForceShowProperties => ObjectPropertyList.Enabled;
public bool GettingProperties { get; private set; }
public string GetName() => Name ?? "An Unnamed House";
public override void OnAfterDelete()
{
base.OnAfterDelete();
if (Owner?.Deleted == false)
{
Owner.Delete();
}
}
public override void AddNameProperty(ObjectPropertyList list)
{
list.Add(1061638); // A House Sign
}
public override void GetProperties(ObjectPropertyList list)
{
base.GetProperties(list);
list.Add(1061639, Utility.FixHtml(GetName())); // Name: ~1_NAME~
list.Add(1061640, Owner?.Owner == null ? "nobody" : Owner.Owner.Name); // Owner: ~1_OWNER~
if (Owner != null)
{
list.Add(Owner.Public ? 1061641 : 1061642); // This House is Open to the Public : This is a Private Home
GettingProperties = true;
var level = Owner.DecayLevel;
GettingProperties = false;
if (level == DecayLevel.DemolitionPending)
{
list.Add(1062497); // Demolition Pending
}
else if (level != DecayLevel.Ageless)
{
if (level == DecayLevel.Collapsed)
{
level = DecayLevel.IDOC;
}
list.Add(1062028, $"#{1043009 + (int)level}"); // Condition: This structure is ...
}
}
}
public override void OnSingleClick(Mobile from)
{
if (Owner != null && BaseHouse.DecayEnabled && Owner.DecayPeriod != TimeSpan.Zero)
{
var message = Owner.DecayLevel switch
{
DecayLevel.Ageless => "ageless",
DecayLevel.Fairly => "fairly worn",
DecayLevel.Greatly => "greatly worn",
DecayLevel.LikeNew => "like new",
DecayLevel.Slightly => "slightly worn",
DecayLevel.Somewhat => "somewhat worn",
_ => "in danger of collapsing"
};
LabelTo(from, "This house is {0}.", message);
}
base.OnSingleClick(from);
}
public void ShowSign(Mobile m)
{
if (Owner != null)
{
if (Owner.IsFriend(m) && m.AccessLevel < AccessLevel.GameMaster)
{
if (Core.ML && Owner.IsOwner(m) || !Core.ML)
{
Owner.RefreshDecay();
}
if (!Core.AOS)
{
m.SendLocalizedMessage(501293); // Welcome back to the house, friend!
}
}
if (Owner.IsAosRules)
{
m.SendGump(new HouseGumpAOS(HouseGumpPageAOS.Information, m, Owner));
}
else
{
m.SendGump(new HouseGump(m, Owner));
}
}
}
public void ClaimGump_Callback(Mobile from, bool okay)
{
if (okay && Owner != null && Owner.Owner == null && Owner.DecayLevel != DecayLevel.DemolitionPending)
{
var canClaim = Owner.CoOwners?.Count > 0 && Owner.IsCoOwner(from) || Owner.IsFriend(from);
if (canClaim && !BaseHouse.HasAccountHouse(from))
{
Owner.Owner = from;
Owner.LastTraded = DateTime.UtcNow;
}
}
ShowSign(from);
}
public override void OnDoubleClick(Mobile m)
{
if (Owner == null)
{
return;
}
if (m.AccessLevel < AccessLevel.GameMaster && Owner.Owner == null &&
Owner.DecayLevel != DecayLevel.DemolitionPending)
{
var canClaim = Owner?.CoOwners.Count > 0 && Owner.IsCoOwner(m) || Owner.IsFriend(m);
if (canClaim && !BaseHouse.HasAccountHouse(m))
{
m.SendGump(
new WarningGump(501036, 32512, 1049719, 32512, 420, 280, okay => ClaimGump_Callback(m, okay))
);
}
}
ShowSign(m);
}
public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
{
base.GetContextMenuEntries(from, list);
if (!BaseHouse.NewVendorSystem || !from.Alive || Owner?.IsAosRules != true)
{
return;
}
if (Owner.AreThereAvailableVendorsFor(from))
{
list.Add(new VendorsEntry(this));
}
if (Owner.VendorInventories.Count > 0)
{
list.Add(new ReclaimVendorInventoryEntry(this));
}
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
writer.Write(Owner);
writer.Write(OriginalOwner);
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
switch (version)
{
case 0:
{
Owner = reader.ReadEntity<BaseHouse>();
OriginalOwner = reader.ReadEntity<Mobile>();
break;
}
}
if (Name == "a house sign")
{
Name = null;
}
}
private class VendorsEntry : ContextMenuEntry
{
private readonly HouseSign m_Sign;
public VendorsEntry(HouseSign sign) : base(6211) => m_Sign = sign;
public override void OnClick()
{
var from = Owner.From;
if (!from.CheckAlive() || m_Sign.Deleted || m_Sign.Owner?.AreThereAvailableVendorsFor(from) != true)
{
return;
}
if (from.Map != m_Sign.Map || !from.InRange(m_Sign, 5))
{
from.SendLocalizedMessage(
1062429
); // You must be within five paces of the house sign to use this option.
}
else
{
from.SendGump(new HouseGumpAOS(HouseGumpPageAOS.Vendors, from, m_Sign.Owner));
}
}
}
private class ReclaimVendorInventoryEntry : ContextMenuEntry
{
private readonly HouseSign m_Sign;
public ReclaimVendorInventoryEntry(HouseSign sign) : base(6213) => m_Sign = sign;
public override void OnClick()
{
var from = Owner.From;
if (m_Sign.Deleted || m_Sign.Owner == null || m_Sign.Owner.VendorInventories.Count == 0 ||
!from.CheckAlive())
{
return;
}
if (from.Map != m_Sign.Map || !from.InRange(m_Sign, 5))
{
from.SendLocalizedMessage(
1062429
); // You must be within five paces of the house sign to use this option.
}
else
{
from.CloseGump<VendorInventoryGump>();
from.SendGump(new VendorInventoryGump(m_Sign.Owner, from));
}
}
}
}
}

200
Projects/UOContent/Multis/Houses/HouseTeleporter.cs Normal file
View file

@ -0,0 +1,200 @@
using System;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Gumps;
using Server.Mobiles;
using Server.Multis;
namespace Server.Items
{
public class HouseTeleporter : Item, ISecurable
{
public HouseTeleporter(int itemID, Item target = null) : base(itemID)
{
Movable = false;
Level = SecureLevel.Anyone;
Target = target;
}
public HouseTeleporter(Serial serial) : base(serial)
{
}
[CommandProperty(AccessLevel.GameMaster)]
public Item Target { get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public SecureLevel Level { get; set; }
public bool CheckAccess(Mobile m)
{
var house = BaseHouse.FindHouseAt(this);
return (house == null || house.Public && !house.IsBanned(m) || house.HasAccess(m)) &&
house?.HasSecureAccess(m, Level) == true;
}
public override bool OnMoveOver(Mobile m)
{
if (Target?.Deleted == false)
{
if (CheckAccess(m))
{
if (!m.Hidden || m.AccessLevel == AccessLevel.Player)
{
new EffectTimer(Location, Map, 2023, 0x1F0, TimeSpan.FromSeconds(0.4)).Start();
}
new DelayTimer(this, m).Start();
}
else
{
m.SendLocalizedMessage(1061637); // You are not allowed to access this.
}
}
return true;
}
public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
{
base.GetContextMenuEntries(from, list);
SetSecureLevelEntry.AddTo(from, this, list);
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(1); // version
writer.Write((int)Level);
writer.Write(Target);
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
switch (version)
{
case 1:
{
Level = (SecureLevel)reader.ReadInt();
goto case 0;
}
case 0:
{
Target = reader.ReadEntity<Item>();
if (version < 1)
{
Level = SecureLevel.Anyone;
}
break;
}
}
}
private class EffectTimer : Timer
{
private readonly int m_EffectID;
private readonly Point3D m_Location;
private readonly Map m_Map;
private readonly int m_SoundID;
public EffectTimer(Point3D p, Map map, int effectID, int soundID, TimeSpan delay) : base(delay)
{
m_Location = p;
m_Map = map;
m_EffectID = effectID;
m_SoundID = soundID;
}
protected override void OnTick()
{
Effects.SendLocationParticles(
EffectItem.Create(m_Location, m_Map, EffectItem.DefaultDuration),
0x3728,
10,
10,
m_EffectID,
0
);
if (m_SoundID != -1)
{
Effects.PlaySound(m_Location, m_Map, m_SoundID);
}
}
}
private class DelayTimer : Timer
{
private readonly Mobile m_Mobile;
private readonly HouseTeleporter m_Teleporter;
public DelayTimer(HouseTeleporter tp, Mobile m) : base(TimeSpan.FromSeconds(1.0))
{
m_Teleporter = tp;
m_Mobile = m;
}
protected override void OnTick()
{
var target = m_Teleporter.Target;
if (target?.Deleted != false)
{
return;
}
var m = m_Mobile;
if (m.Location != m_Teleporter.Location || m.Map != m_Teleporter.Map)
{
return;
}
var p = target.GetWorldTop();
var map = target.Map;
BaseCreature.TeleportPets(m, p, map);
m.MoveToWorld(p, map);
if (m.Hidden && m.AccessLevel != AccessLevel.Player)
{
return;
}
Effects.PlaySound(target.Location, target.Map, 0x1FE);
Effects.SendLocationParticles(
EffectItem.Create(m_Teleporter.Location, m_Teleporter.Map, EffectItem.DefaultDuration),
0x3728,
10,
10,
2023,
0
);
Effects.SendLocationParticles(
EffectItem.Create(target.Location, target.Map, EffectItem.DefaultDuration),
0x3728,
10,
10,
5023,
0
);
new EffectTimer(target.Location, target.Map, 2023, -1, TimeSpan.FromSeconds(0.4)).Start();
}
}
}
}

586
Projects/UOContent/Multis/Houses/Houses.cs Normal file
View file

@ -0,0 +1,586 @@
using Server.Items;
using Server.Multis.Deeds;
namespace Server.Multis
{
public class SmallOldHouse : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-3, -3, 7, 7), new(-1, 4, 3, 1) };
public SmallOldHouse(Mobile owner, int id) : base(id, owner, 425, 3)
{
var keyValue = CreateKeys(owner);
AddSouthDoor(0, 3, 7, keyValue);
SetSign(2, 4, 5);
}
public SmallOldHouse(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(2, 4, 0);
public override int DefaultPrice => 43800;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.TwoStoryFoundations[0];
public override HouseDeed GetDeed()
{
return ItemID switch
{
0x64 => new StonePlasterHouseDeed(),
0x66 => new FieldStoneHouseDeed(),
0x68 => new SmallBrickHouseDeed(),
0x6A => new WoodHouseDeed(),
0x6C => new WoodPlasterHouseDeed(),
0x6E => new ThatchedRoofCottageDeed(),
_ => new ThatchedRoofCottageDeed()
};
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class GuildHouse : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-7, -7, 14, 14), new(-2, 7, 4, 1) };
public GuildHouse(Mobile owner) : base(0x74, owner, 1100, 8)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(-1, 6, 7, keyValue);
SetSign(4, 8, 16);
AddSouthDoor(-3, -1, 7);
AddSouthDoor(3, -1, 7);
}
public GuildHouse(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 144500;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.ThreeStoryFoundations[20];
public override int ConvertOffsetX => -1;
public override int ConvertOffsetY => -1;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(4, 8, 0);
public override HouseDeed GetDeed() => new BrickHouseDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class TwoStoryHouse : BaseHouse
{
public static Rectangle2D[] AreaArray =
{ new(-7, 0, 14, 7), new(-7, -7, 9, 7), new(-4, 7, 4, 1) };
public TwoStoryHouse(Mobile owner, int id) : base(id, owner, 1370, 10)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(-3, 6, 7, keyValue);
SetSign(2, 8, 16);
AddSouthDoor(-3, 0, 7);
AddSouthDoor(id == 0x76 ? -2 : -3, 0, 27);
}
public TwoStoryHouse(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(2, 8, 0);
public override int DefaultPrice => 192400;
public override HouseDeed GetDeed()
{
return ItemID switch
{
0x76 => new TwoStoryWoodPlasterHouseDeed(),
0x78 => new TwoStoryStonePlasterHouseDeed(),
_ => new TwoStoryStonePlasterHouseDeed()
};
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class Tower : BaseHouse
{
public static Rectangle2D[] AreaArray =
{
new(-7, -7, 16, 14), new(-1, 7, 4, 2), new(-11, 0, 4, 7),
new(9, 0, 4, 7)
};
public Tower(Mobile owner) : base(0x7A, owner, 2119, 15)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(false, 0, 6, 6, keyValue);
SetSign(5, 8, 16);
AddSouthDoor(false, 3, -2, 6);
AddEastDoor(false, 1, 4, 26);
AddEastDoor(false, 1, 4, 46);
}
public Tower(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 433200;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.ThreeStoryFoundations[37];
public override int ConvertOffsetY => -1;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(5, 8, 0);
public override HouseDeed GetDeed() => new TowerDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class Keep : BaseHouse // warning: ODD shape!
{
public static Rectangle2D[] AreaArray =
{
new(-11, -11, 7, 8), new(-11, 5, 7, 8), new(6, -11, 7, 8),
new(6, 5, 7, 8), new(-9, -3, 5, 8), new(6, -3, 5, 8),
new(-4, -9, 10, 20), new(-1, 11, 4, 1)
};
public Keep(Mobile owner) : base(0x7C, owner, 2625, 18)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(false, 0, 10, 6, keyValue);
SetSign(5, 12, 16);
}
public Keep(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 665200;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(5, 13, 0);
public override HouseDeed GetDeed() => new KeepDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class Castle : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-15, -15, 31, 31), new(-1, 16, 4, 1) };
public Castle(Mobile owner) : base(0x7E, owner, 4076, 28)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(false, 0, 15, 6, keyValue);
SetSign(5, 17, 16);
AddSouthDoors(false, 0, 11, 6, true);
AddSouthDoors(false, 0, 5, 6, false);
AddSouthDoors(false, -1, -11, 6, false);
}
public Castle(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 1022800;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(5, 17, 0);
public override HouseDeed GetDeed() => new CastleDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class LargePatioHouse : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-7, -7, 15, 14), new(-5, 7, 4, 1) };
public LargePatioHouse(Mobile owner) : base(0x8C, owner, 1100, 8)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(-4, 6, 7, keyValue);
SetSign(1, 8, 16);
AddEastDoor(1, 4, 7);
AddEastDoor(1, -4, 7);
AddSouthDoor(4, -1, 7);
}
public LargePatioHouse(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 152800;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.ThreeStoryFoundations[29];
public override int ConvertOffsetY => -1;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(1, 8, 0);
public override HouseDeed GetDeed() => new LargePatioDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class LargeMarbleHouse : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-7, -7, 15, 14), new(-6, 7, 6, 1) };
public LargeMarbleHouse(Mobile owner) : base(0x96, owner, 1370, 10)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(false, -4, 3, 4, keyValue);
SetSign(1, 8, 11);
}
public LargeMarbleHouse(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 192000;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.ThreeStoryFoundations[29];
public override int ConvertOffsetY => -1;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(1, 8, 0);
public override HouseDeed GetDeed() => new LargeMarbleDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class SmallTower : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-3, -3, 8, 7), new(2, 4, 3, 1) };
public SmallTower(Mobile owner) : base(0x98, owner, 580, 4)
{
var keyValue = CreateKeys(owner);
AddSouthDoor(false, 3, 3, 6, keyValue);
SetSign(1, 4, 5);
}
public SmallTower(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 88500;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.TwoStoryFoundations[6];
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(1, 4, 0);
public override HouseDeed GetDeed() => new SmallTowerDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class LogCabin : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-3, -6, 8, 13) };
public LogCabin(Mobile owner) : base(0x9A, owner, 1100, 8)
{
var keyValue = CreateKeys(owner);
AddSouthDoor(1, 4, 8, keyValue);
SetSign(5, 8, 20);
AddSouthDoor(1, 0, 29);
}
public LogCabin(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 97800;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.TwoStoryFoundations[12];
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(5, 8, 0);
public override HouseDeed GetDeed() => new LogCabinDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class SandStonePatio : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-5, -4, 12, 8), new(-2, 4, 3, 1) };
public SandStonePatio(Mobile owner) : base(0x9C, owner, 850, 6)
{
var keyValue = CreateKeys(owner);
AddSouthDoor(-1, 3, 6, keyValue);
SetSign(4, 6, 24);
}
public SandStonePatio(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 90900;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.TwoStoryFoundations[35];
public override int ConvertOffsetY => -1;
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(4, 6, 0);
public override HouseDeed GetDeed() => new SandstonePatioDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class TwoStoryVilla : BaseHouse
{
public static Rectangle2D[] AreaArray = { new(-5, -5, 11, 11), new(2, 6, 4, 1) };
public TwoStoryVilla(Mobile owner) : base(0x9E, owner, 1100, 8)
{
var keyValue = CreateKeys(owner);
AddSouthDoors(3, 1, 5, keyValue);
SetSign(3, 8, 24);
AddEastDoor(1, 0, 25);
AddSouthDoor(-3, -1, 25);
}
public TwoStoryVilla(Serial serial) : base(serial)
{
}
public override int DefaultPrice => 136500;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.TwoStoryFoundations[31];
public override Rectangle2D[] Area => AreaArray;
public override Point3D BaseBanLocation => new(3, 8, 0);
public override HouseDeed GetDeed() => new VillaDeed();
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
public class SmallShop : BaseHouse
{
public static Rectangle2D[] AreaArray1 = { new(-3, -3, 7, 7), new(-1, 4, 4, 1) };
public static Rectangle2D[] AreaArray2 = { new(-3, -3, 7, 7), new(-2, 4, 3, 1) };
public SmallShop(Mobile owner, int id) : base(id, owner, 425, 3)
{
var keyValue = CreateKeys(owner);
var door = MakeDoor(false, DoorFacing.EastCW);
door.Locked = true;
door.KeyValue = keyValue;
if (door is BaseHouseDoor houseDoor)
{
houseDoor.Facing = DoorFacing.EastCCW;
}
AddDoor(door, -2, 0, id == 0xA2 ? 24 : 27);
// AddSouthDoor( false, -2, 0, 27 - (id == 0xA2 ? 3 : 0), keyValue );
SetSign(3, 4, 7 - (id == 0xA2 ? 2 : 0));
}
public SmallShop(Serial serial) : base(serial)
{
}
public override Rectangle2D[] Area => ItemID == 0x40A2 ? AreaArray1 : AreaArray2;
public override Point3D BaseBanLocation => new(3, 4, 0);
public override int DefaultPrice => 63000;
public override HousePlacementEntry ConvertEntry => HousePlacementEntry.TwoStoryFoundations[0];
public override HouseDeed GetDeed()
{
return ItemID switch
{
0xA0 => new StoneWorkshopDeed(),
0xA2 => new MarbleWorkshopDeed(),
_ => new MarbleWorkshopDeed()
};
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
}
}
}

349
Projects/UOContent/Multis/Houses/MovingCrate.cs Normal file
View file

@ -0,0 +1,349 @@
using System;
using System.Collections.Generic;
using Server.Items;
using Server.Network;
namespace Server.Multis
{
public class MovingCrate : Container
{
public static readonly int MaxItemsPerSubcontainer = 20;
public static readonly int Rows = 3;
public static readonly int Columns = 5;
public static readonly int HorizontalSpacing = 25;
public static readonly int VerticalSpacing = 25;
private Timer m_InternalizeTimer;
public MovingCrate(BaseHouse house) : base(0xE3D)
{
Hue = 0x8A5;
Movable = false;
House = house;
}
public MovingCrate(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1061690; // Packing Crate
public BaseHouse House { get; set; }
public override int DefaultMaxItems => 0;
public override int DefaultMaxWeight => 0;
public override bool IsDecoContainer => false;
/*
public override void AddNameProperties( ObjectPropertyList list )
{
base.AddNameProperties( list );
if (House != null && House.InternalizedVendors.Count > 0)
list.Add( 1061833, House.InternalizedVendors.Count.ToString() ); // This packing crate contains ~1_COUNT~ vendors/barkeepers.
}
*/
public override void DropItem(Item dropped)
{
// 1. Try to stack the item
foreach (var item in Items)
{
if (item is PackingBox)
{
var subItems = item.Items;
for (var i = 0; i < subItems.Count; i++)
{
var subItem = subItems[i];
if (!(subItem is Container) && subItem.StackWith(null, dropped, false))
{
return;
}
}
}
}
// 2. Try to drop the item into an existing container
foreach (var item in Items)
{
if (item is PackingBox packingBox)
{
Container box = packingBox;
var subItems = box.Items;
if (subItems.Count < MaxItemsPerSubcontainer)
{
box.DropItem(dropped);
return;
}
}
}
// 3. Drop the item into a new container
Container subContainer = new PackingBox();
subContainer.DropItem(dropped);
var location = GetFreeLocation();
if (location != Point3D.Zero)
{
AddItem(subContainer);
subContainer.Location = location;
}
else
{
base.DropItem(subContainer);
}
}
private Point3D GetFreeLocation()
{
var positions = new bool[Rows, Columns];
foreach (var item in Items)
{
if (item is PackingBox)
{
var i = (item.Y - Bounds.Y) / VerticalSpacing;
if (i < 0)
{
i = 0;
}
else if (i >= Rows)
{
i = Rows - 1;
}
var j = (item.X - Bounds.X) / HorizontalSpacing;
if (j < 0)
{
j = 0;
}
else if (j >= Columns)
{
j = Columns - 1;
}
positions[i, j] = true;
}
}
for (var i = 0; i < Rows; i++)
{
for (var j = 0; j < Columns; j++)
{
if (!positions[i, j])
{
var x = Bounds.X + j * HorizontalSpacing;
var y = Bounds.Y + i * VerticalSpacing;
return new Point3D(x, y, 0);
}
}
}
return Point3D.Zero;
}
public override bool CheckHold(Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight)
{
if (m.AccessLevel < AccessLevel.GameMaster)
{
m.SendLocalizedMessage(1061145); // You cannot place items into a house moving crate.
return false;
}
return base.CheckHold(m, item, message, checkItems, plusItems, plusWeight);
}
public override bool CheckLift(Mobile from, Item item, ref LRReason reject) => House?.Deleted == false &&
base.CheckLift(from, item, ref reject) && House.IsOwner(from);
public override bool CheckItemUse(Mobile from, Item item) =>
House?.Deleted == false && base.CheckItemUse(from, item) && House.IsOwner(from);
public override void OnItemRemoved(Item item)
{
base.OnItemRemoved(item);
if (TotalItems == 0)
{
Delete();
}
}
public void RestartTimer()
{
if (m_InternalizeTimer == null)
{
m_InternalizeTimer = new InternalizeTimer(this);
m_InternalizeTimer.Start();
}
else
{
m_InternalizeTimer.Stop();
m_InternalizeTimer.Start();
}
}
public void Hide()
{
if (m_InternalizeTimer != null)
{
m_InternalizeTimer.Stop();
m_InternalizeTimer = null;
}
var toRemove = new List<Item>();
foreach (var item in Items)
{
if (item is PackingBox && item.Items.Count == 0)
{
toRemove.Add(item);
}
}
foreach (var item in toRemove)
{
item.Delete();
}
if (TotalItems == 0)
{
Delete();
}
else
{
Internalize();
}
}
public override void OnAfterDelete()
{
base.OnAfterDelete();
if (House?.MovingCrate == this)
{
House.MovingCrate = null;
}
m_InternalizeTimer?.Stop();
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.WriteEncodedInt(1);
writer.Write(House);
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadEncodedInt();
House = reader.ReadEntity<BaseHouse>();
if (House != null)
{
House.MovingCrate = this;
Timer.DelayCall(Hide);
}
else
{
Timer.DelayCall(Delete);
}
if (version == 0)
{
MaxItems = -1; // reset to default
}
}
public class InternalizeTimer : Timer
{
private readonly MovingCrate m_Crate;
public InternalizeTimer(MovingCrate crate) : base(TimeSpan.FromMinutes(5.0))
{
m_Crate = crate;
Priority = TimerPriority.FiveSeconds;
}
protected override void OnTick()
{
m_Crate.Hide();
}
}
}
public class PackingBox : BaseContainer
{
public PackingBox() : base(0x9A8) => Movable = false;
public PackingBox(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1061690; // Packing Crate
public override int DefaultGumpID => 0x4B;
public override int DefaultDropSound => 0x42;
public override Rectangle2D Bounds => new(16, 51, 168, 73);
public override int DefaultMaxItems => 0;
public override int DefaultMaxWeight => 0;
public override void SendCantStoreMessage(Mobile to, Item item)
{
to.SendLocalizedMessage(1061145); // You cannot place items into a house moving crate.
}
public override void OnItemRemoved(Item item)
{
base.OnItemRemoved(item);
if (item.GetBounce() == null && TotalItems == 0)
{
Delete();
}
}
public override void OnItemBounceCleared(Item item)
{
base.OnItemBounceCleared(item);
if (TotalItems == 0)
{
Delete();
}
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.WriteEncodedInt(1); // version
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadEncodedInt();
if (version == 0)
{
MaxItems = -1; // reset to default
}
}
}
}

148
Projects/UOContent/Multis/Houses/PreviewHouse.cs Normal file
View file

@ -0,0 +1,148 @@
using System;
using System.Collections.Generic;
using Server.Items;
namespace Server.Multis
{
public class PreviewHouse : BaseMulti
{
private List<Item> m_Components;
private Timer m_Timer;
public PreviewHouse(int multiID) : base(multiID)
{
m_Components = new List<Item>();
var mcl = Components;
for (var i = 1; i < mcl.List.Length; ++i)
{
var entry = mcl.List[i];
if (entry.Flags == 0)
{
Item item = new Static((int)entry.ItemId);
item.MoveToWorld(new Point3D(X + entry.OffsetX, Y + entry.OffsetY, Z + entry.OffsetZ), Map);
m_Components.Add(item);
}
}
m_Timer = new DecayTimer(this);
m_Timer.Start();
}
public PreviewHouse(Serial serial) : base(serial)
{
}
public override void OnLocationChange(Point3D oldLocation)
{
base.OnLocationChange(oldLocation);
if (m_Components == null)
{
return;
}
var xOffset = X - oldLocation.X;
var yOffset = Y - oldLocation.Y;
var zOffset = Z - oldLocation.Z;
for (var i = 0; i < m_Components.Count; ++i)
{
var item = m_Components[i];
item.MoveToWorld(new Point3D(item.X + xOffset, item.Y + yOffset, item.Z + zOffset), Map);
}
}
public override void OnMapChange()
{
base.OnMapChange();
if (m_Components == null)
{
return;
}
for (var i = 0; i < m_Components.Count; ++i)
{
var item = m_Components[i];
item.Map = Map;
}
}
public override void OnDelete()
{
base.OnDelete();
if (m_Components == null)
{
return;
}
for (var i = 0; i < m_Components.Count; ++i)
{
var item = m_Components[i];
item.Delete();
}
}
public override void OnAfterDelete()
{
m_Timer?.Stop();
m_Timer = null;
base.OnAfterDelete();
}
public override void Serialize(IGenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
writer.Write(m_Components);
}
public override void Deserialize(IGenericReader reader)
{
base.Deserialize(reader);
var version = reader.ReadInt();
switch (version)
{
case 0:
{
m_Components = reader.ReadEntityList<Item>();
break;
}
}
Timer.DelayCall(Delete);
}
private class DecayTimer : Timer
{
private readonly Item m_Item;
public DecayTimer(Item item) : base(TimeSpan.FromSeconds(20.0))
{
m_Item = item;
Priority = TimerPriority.OneSecond;
}
protected override void OnTick()
{
m_Item.Delete();
}
}
}
}