Reorganizes Project (#41)

This commit is contained in:
Kamron Batman 2019-08-02 18:13:40 -07:00 committed by GitHub
parent 08bf44af9a
commit 3614a66aee
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3499 changed files with 79 additions and 55 deletions

View file

@ -0,0 +1,524 @@
using System;
using System.Collections.Generic;
using Server.Commands;
using Server.Network;
using Server.Targeting;
namespace Server.Items
{
public abstract class BaseDoor : Item, ILockable, ITelekinesisable
{
private static Point3D[] m_Offsets =
{
new Point3D(-1, 1, 0),
new Point3D(1, 1, 0),
new Point3D(-1, 0, 0),
new Point3D(1, -1, 0),
new Point3D(1, 1, 0),
new Point3D(1, -1, 0),
new Point3D(0, 0, 0),
new Point3D(0, -1, 0),
new Point3D(0, 0, 0),
new Point3D(0, 0, 0),
new Point3D(0, 0, 0),
new Point3D(0, 0, 0)
};
private BaseDoor m_Link;
private bool m_Open;
private Timer m_Timer;
public BaseDoor(int closedID, int openedID, int openedSound, int closedSound, Point3D offset) : base(closedID)
{
OpenedID = openedID;
ClosedID = closedID;
OpenedSound = openedSound;
ClosedSound = closedSound;
Offset = offset;
m_Timer = new InternalTimer(this);
Movable = false;
}
public BaseDoor(Serial serial) : base(serial)
{
}
[CommandProperty(AccessLevel.GameMaster)]
public bool Open
{
get => m_Open;
set
{
if (m_Open != value)
{
m_Open = value;
ItemID = m_Open ? OpenedID : ClosedID;
if (m_Open)
Location = new Point3D(X + Offset.X, Y + Offset.Y, Z + Offset.Z);
else
Location = new Point3D(X - Offset.X, Y - Offset.Y, Z - Offset.Z);
Effects.PlaySound(this, Map, m_Open ? OpenedSound : ClosedSound);
if (m_Open)
m_Timer.Start();
else
m_Timer.Stop();
}
}
}
[CommandProperty(AccessLevel.GameMaster)]
public int OpenedID{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public int ClosedID{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public int OpenedSound{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public int ClosedSound{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public Point3D Offset{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public BaseDoor Link
{
get
{
if (m_Link?.Deleted == true)
m_Link = null;
return m_Link;
}
set => m_Link = value;
}
public virtual bool UseChainedFunctionality => false;
[CommandProperty(AccessLevel.GameMaster)]
public bool Locked{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public uint KeyValue{ get; set; }
public void OnTelekinesis(Mobile from)
{
Effects.SendLocationParticles(EffectItem.Create(Location, Map, EffectItem.DefaultDuration), 0x376A, 9, 32, 5022);
Effects.PlaySound(Location, Map, 0x1F5);
Use(from);
}
// Called by RunUO
public static void Initialize()
{
EventSink.OpenDoorMacroUsed += EventSink_OpenDoorMacroUsed;
CommandSystem.Register("Link", AccessLevel.GameMaster, Link_OnCommand);
CommandSystem.Register("ChainLink", AccessLevel.GameMaster, ChainLink_OnCommand);
}
[Usage("Link")]
[Description("Links two targeted doors together.")]
private static void Link_OnCommand(CommandEventArgs e)
{
e.Mobile.BeginTarget(-1, false, TargetFlags.None, Link_OnFirstTarget);
e.Mobile.SendMessage("Target the first door to link.");
}
private static void Link_OnFirstTarget(Mobile from, object targeted)
{
if (!(targeted is BaseDoor door))
{
from.BeginTarget(-1, false, TargetFlags.None, Link_OnFirstTarget);
from.SendMessage("That is not a door. Try again.");
}
else
{
from.BeginTarget(-1, false, TargetFlags.None, Link_OnSecondTarget, door);
from.SendMessage("Target the second door to link.");
}
}
private static void Link_OnSecondTarget(Mobile from, object targeted, BaseDoor first)
{
if (!(targeted is BaseDoor second))
{
from.BeginTarget(-1, false, TargetFlags.None, Link_OnSecondTarget, first);
from.SendMessage("That is not a door. Try again.");
}
else
{
first.Link = second;
second.Link = first;
from.SendMessage("The doors have been linked.");
}
}
[Usage("ChainLink")]
[Description("Chain-links two or more targeted doors together.")]
private static void ChainLink_OnCommand(CommandEventArgs e)
{
e.Mobile.BeginTarget(-1, false, TargetFlags.None, ChainLink_OnTarget, new List<BaseDoor>());
e.Mobile.SendMessage("Target the first of a sequence of doors to link.");
}
private static void ChainLink_OnTarget(Mobile from, object targeted, List<BaseDoor> list)
{
if (!(targeted is BaseDoor door))
{
from.BeginTarget(-1, false, TargetFlags.None, ChainLink_OnTarget, list);
from.SendMessage("That is not a door. Try again.");
}
else
{
if (list.Count > 0 && list[0] == door)
{
if (list.Count >= 2)
{
for (int i = 0; i < list.Count; ++i)
list[i].Link = list[(i + 1) % list.Count];
from.SendMessage("The chain of doors have been linked.");
}
else
{
from.BeginTarget(-1, false, TargetFlags.None, ChainLink_OnTarget, list);
from.SendMessage("You have not yet targeted two unique doors. Target the second door to link.");
}
}
else if (list.Contains(door))
{
from.BeginTarget(-1, false, TargetFlags.None, ChainLink_OnTarget, list);
from.SendMessage(
"You have already targeted that door. Target another door, or retarget the first door to complete the chain.");
}
else
{
list.Add(door);
from.BeginTarget(-1, false, TargetFlags.None, ChainLink_OnTarget, list);
if (list.Count == 1)
from.SendMessage("Target the second door to link.");
else
from.SendMessage("Target another door to link. To complete the chain, retarget the first door.");
}
}
}
private static void EventSink_OpenDoorMacroUsed(OpenDoorMacroEventArgs args)
{
Mobile m = args.Mobile;
if (m.Map != null)
{
int x = m.X, y = m.Y;
switch (m.Direction & Direction.Mask)
{
case Direction.North:
--y;
break;
case Direction.Right:
++x;
--y;
break;
case Direction.East:
++x;
break;
case Direction.Down:
++x;
++y;
break;
case Direction.South:
++y;
break;
case Direction.Left:
--x;
++y;
break;
case Direction.West:
--x;
break;
case Direction.Up:
--x;
--y;
break;
}
Sector sector = m.Map.GetSector(x, y);
foreach (Item item in sector.Items)
if (item.Location.X == x && item.Location.Y == y && item.Z + item.ItemData.Height > m.Z &&
m.Z + 16 > item.Z && item is BaseDoor && m.CanSee(item) && m.InLOS(item))
{
if (m.CheckAlive())
{
m.SendLocalizedMessage(500024); // Opening door...
item.OnDoubleClick(m);
}
break;
}
}
}
public static Point3D GetOffset(DoorFacing facing)
{
return m_Offsets[(int)facing];
}
public bool CanClose()
{
if (!m_Open)
return true;
Map map = Map;
if (map == null)
return false;
Point3D p = new Point3D(X - Offset.X, Y - Offset.Y, Z - Offset.Z);
return CheckFit(map, p, 16);
}
private bool CheckFit(Map map, Point3D p, int height)
{
if (map == Map.Internal)
return false;
int x = p.X;
int y = p.Y;
int z = p.Z;
Sector sector = map.GetSector(x, y);
List<Item> items = sector.Items;
List<Mobile> mobs = sector.Mobiles;
for (int i = 0; i < items.Count; ++i)
{
Item item = items[i];
if (!(item is BaseMulti) && item.ItemID <= TileData.MaxItemValue && item.AtWorldPoint(x, y) &&
!(item is BaseDoor))
{
ItemData id = item.ItemData;
bool surface = id.Surface;
bool impassable = id.Impassable;
if ((surface || impassable) && item.Z + id.CalcHeight > z && z + height > item.Z)
return false;
}
}
for (int i = 0; i < mobs.Count; ++i)
{
Mobile m = mobs[i];
if (m.Location.X == x && m.Location.Y == y)
{
if (m.Hidden && m.AccessLevel > AccessLevel.Player)
continue;
if (!m.Alive)
continue;
if (m.Z + 16 > z && z + height > m.Z)
return false;
}
}
return true;
}
public List<BaseDoor> GetChain()
{
List<BaseDoor> list = new List<BaseDoor>();
BaseDoor c = this;
do
{
list.Add(c);
c = c.Link;
} while (c != null && !list.Contains(c));
return list;
}
public bool IsFreeToClose()
{
if (!UseChainedFunctionality)
return CanClose();
List<BaseDoor> list = GetChain();
bool freeToClose = true;
for (int i = 0; freeToClose && i < list.Count; ++i)
freeToClose = list[i].CanClose();
return freeToClose;
}
public virtual bool IsInside(Mobile from)
{
return false;
}
public virtual bool UseLocks()
{
return true;
}
public virtual void Use(Mobile from)
{
if (Locked && !m_Open && UseLocks())
{
if (from.AccessLevel >= AccessLevel.GameMaster)
{
from.LocalOverheadMessage(MessageType.Regular, 0x3B2,
502502); // That is locked, but you open it with your godly powers.
//from.Send( new MessageLocalized( Serial, ItemID, MessageType.Regular, 0x3B2, 3, 502502, "", "" ) ); // That is locked, but you open it with your godly powers.
}
else if (Key.ContainsKey(from.Backpack, KeyValue))
{
from.LocalOverheadMessage(MessageType.Regular, 0x3B2,
501282); // You quickly unlock, open, and relock the door
}
else if (IsInside(from))
{
from.LocalOverheadMessage(MessageType.Regular, 0x3B2,
501280); // That is locked, but is usable from the inside.
}
else
{
if (Hue == 0x44E && Map == Map.Malas) // doom door into healer room in doom
SendLocalizedMessageTo(from, 1060014); // Only the dead may pass.
else
from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 502503); // That is locked.
return;
}
}
if (m_Open && !IsFreeToClose())
return;
if (m_Open)
OnClosed(from);
else
OnOpened(from);
if (UseChainedFunctionality)
{
bool open = !m_Open;
List<BaseDoor> list = GetChain();
for (int i = 0; i < list.Count; ++i)
list[i].Open = open;
}
else
{
Open = !m_Open;
BaseDoor link = Link;
if (m_Open && link?.Open == false)
link.Open = true;
}
}
public virtual void OnOpened(Mobile from)
{
}
public virtual void OnClosed(Mobile from)
{
}
public override void OnDoubleClick(Mobile from)
{
if (from.AccessLevel == AccessLevel.Player && !from.InRange(GetWorldLocation(), 2))
from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
else
Use(from);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
writer.Write(KeyValue);
writer.Write(m_Open);
writer.Write(Locked);
writer.Write(OpenedID);
writer.Write(ClosedID);
writer.Write(OpenedSound);
writer.Write(ClosedSound);
writer.Write(Offset);
writer.Write(m_Link);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 0:
{
KeyValue = reader.ReadUInt();
m_Open = reader.ReadBool();
Locked = reader.ReadBool();
OpenedID = reader.ReadInt();
ClosedID = reader.ReadInt();
OpenedSound = reader.ReadInt();
ClosedSound = reader.ReadInt();
Offset = reader.ReadPoint3D();
m_Link = reader.ReadItem() as BaseDoor;
m_Timer = new InternalTimer(this);
if (m_Open)
m_Timer.Start();
break;
}
}
}
private class InternalTimer : Timer
{
private BaseDoor m_Door;
public InternalTimer(BaseDoor door) : base(TimeSpan.FromSeconds(20.0), TimeSpan.FromSeconds(10.0))
{
Priority = TimerPriority.OneSecond;
m_Door = door;
}
protected override void OnTick()
{
if (m_Door.Open && m_Door.IsFreeToClose())
m_Door.Open = false;
}
}
}
}

View file

@ -0,0 +1,371 @@
namespace Server.Items
{
public enum DoorFacing
{
WestCW,
EastCCW,
WestCCW,
EastCW,
SouthCW,
NorthCCW,
SouthCCW,
NorthCW,
//Sliding Doors
SouthSW,
SouthSE,
WestSS,
WestSN
}
public class IronGateShort : BaseDoor
{
[Constructible]
public IronGateShort(DoorFacing facing) : base(0x84c + 2 * (int)facing, 0x84d + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public IronGateShort(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class IronGate : BaseDoor
{
[Constructible]
public IronGate(DoorFacing facing) : base(0x824 + 2 * (int)facing, 0x825 + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public IronGate(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class LightWoodGate : BaseDoor
{
[Constructible]
public LightWoodGate(DoorFacing facing) : base(0x839 + 2 * (int)facing, 0x83A + 2 * (int)facing, 0xEB, 0xF2,
GetOffset(facing))
{
}
public LightWoodGate(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class DarkWoodGate : BaseDoor
{
[Constructible]
public DarkWoodGate(DoorFacing facing) : base(0x866 + 2 * (int)facing, 0x867 + 2 * (int)facing, 0xEB, 0xF2,
GetOffset(facing))
{
}
public DarkWoodGate(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class MetalDoor : BaseDoor
{
[Constructible]
public MetalDoor(DoorFacing facing) : base(0x675 + 2 * (int)facing, 0x676 + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public MetalDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class BarredMetalDoor : BaseDoor
{
[Constructible]
public BarredMetalDoor(DoorFacing facing) : base(0x685 + 2 * (int)facing, 0x686 + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public BarredMetalDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class BarredMetalDoor2 : BaseDoor
{
[Constructible]
public BarredMetalDoor2(DoorFacing facing) : base(0x1FED + 2 * (int)facing, 0x1FEE + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public BarredMetalDoor2(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class RattanDoor : BaseDoor
{
[Constructible]
public RattanDoor(DoorFacing facing) : base(0x695 + 2 * (int)facing, 0x696 + 2 * (int)facing, 0xEB, 0xF2,
GetOffset(facing))
{
}
public RattanDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class DarkWoodDoor : BaseDoor
{
[Constructible]
public DarkWoodDoor(DoorFacing facing) : base(0x6A5 + 2 * (int)facing, 0x6A6 + 2 * (int)facing, 0xEA, 0xF1,
GetOffset(facing))
{
}
public DarkWoodDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class MediumWoodDoor : BaseDoor
{
[Constructible]
public MediumWoodDoor(DoorFacing facing) : base(0x6B5 + 2 * (int)facing, 0x6B6 + 2 * (int)facing, 0xEA, 0xF1,
GetOffset(facing))
{
}
public MediumWoodDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class MetalDoor2 : BaseDoor
{
[Constructible]
public MetalDoor2(DoorFacing facing) : base(0x6C5 + 2 * (int)facing, 0x6C6 + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public MetalDoor2(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class LightWoodDoor : BaseDoor
{
[Constructible]
public LightWoodDoor(DoorFacing facing) : base(0x6D5 + 2 * (int)facing, 0x6D6 + 2 * (int)facing, 0xEA, 0xF1,
GetOffset(facing))
{
}
public LightWoodDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class StrongWoodDoor : BaseDoor
{
[Constructible]
public StrongWoodDoor(DoorFacing facing) : base(0x6E5 + 2 * (int)facing, 0x6E6 + 2 * (int)facing, 0xEA, 0xF1,
GetOffset(facing))
{
}
public StrongWoodDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

View file

@ -0,0 +1,257 @@
using System;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Gumps;
using Server.Multis;
namespace Server.Items
{
public class MetalHouseDoor : BaseHouseDoor
{
[Constructible]
public MetalHouseDoor(DoorFacing facing) : base(facing, 0x675 + 2 * (int)facing, 0x676 + 2 * (int)facing, 0xEC, 0xF3,
GetOffset(facing))
{
}
public MetalHouseDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class DarkWoodHouseDoor : BaseHouseDoor
{
[Constructible]
public DarkWoodHouseDoor(DoorFacing facing) : base(facing, 0x6A5 + 2 * (int)facing, 0x6A6 + 2 * (int)facing, 0xEA,
0xF1, GetOffset(facing))
{
}
public DarkWoodHouseDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class GenericHouseDoor : BaseHouseDoor
{
[Constructible]
public GenericHouseDoor(DoorFacing facing, int baseItemID, int openedSound, int closedSound, bool autoAdjust = true)
: base(facing, baseItemID + (autoAdjust ? 2 * (int)facing : 0),
baseItemID + 1 + (autoAdjust ? 2 * (int)facing : 0), openedSound, closedSound, GetOffset(facing))
{
}
public GenericHouseDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public abstract class BaseHouseDoor : BaseDoor, ISecurable
{
public BaseHouseDoor(DoorFacing facing, int closedID, int openedID, int openedSound, int closedSound, Point3D offset)
: base(closedID, openedID, openedSound, closedSound, offset)
{
Facing = facing;
Level = SecureLevel.Anyone;
}
public BaseHouseDoor(Serial serial) : base(serial)
{
}
[CommandProperty(AccessLevel.GameMaster)]
public DoorFacing Facing{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public SecureLevel Level{ get; set; }
public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
{
base.GetContextMenuEntries(from, list);
SetSecureLevelEntry.AddTo(from, this, list);
}
public BaseHouse FindHouse()
{
Point3D loc;
if (Open)
loc = new Point3D(X - Offset.X, Y - Offset.Y, Z - Offset.Z);
else
loc = Location;
return BaseHouse.FindHouseAt(loc, Map, 20);
}
public bool CheckAccess(Mobile m)
{
BaseHouse house = FindHouse();
if (house == null)
return false;
if (!house.IsAosRules)
return true;
if (house.Public ? house.IsBanned(m) : !house.HasAccess(m))
return false;
return house.HasSecureAccess(m, Level);
}
public override void OnOpened(Mobile from)
{
BaseHouse house = FindHouse();
if (house?.IsFriend(from) == true && from.AccessLevel == AccessLevel.Player && house.RefreshDecay())
from.SendLocalizedMessage(1043293); // Your house's age and contents have been refreshed.
if (house?.Public == true && !house.IsFriend(from))
house.Visits++;
}
public override bool UseLocks()
{
return FindHouse()?.IsAosRules != true;
}
public override void Use(Mobile from)
{
if (!CheckAccess(from))
from.SendLocalizedMessage(1061637); // You are not allowed to access this.
else
base.Use(from);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(1); // version
writer.Write((int)Level);
writer.Write((int)Facing);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 1:
{
Level = (SecureLevel)reader.ReadInt();
goto case 0;
}
case 0:
{
if (version < 1)
Level = SecureLevel.Anyone;
Facing = (DoorFacing)reader.ReadInt();
break;
}
}
}
public override bool IsInside(Mobile from)
{
int x, y, w, h;
const int r = 2;
const int bs = r * 2 + 1;
const int ss = r + 1;
switch (Facing)
{
case DoorFacing.WestCW:
case DoorFacing.EastCCW:
x = -r;
y = -r;
w = bs;
h = ss;
break;
case DoorFacing.EastCW:
case DoorFacing.WestCCW:
x = -r;
y = 0;
w = bs;
h = ss;
break;
case DoorFacing.SouthCW:
case DoorFacing.NorthCCW:
x = -r;
y = -r;
w = ss;
h = bs;
break;
case DoorFacing.NorthCW:
case DoorFacing.SouthCCW:
x = 0;
y = -r;
w = ss;
h = bs;
break;
//No way to test the 'insideness' of SE Sliding doors on OSI, so leaving them default to false until further information gained
default: return false;
}
int rx = from.X - X;
int ry = from.Y - Y;
int az = Math.Abs(from.Z - Z);
return rx >= x && rx < x + w && ry >= y && ry < y + h && az <= 4;
}
}
}

View file

@ -0,0 +1,58 @@
namespace Server.Items
{
public class PortcullisNS : BaseDoor
{
[Constructible]
public PortcullisNS() : base(0x6F5, 0x6F5, 0xF0, 0xEF, new Point3D(0, 0, 20))
{
}
public PortcullisNS(Serial serial) : base(serial)
{
}
public override bool UseChainedFunctionality => true;
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PortcullisEW : BaseDoor
{
[Constructible]
public PortcullisEW() : base(0x6F6, 0x6F6, 0xF0, 0xEF, new Point3D(0, 0, 20))
{
}
public PortcullisEW(Serial serial) : base(serial)
{
}
public override bool UseChainedFunctionality => true;
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

View file

@ -0,0 +1,164 @@
namespace Server.Items
{
public class SecretStoneDoor1 : BaseDoor
{
[Constructible]
public SecretStoneDoor1(DoorFacing facing) : base(0xE8 + 2 * (int)facing, 0xE9 + 2 * (int)facing, 0xED, 0xF4,
GetOffset(facing))
{
}
public SecretStoneDoor1(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class SecretDungeonDoor : BaseDoor
{
[Constructible]
public SecretDungeonDoor(DoorFacing facing) : base(0x314 + 2 * (int)facing, 0x315 + 2 * (int)facing, 0xED, 0xF4,
GetOffset(facing))
{
}
public SecretDungeonDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class SecretStoneDoor2 : BaseDoor
{
[Constructible]
public SecretStoneDoor2(DoorFacing facing) : base(0x324 + 2 * (int)facing, 0x325 + 2 * (int)facing, 0xED, 0xF4,
GetOffset(facing))
{
}
public SecretStoneDoor2(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class SecretWoodenDoor : BaseDoor
{
[Constructible]
public SecretWoodenDoor(DoorFacing facing) : base(0x334 + 2 * (int)facing, 0x335 + 2 * (int)facing, 0xED, 0xF4,
GetOffset(facing))
{
}
public SecretWoodenDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class SecretLightWoodDoor : BaseDoor
{
[Constructible]
public SecretLightWoodDoor(DoorFacing facing) : base(0x344 + 2 * (int)facing, 0x345 + 2 * (int)facing, 0xED, 0xF4,
GetOffset(facing))
{
}
public SecretLightWoodDoor(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class SecretStoneDoor3 : BaseDoor
{
[Constructible]
public SecretStoneDoor3(DoorFacing facing) : base(0x354 + 2 * (int)facing, 0x355 + 2 * (int)facing, 0xED, 0xF4,
GetOffset(facing))
{
}
public SecretStoneDoor3(Serial serial) : base(serial)
{
}
public override void Serialize(GenericWriter writer) // Default Serialize method
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader) // Default Deserialize method
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}