707 lines
21 KiB
C#
707 lines
21 KiB
C#
using System;
|
|
|
|
using Server.Items;
|
|
using Server.Network;
|
|
using System.Collections.Generic;
|
|
using Server.Multis;
|
|
|
|
namespace Server.Mobiles
|
|
{
|
|
public enum BlockMountType
|
|
{
|
|
None = -1,
|
|
Dazed,
|
|
BolaRecovery,
|
|
DismountRecovery,
|
|
RidingSwipe,
|
|
RidingSwipeEthereal,
|
|
RidingSwipeFlying
|
|
}
|
|
|
|
public abstract class BaseMount : BaseCreature, IMount
|
|
{
|
|
private static Dictionary<Mobile, BlockEntry> m_Table = new Dictionary<Mobile, BlockEntry>();
|
|
private Mobile m_Rider;
|
|
|
|
public BaseMount(string name, int bodyID, int itemID, AIType aiType, FightMode fightMode, int rangePerception, int rangeFight, double activeSpeed, double passiveSpeed)
|
|
: base(aiType, fightMode, rangePerception, rangeFight, activeSpeed, passiveSpeed)
|
|
{
|
|
Name = name;
|
|
Body = bodyID;
|
|
|
|
InternalItem = new MountItem(this, itemID);
|
|
}
|
|
|
|
public BaseMount(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public virtual TimeSpan MountAbilityDelay
|
|
{
|
|
get
|
|
{
|
|
return TimeSpan.Zero;
|
|
}
|
|
}
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public DateTime NextMountAbility { get; set; }
|
|
|
|
public virtual bool AllowMaleRider
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public virtual bool AllowFemaleRider
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
[Hue, CommandProperty(AccessLevel.GameMaster)]
|
|
public override int Hue
|
|
{
|
|
get
|
|
{
|
|
return base.Hue;
|
|
}
|
|
set
|
|
{
|
|
base.Hue = value;
|
|
|
|
if (InternalItem != null)
|
|
InternalItem.Hue = value;
|
|
}
|
|
}
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public int ItemID
|
|
{
|
|
get
|
|
{
|
|
if (InternalItem != null)
|
|
return InternalItem.ItemID;
|
|
else
|
|
return 0;
|
|
}
|
|
set
|
|
{
|
|
if (InternalItem != null)
|
|
InternalItem.ItemID = value;
|
|
}
|
|
}
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public Mobile Rider
|
|
{
|
|
get
|
|
{
|
|
return m_Rider;
|
|
}
|
|
set
|
|
{
|
|
if (m_Rider != value)
|
|
{
|
|
if (value == null)
|
|
{
|
|
Point3D loc = m_Rider.Location;
|
|
Map map = m_Rider.Map;
|
|
|
|
if (map == null || map == Map.Internal)
|
|
{
|
|
loc = m_Rider.LogoutLocation;
|
|
map = m_Rider.LogoutMap;
|
|
}
|
|
|
|
Direction = m_Rider.Direction;
|
|
Location = loc;
|
|
Map = map;
|
|
|
|
NetState ns = m_Rider.NetState;
|
|
|
|
if (ns != null && m_Rider is PlayerMobile && ns.IsEnhancedClient && Commandable)
|
|
{
|
|
ns.Send(new PetWindow((PlayerMobile)m_Rider, this));
|
|
}
|
|
|
|
if (InternalItem != null)
|
|
InternalItem.Internalize();
|
|
}
|
|
else
|
|
{
|
|
if (m_Rider != null)
|
|
Dismount(m_Rider);
|
|
|
|
Dismount(value);
|
|
|
|
if (InternalItem != null)
|
|
value.AddItem(InternalItem);
|
|
|
|
value.Direction = Direction;
|
|
|
|
Internalize();
|
|
}
|
|
|
|
m_Rider = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected Item InternalItem { get; private set; }
|
|
|
|
public static bool OnFlightPath(Mobile m)
|
|
{
|
|
if (!m.Flying)
|
|
return false;
|
|
|
|
StaticTile[] tiles = m.Map.Tiles.GetStaticTiles(m.X, m.Y, true);
|
|
ItemData itemData;
|
|
bool onpath = false;
|
|
|
|
for (int i = 0; i < tiles.Length && !onpath; ++i)
|
|
{
|
|
itemData = TileData.ItemTable[tiles[i].ID & TileData.MaxItemValue];
|
|
onpath = (itemData.Name == "hover over");
|
|
}
|
|
|
|
return onpath;
|
|
}
|
|
|
|
public static void Dismount(Mobile dismounted)
|
|
{
|
|
Dismount(dismounted, dismounted, BlockMountType.None, TimeSpan.MinValue, false);
|
|
}
|
|
|
|
public static void Dismount(Mobile dismounter, Mobile dismounted, BlockMountType blockmounttype, TimeSpan delay)
|
|
{
|
|
Dismount(dismounter, dismounted, blockmounttype, TimeSpan.MinValue, true);
|
|
}
|
|
|
|
public static void Dismount(Mobile dismounter, Mobile dismounted, BlockMountType blockmounttype, TimeSpan delay, bool message)
|
|
{
|
|
if (!dismounted.Mounted && !Server.Spells.Ninjitsu.AnimalForm.UnderTransformation(dismounted) && !dismounted.Flying)
|
|
return;
|
|
|
|
if (dismounted is ChaosDragoonElite)
|
|
{
|
|
dismounter.SendLocalizedMessage(1042047); // You fail to knock the rider from its mount.
|
|
}
|
|
|
|
IMount mount = dismounted.Mount;
|
|
|
|
if (mount != null)
|
|
{
|
|
mount.Rider = null;
|
|
|
|
if (message)
|
|
dismounted.SendLocalizedMessage(1040023); // You have been knocked off of your mount!
|
|
}
|
|
else if (Core.ML && Spells.Ninjitsu.AnimalForm.UnderTransformation(dismounted))
|
|
{
|
|
Spells.Ninjitsu.AnimalForm.RemoveContext(dismounted, true);
|
|
}
|
|
else if (dismounted.Flying)
|
|
{
|
|
if (!OnFlightPath(dismounted))
|
|
{
|
|
dismounted.Flying = false;
|
|
dismounted.Freeze(TimeSpan.FromSeconds(1));
|
|
dismounted.Animate(AnimationType.Land, 0);
|
|
BuffInfo.RemoveBuff(dismounted, BuffIcon.Fly);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (delay != TimeSpan.MinValue)
|
|
{
|
|
SetMountPrevention(dismounted, mount, blockmounttype, delay);
|
|
}
|
|
}
|
|
|
|
public static void SetMountPrevention(Mobile mob, BlockMountType type, TimeSpan duration)
|
|
{
|
|
SetMountPrevention(mob, null, type, duration);
|
|
}
|
|
|
|
public static void SetMountPrevention(Mobile mob, IMount mount, BlockMountType type, TimeSpan duration)
|
|
{
|
|
if (mob == null)
|
|
return;
|
|
|
|
DateTime expiration = DateTime.UtcNow + duration;
|
|
BlockEntry entry = null;
|
|
|
|
if (m_Table.ContainsKey(mob))
|
|
entry = m_Table[mob];
|
|
|
|
if (entry != null)
|
|
{
|
|
entry.m_Type = type;
|
|
entry.m_Expiration = expiration;
|
|
}
|
|
else
|
|
{
|
|
m_Table[mob] = entry = new BlockEntry(mob, mount, type, expiration);
|
|
}
|
|
|
|
BuffInfo.AddBuff(mob, new BuffInfo(BuffIcon.DismountPrevention, 1075635, 1075636, duration, mob));
|
|
}
|
|
|
|
public static void ClearMountPrevention(Mobile mob)
|
|
{
|
|
if (mob != null && m_Table.ContainsKey(mob))
|
|
m_Table.Remove(mob);
|
|
}
|
|
|
|
public static BlockMountType GetMountPrevention(Mobile mob)
|
|
{
|
|
return GetMountPrevention(mob, null);
|
|
}
|
|
|
|
public static BlockMountType GetMountPrevention(Mobile mob, BaseMount mount)
|
|
{
|
|
if (mob == null)
|
|
return BlockMountType.None;
|
|
|
|
BlockEntry entry = null;
|
|
|
|
if (m_Table.ContainsKey(mob))
|
|
entry = m_Table[mob];
|
|
|
|
if (entry == null)
|
|
return BlockMountType.None;
|
|
|
|
if (entry.IsExpired(mount))
|
|
{
|
|
return BlockMountType.None;
|
|
}
|
|
|
|
if (Core.TOL && entry.m_Type >= BlockMountType.RidingSwipe && entry.m_Expiration > DateTime.UtcNow)
|
|
{
|
|
return BlockMountType.DismountRecovery;
|
|
}
|
|
|
|
return entry.m_Type;
|
|
}
|
|
|
|
public static bool CheckMountAllowed(Mobile mob, bool message)
|
|
{
|
|
return CheckMountAllowed(mob, message, false);
|
|
}
|
|
|
|
public static bool CheckMountAllowed(Mobile mob, bool message, bool flying)
|
|
{
|
|
return CheckMountAllowed(mob, null, message, flying);
|
|
}
|
|
|
|
public static bool CheckMountAllowed(Mobile mob, BaseMount mount, bool message, bool flying)
|
|
{
|
|
BlockMountType type = GetMountPrevention(mob, mount);
|
|
|
|
if (type == BlockMountType.None)
|
|
return true;
|
|
|
|
if (message && mob.NetState != null)
|
|
{
|
|
switch (type)
|
|
{
|
|
case BlockMountType.RidingSwipeEthereal:
|
|
case BlockMountType.Dazed:
|
|
{
|
|
mob.PrivateOverheadMessage(MessageType.Regular, 0x3B2, flying ? 1112457 : 1040024, mob.NetState);
|
|
// You are still too dazed from being knocked off your mount to ride!
|
|
break;
|
|
}
|
|
case BlockMountType.BolaRecovery:
|
|
{
|
|
mob.PrivateOverheadMessage(MessageType.Regular, 0x3B2, flying ? 1112455 : 1062910, mob.NetState);
|
|
// You cannot mount while recovering from a bola throw.
|
|
break;
|
|
}
|
|
case BlockMountType.RidingSwipe:
|
|
{
|
|
mob.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1062934, mob.NetState);
|
|
// You must heal your mount before riding it.
|
|
break;
|
|
}
|
|
case BlockMountType.RidingSwipeFlying:
|
|
{
|
|
mob.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1112454, mob.NetState);
|
|
// You must heal your mount before riding it.
|
|
break;
|
|
}
|
|
case BlockMountType.DismountRecovery:
|
|
{
|
|
mob.PrivateOverheadMessage(MessageType.Regular, 0x3B2, flying ? 1112456 : 1070859, mob.NetState);
|
|
// You cannot mount while recovering from a dismount special maneuver.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static void ExpireMountPrevention(Mobile m)
|
|
{
|
|
if(m_Table.ContainsKey(m))
|
|
m_Table.Remove(m);
|
|
|
|
BuffInfo.RemoveBuff(m, BuffIcon.DismountPrevention);
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
|
|
writer.Write((int)1); // version
|
|
|
|
writer.Write(NextMountAbility);
|
|
|
|
writer.Write(m_Rider);
|
|
writer.Write(InternalItem);
|
|
}
|
|
|
|
public override bool OnBeforeDeath()
|
|
{
|
|
Rider = null;
|
|
|
|
return base.OnBeforeDeath();
|
|
}
|
|
|
|
public override void OnAfterDelete()
|
|
{
|
|
if (InternalItem != null)
|
|
InternalItem.Delete();
|
|
|
|
InternalItem = null;
|
|
|
|
base.OnAfterDelete();
|
|
}
|
|
|
|
public override void OnDelete()
|
|
{
|
|
Rider = null;
|
|
|
|
base.OnDelete();
|
|
}
|
|
|
|
public override void OnDeath(Container c)
|
|
{
|
|
base.OnDeath(c);
|
|
|
|
var owner = GetMaster();
|
|
|
|
if (owner != null && m_Table.ContainsKey(owner))
|
|
{
|
|
var entry = m_Table[owner];
|
|
|
|
if (entry.m_Type >= BlockMountType.RidingSwipe && entry.m_Mount == this)
|
|
{
|
|
ExpireMountPrevention(owner);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
|
|
int version = reader.ReadInt();
|
|
|
|
switch ( version )
|
|
{
|
|
case 1:
|
|
{
|
|
NextMountAbility = reader.ReadDateTime();
|
|
goto case 0;
|
|
}
|
|
case 0:
|
|
{
|
|
m_Rider = reader.ReadMobile();
|
|
InternalItem = reader.ReadItem();
|
|
|
|
if (InternalItem == null)
|
|
Delete();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void OnDisallowedRider(Mobile m)
|
|
{
|
|
m.SendMessage("You may not ride this creature.");
|
|
}
|
|
|
|
public override void OnDoubleClick(Mobile from)
|
|
{
|
|
if (IsDeadPet)
|
|
return;
|
|
|
|
if (from.IsBodyMod && !from.Body.IsHuman)
|
|
{
|
|
if (Core.AOS) // You cannot ride a mount in your current form.
|
|
PrivateOverheadMessage(Network.MessageType.Regular, 0x3B2, 1062061, from.NetState);
|
|
else
|
|
from.SendLocalizedMessage(1061628); // You can't do that while polymorphed.
|
|
|
|
return;
|
|
}
|
|
|
|
if (!CheckMountAllowed(from, this, true, false))
|
|
return;
|
|
|
|
if (from.Mount is BaseBoat)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (from.Mounted)
|
|
{
|
|
from.SendLocalizedMessage(1005583); // Please dismount first.
|
|
return;
|
|
}
|
|
|
|
if (from.Race == Race.Gargoyle && from.IsPlayer())
|
|
{
|
|
from.SendLocalizedMessage(1112281);
|
|
OnDisallowedRider(from);
|
|
return;
|
|
}
|
|
|
|
if (from.Female ? !AllowFemaleRider : !AllowMaleRider)
|
|
{
|
|
OnDisallowedRider(from);
|
|
return;
|
|
}
|
|
|
|
if (!Multis.DesignContext.Check(from))
|
|
return;
|
|
|
|
if (from.HasTrade)
|
|
{
|
|
from.SendLocalizedMessage(1042317); // You may not ride at this time
|
|
return;
|
|
}
|
|
|
|
if (from.InRange(this, 1))
|
|
{
|
|
bool canAccess = (from.AccessLevel >= AccessLevel.GameMaster) ||
|
|
(Controlled && ControlMaster == from) ||
|
|
(Summoned && SummonMaster == from);
|
|
|
|
if (canAccess)
|
|
{
|
|
if (Poisoned)
|
|
PrivateOverheadMessage(Network.MessageType.Regular, 0x3B2, 1049692, from.NetState); // This mount is too ill to ride.
|
|
else
|
|
Rider = from;
|
|
}
|
|
else if (!Controlled && !Summoned)
|
|
{
|
|
// That mount does not look broken! You would have to tame it to ride it.
|
|
PrivateOverheadMessage(Network.MessageType.Regular, 0x3B2, 501263, from.NetState);
|
|
}
|
|
else
|
|
{
|
|
// This isn't your mount; it refuses to let you ride.
|
|
PrivateOverheadMessage(Network.MessageType.Regular, 0x3B2, 501264, from.NetState);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
from.SendLocalizedMessage(500206); // That is too far away to ride.
|
|
}
|
|
}
|
|
|
|
public virtual void OnRiderDamaged(Mobile from, ref int amount, bool willKill)
|
|
{
|
|
if (m_Rider == null)
|
|
return;
|
|
|
|
Mobile attacker = from;
|
|
|
|
if (attacker == null)
|
|
attacker = m_Rider.FindMostRecentDamager(true);
|
|
|
|
if (!(attacker == this || attacker == m_Rider || willKill || DateTime.UtcNow > NextMountAbility))
|
|
{
|
|
if (DoMountAbility(amount, from))
|
|
NextMountAbility = DateTime.UtcNow + MountAbilityDelay;
|
|
}
|
|
}
|
|
|
|
[Obsolete("Call: OnRiderDamaged(Mobile from, ref int amount, bool willKill)")]
|
|
public virtual void OnRiderDamaged(int amount, Mobile from, bool willKill)
|
|
{
|
|
OnRiderDamaged(from, ref amount, willKill);
|
|
}
|
|
|
|
public virtual bool DoMountAbility(int damage, Mobile attacker)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
private class BlockEntry
|
|
{
|
|
public Mobile m_Mobile;
|
|
public IMount m_Mount;
|
|
public BlockMountType m_Type;
|
|
public DateTime m_Expiration;
|
|
|
|
public BlockEntry(Mobile m, IMount mount, BlockMountType type, DateTime expiration)
|
|
{
|
|
m_Mobile = m;
|
|
m_Mount = mount;
|
|
m_Type = type;
|
|
m_Expiration = expiration;
|
|
}
|
|
|
|
public bool IsExpired(BaseMount mount)
|
|
{
|
|
if (m_Type >= BlockMountType.RidingSwipe)
|
|
{
|
|
if (Core.SA && DateTime.UtcNow < m_Expiration)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (mount != m_Mount)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
switch (m_Type)
|
|
{
|
|
default:
|
|
case BlockMountType.RidingSwipe:
|
|
{
|
|
if ((!Core.SA && m_Mount == null) || m_Mount is Mobile && ((Mobile)m_Mount).Hits >= ((Mobile)m_Mount).HitsMax)
|
|
{
|
|
BaseMount.ExpireMountPrevention(m_Mobile);
|
|
return true;
|
|
}
|
|
}
|
|
break;
|
|
case BlockMountType.RidingSwipeEthereal:
|
|
{
|
|
BaseMount.ExpireMountPrevention(m_Mobile);
|
|
return true;
|
|
}
|
|
case BlockMountType.RidingSwipeFlying:
|
|
{
|
|
if (m_Mobile.Hits >= m_Mobile.HitsMax)
|
|
{
|
|
BaseMount.ExpireMountPrevention(m_Mobile);
|
|
return true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (DateTime.UtcNow >= m_Expiration)
|
|
{
|
|
BaseMount.ExpireMountPrevention(m_Mobile);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MountItem : Item, IMountItem
|
|
{
|
|
private BaseMount m_Mount;
|
|
public MountItem(BaseMount mount, int itemID)
|
|
: base(itemID)
|
|
{
|
|
Layer = Layer.Mount;
|
|
Movable = false;
|
|
|
|
m_Mount = mount;
|
|
}
|
|
|
|
public MountItem(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override double DefaultWeight
|
|
{
|
|
get
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
public IMount Mount
|
|
{
|
|
get
|
|
{
|
|
return m_Mount;
|
|
}
|
|
}
|
|
public override void OnAfterDelete()
|
|
{
|
|
if (m_Mount != null)
|
|
m_Mount.Delete();
|
|
|
|
m_Mount = null;
|
|
|
|
base.OnAfterDelete();
|
|
}
|
|
|
|
public override DeathMoveResult OnParentDeath(Mobile parent)
|
|
{
|
|
if (m_Mount != null)
|
|
m_Mount.Rider = null;
|
|
|
|
return DeathMoveResult.RemainEquiped;
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
|
|
writer.Write((int)0); // version
|
|
|
|
writer.Write(m_Mount);
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
|
|
int version = reader.ReadInt();
|
|
|
|
switch ( version )
|
|
{
|
|
case 0:
|
|
{
|
|
m_Mount = reader.ReadMobile() as BaseMount;
|
|
|
|
if (m_Mount == null)
|
|
Delete();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|