PlayerMobile.cs Still Trying To Wipe...

[Vorspire]

Im still getting "Error while trying to load saved object 'PlayerMobile' Delete this object y/n?"

If ANYONE can tell me ANY reason why it's doing this, then please look at the below scripts and reply...

I'm pretty sure its a serialization thing, the last time i fixed this script, it compiled with the current saves and worked fine.. when it World Saved, and the server was restarted, it gave the error..

Here's the script:

using System;
using System.Collections;
using Server;
using Server.Misc;
using Server.Items;
using Server.Gumps;
using Server.Multis;
using Server.Engines.Help;
using Server.ContextMenus;
using Server.Network;
using Server.Spells;
using Server.Spells.Fifth;
using Server.Spells.Seventh;
using Server.Targeting;
using Server.Engines.Quests;
using Server.Engines.Level;
//using Server.Engines.Level.Abilities;
using Server.Events;
namespace Server.Mobiles
{
 [Flags]
 public enum HeroFlag
 {
  RegainHealth1   = 0x00000001,
  RegainHealth2   = 0x00000002,
  RegainHealth3   = 0x00000004,
  RegainMana1	= 0x00000008,
  RegainMana2	= 0x00000010,
  RegainMana3	= 0x00000020,
  RegainStam1	= 0x00000040,
  RegainStam2	= 0x00000080,
  RegainStam3	= 0x00000100,
  ManaShield1	= 0x00000200,
  ManaShield2	= 0x00000400,
  ManaShield3	= 0x00000800,
  ArrowIce	= 0x00001000,
  ArrowFire	= 0x00002000,
  ArrowMulti	= 0x00004000,
  BioShielding1   = 0x00008000,
  BioShielding2   = 0x00010000,
  VortexProtection1  = 0x00020000,
  VortexProtection2  = 0x00040000,
  VortexProtection3  = 0x00080000,
  LightningProtection1 = 0x00100000,
  LightningProtection2 = 0x00200000,
  LightningProtection3 = 0x00400000,
  ElementalProtection  = 0x00800000,
  Exhaustion	= 0x01000000,
  DoublePower	= 0x02000000	
 }
 
 [Flags]
 public enum PlayerFlag // First 16 bits are reserved for default-distro use, start custom flags at 0x00010000
 {
  None	= 0x00000000,
  Glassblowing  = 0x00000001,
  Masonry	= 0x00000002,
  SandMining   = 0x00000004,
  StoneMining   = 0x00000008,
  ToggleMiningStone = 0x00000010,
  KarmaLocked   = 0x00000020,
  AutoRenewInsurance = 0x00000040,
  UseOwnFilter  = 0x00000080,
  PublicMyRunUO  = 0x00000100,
  PagingSquelched  = 0x00000200,
  IsInEvent   = 0x00020000
 }
 public enum NpcGuild
 {
  None,
  MagesGuild,
  WarriorsGuild,
  ThievesGuild,
  RangersGuild,
  HealersGuild,
  MinersGuild,
  MerchantsGuild,
  TinkersGuild,
  TailorsGuild,
  FishermensGuild,
  BardsGuild,
  BlacksmithsGuild
 }
 public class PlayerMobile : BaseMobile 
 {
  private class CountAndTimeStamp 
  {
   private int m_Count;
   private DateTime m_Stamp;
   public CountAndTimeStamp() 
   {
   }
   public DateTime TimeStamp { get{ return m_Stamp; } }
   public int Count 
   { 
	get { return m_Count; } 
	set { m_Count = value; m_Stamp = DateTime.Now; } 
   }
  }
  private DesignContext m_DesignContext;
  private NpcGuild m_NpcGuild;
  private DateTime m_NpcGuildJoinTime;
  private TimeSpan m_NpcGuildGameTime;
  private PlayerFlag m_Flags;
  private int m_StepsTaken;
  private int m_Profession;
  //LevelSystem:
  private int m_HeroUpPoints;
  public HeroFlag m_HeroFlags;
  private int m_HitsMax;
  private int m_StamMax;
  private int m_ManaMax;
  private int m_StatUpPoints = 0;
  public DateTime LastDeath = DateTime.Now - TimeSpan.FromMinutes(60.0);
  //public BaseHeroAbility m_HeroAbility;
  public ArrayList m_HeroAbilities;
  //Event:
  BaseEvent m_Event;
  BaseTeam m_Team;
  private Container m_EventBackpack;
  public BaseEvent Event 
  {
   get { return m_Event; }
   set { m_Event = value; }
  }
  public BaseTeam Team 
  {
   get { return m_Team; }
   set { m_Team = value; }
  }
  public Container EventBackpack 
  {
   get { return m_EventBackpack; }
   set { m_EventBackpack = value; }
  }
  private int m_TotalPoints;
  private int m_TotalWins;
  private int m_TotalLoses;
  private int m_TotalResKills;
  private int m_TotalResKilled;
  private Mobile m_LastPwner;
  private Mobile m_LastPwned;
  private DateTime m_ResKillTime;
  private int m_TotalPointsLost;
  private int m_TotalPointsSpent;
  private string m_PvpRank = "Noob";
  private int m_PureWins;
  public bool m_IsInPvP = false;
  public bool m_ToggleRank = false;
  public Point3D m_PvPLoseLoc;
  public bool m_Voted = false;
  public bool m_IsInAnArena = false;
  public Point3D m_ArenaLoseLoc;
  public Map m_ArenaLoseMap;
  // Enables Vote Time Delay
  private TimeSpan n_VoteTime = TimeSpan.FromHours( 12.0 );
  private DateTime m_VoteTime;
  [CommandProperty( AccessLevel.Administrator )]
  public TimeSpan VoteTime
  {
   get
   {
	TimeSpan ts = m_VoteTime - DateTime.Now;
	if ( ts < TimeSpan.Zero )
	 ts = TimeSpan.Zero;
	return ts;
   }
   set
   {
	try{ m_VoteTime = DateTime.Now + value; }
	catch{}
   }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public Map ArenaLoseMap
  {
   get{ return m_ArenaLoseMap; }
   set{ m_ArenaLoseMap = value; InvalidateProperties(); }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public string PvpRank
  {
   get{ return m_PvpRank; }
   set{ m_PvpRank = value; InvalidateProperties(); }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalPoints
  {
   get{ return m_TotalPoints; }
   set{ m_TotalPoints = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalWins
  {
   get{ return m_TotalWins; }
   set{ m_TotalWins = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalLoses
  {
   get{ return m_TotalLoses; }
   set{ m_TotalLoses = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalResKills
  {
   get{ return m_TotalResKills; }
   set{ m_TotalResKills = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalResKilled
  {
   get{ return m_TotalResKilled; }
   set{ m_TotalResKilled = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public Mobile LastPwner
  {
   get{ return m_LastPwner; }
   set{ m_LastPwner = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public Mobile LastPwned
  {
   get{ return m_LastPwned; }
   set{ m_LastPwned = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public TimeSpan ResKillTime
  {
   get
   {
	TimeSpan ts = m_ResKillTime - DateTime.Now;
	if ( ts < TimeSpan.Zero )
	 ts = TimeSpan.Zero;
	return ts;
   }
   set
   {
	try{ m_ResKillTime = DateTime.Now + value; }
	catch{}
   }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalPointsLost
  {
   get{ return m_TotalPointsLost; }
   set{ m_TotalPointsLost = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int TotalPointsSpent
  {
   get{ return m_TotalPointsSpent; }
   set{ m_TotalPointsSpent = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public int PureWins
  {
   get{ return m_PureWins; }
   set{ m_PureWins = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public bool IsInPvP
  {
   get{ return m_IsInPvP; }
   set{ m_IsInPvP = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public bool Voted
  {
   get{ return m_Voted; }
   set{ m_Voted = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public bool ToggleRank
  {
   get{ return m_ToggleRank; }
   set{ m_ToggleRank = value; }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public bool IsInAnArena
  {
   get{ return m_IsInAnArena; }
   set{ m_IsInAnArena = value; }
  }
  //End Pvp Point System
  /*[CommandProperty(AccessLevel.GameMaster, AccessLevel.Developer)]
  public ArrayList HeroAbilities 
  {
   get { return m_HeroAbilities; }
   set { m_HeroAbilities = value; }
  }
  [CommandProperty(AccessLevel.GameMaster, AccessLevel.Developer)]
  public int HeroUpPoints 
  {
   get { return m_HeroUpPoints; }
   set { m_HeroUpPoints = value; }
  }*/
  [CommandProperty(AccessLevel.GameMaster, AccessLevel.Developer)]
  public int StatUpPoints 
  {
   get { return m_StatUpPoints; }
   set { m_StatUpPoints = value; }
  }
  public bool GetFlag( HeroFlag flag ) 
  {
   return ( (m_HeroFlags & flag) != 0 );
  }
  public void SetFlag( HeroFlag flag, bool value ) 
  {
   if ( value )
	m_HeroFlags |= flag;
   else
	m_HeroFlags &= ~flag;
  }
  // end
  [CommandProperty( AccessLevel.GameMaster )]
  public int Profession 
  {
   get{ return m_Profession; }
   set{ m_Profession = value; }
  }
  public int StepsTaken 
  {
   get{ return m_StepsTaken; }
   set{ m_StepsTaken = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public NpcGuild NpcGuild 
  {
   get{ return m_NpcGuild; }
   set{ m_NpcGuild = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public DateTime NpcGuildJoinTime 
  {
   get{ return m_NpcGuildJoinTime; }
   set{ m_NpcGuildJoinTime = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public TimeSpan NpcGuildGameTime 
  {
   get{ return m_NpcGuildGameTime; }
   set{ m_NpcGuildGameTime = value; }
  }
  public PlayerFlag Flags 
  {
   get{ return m_Flags; }
   set{ m_Flags = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool PagingSquelched 
  {
   get{ return GetFlag( PlayerFlag.PagingSquelched ); }
   set{ SetFlag( PlayerFlag.PagingSquelched, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool Glassblowing 
  {
   get{ return GetFlag( PlayerFlag.Glassblowing ); }
   set{ SetFlag( PlayerFlag.Glassblowing, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool Masonry 
  {
   get{ return GetFlag( PlayerFlag.Masonry ); }
   set{ SetFlag( PlayerFlag.Masonry, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool SandMining 
  {
   get{ return GetFlag( PlayerFlag.SandMining ); }
   set{ SetFlag( PlayerFlag.SandMining, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool StoneMining 
  {
   get{ return GetFlag( PlayerFlag.StoneMining ); }
   set{ SetFlag( PlayerFlag.StoneMining, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool ToggleMiningStone 
  {
   get{ return GetFlag( PlayerFlag.ToggleMiningStone ); }
   set{ SetFlag( PlayerFlag.ToggleMiningStone, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool KarmaLocked 
  {
   get{ return GetFlag( PlayerFlag.KarmaLocked ); }
   set{ SetFlag( PlayerFlag.KarmaLocked, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool AutoRenewInsurance 
  {
   get{ return GetFlag( PlayerFlag.AutoRenewInsurance ); }
   set{ SetFlag( PlayerFlag.AutoRenewInsurance, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool UseOwnFilter 
  {
   get{ return GetFlag( PlayerFlag.UseOwnFilter ); }
   set{ SetFlag( PlayerFlag.UseOwnFilter, value ); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public bool PublicMyRunUO 
  {
   get{ return GetFlag( PlayerFlag.PublicMyRunUO ); }
   set{ SetFlag( PlayerFlag.PublicMyRunUO, value ); InvalidateMyRunUO(); }
  }
  
  public bool IsInEvent 
  {
   get{ return GetFlag( PlayerFlag.IsInEvent ); }
   set{ SetFlag( PlayerFlag.IsInEvent, value ); }
  }
  [CommandProperty( AccessLevel.Administrator )]
  public Point3D PvPLoseLoc {get{return m_PvPLoseLoc;} set{m_PvPLoseLoc = value; InvalidateProperties();}}
  [CommandProperty( AccessLevel.Administrator )]
  public Point3D ArenaLoseLoc {get{return m_ArenaLoseLoc;} set{m_ArenaLoseLoc = value; InvalidateProperties();}}
  [CommandProperty( AccessLevel.GameMaster )]
  public override int HitsMax 
  {
   get 
   {
	if ( m_HitsMax < 1 )
	 m_HitsMax = RawStr;
	return m_HitsMax + AosAttributes.GetValue( this, AosAttribute.BonusHits );
   }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public int HitsMaxSeed 
  {
   get{ return m_HitsMax; }
   set{ m_HitsMax = value; OnStatsQuery(this); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public override int StamMax 
  {
   get 
   {
	if ( m_StamMax < 1 )
	 m_StamMax = RawDex;
	return m_StamMax + AosAttributes.GetValue( this, AosAttribute.BonusStam );
   }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public int StamMaxSeed 
  {
   get{ return m_StamMax; }
   set{ m_StamMax = value; OnStatsQuery(this); }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public override int ManaMax 
  {
   get 
   {
	if ( m_ManaMax < 1 )
	 m_ManaMax = RawInt;
	return m_ManaMax + AosAttributes.GetValue( this, AosAttribute.BonusMana );
   }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public int ManaMaxSeed 
  {
   get{ return m_ManaMax; }
   set{ m_ManaMax = value; OnStatsQuery(this); }
  }
  public static Direction GetDirection4( Point3D from, Point3D to ) 
  {
   int dx = from.X - to.X;
   int dy = from.Y - to.Y;
   int rx = dx - dy;
   int ry = dx + dy;
   Direction ret;
   if ( rx >= 0 && ry >= 0 )
	ret = Direction.West;
   else if ( rx >= 0 && ry < 0 )
	ret = Direction.South;
   else if ( rx < 0 && ry < 0 )
	ret = Direction.East;
   else
	ret = Direction.North;
   return ret;
  }
  public override bool OnDroppedItemToWorld( Item item, Point3D location ) 
  {
   if ( !base.OnDroppedItemToWorld( item, location ) )
	return false;
   BounceInfo bi = item.GetBounce();
   if ( bi != null ) 
   {
	Type type = item.GetType();
	if ( type.IsDefined( typeof( FurnitureAttribute ), true ) || type.IsDefined( typeof( DynamicFlipingAttribute ), true ) ) 
	{
	 object[] objs = type.GetCustomAttributes( typeof( FlipableAttribute ), true );
	 if ( objs != null && objs.Length > 0 ) 
	 {
	  FlipableAttribute fp = objs[0] as FlipableAttribute;
	  if ( fp != null ) 
	  {
	   int[] itemIDs = fp.ItemIDs;
	   Point3D oldWorldLoc = bi.m_WorldLoc;
	   Point3D newWorldLoc = location;
	   if ( oldWorldLoc.X != newWorldLoc.X || oldWorldLoc.Y != newWorldLoc.Y ) 
	   {
		Direction dir = GetDirection4( oldWorldLoc, newWorldLoc );
		if ( itemIDs.Length == 2 ) 
		{
		 switch ( dir ) 
		 {
		  case Direction.North:
		  case Direction.South: item.ItemID = itemIDs[0]; break;
		  case Direction.East:
		  case Direction.West: item.ItemID = itemIDs[1]; break;
		 }
		}
		else if ( itemIDs.Length == 4 ) 
		{
		 switch ( dir ) 
		 {
		  case Direction.South: item.ItemID = itemIDs[0]; break;
		  case Direction.East: item.ItemID = itemIDs[1]; break;
		  case Direction.North: item.ItemID = itemIDs[2]; break;
		  case Direction.West: item.ItemID = itemIDs[3]; break;
		 }
		}
	   }
	  }
	 }
	}
   }
   return true;
  }
  public bool GetFlag( PlayerFlag flag ) 
  {
   return ( (m_Flags & flag) != 0 );
  }
  public void SetFlag( PlayerFlag flag, bool value ) 
  {
   if ( value )
	m_Flags |= flag;
   else
	m_Flags &= ~flag;
  }
  public DesignContext DesignContext 
  {
   get{ return m_DesignContext; }
   set{ m_DesignContext = value; }
  }
  public static void Initialize() 
  {
   if ( FastwalkPrevention ) 
   {
	PacketHandler ph = PacketHandlers.GetHandler( 0x02 );
	ph.ThrottleCallback = new ThrottlePacketCallback( MovementThrottle_Callback );
   }
   EventSink.Login += new LoginEventHandler( OnLogin );
   EventSink.Logout += new LogoutEventHandler( OnLogout );
   EventSink.Connected += new ConnectedEventHandler( EventSink_Connected );
   EventSink.Disconnected += new DisconnectedEventHandler( EventSink_Disconnected );
  }

  public override void OnSkillInvalidated( Skill skill ) 
  {
   if ( Core.AOS && skill.SkillName == SkillName.MagicResist )
	UpdateResistances();
  }
  public override int GetMaxResistance( ResistanceType type ) 
  {
   int max = base.GetMaxResistance( type );
   if ( type != ResistanceType.Physical && 60 < max && Spells.Fourth.CurseSpell.UnderEffect( this ) )
	max = 60;
   return max;
  }
  private int m_LastGlobalLight = -1, m_LastPersonalLight = -1;
  public override void OnNetStateChanged() 
  {
   m_LastGlobalLight = -1;
   m_LastPersonalLight = -1;
  }
  public override void ComputeBaseLightLevels( out int global, out int personal ) 
  {
   global = LightCycle.ComputeLevelFor( this );
   personal = this.LightLevel;
  }
  public override void CheckLightLevels( bool forceResend ) 
  {
   NetState ns = this.NetState;
   if ( ns == null )
	return;
   int global, personal;
   ComputeLightLevels( out global, out personal );
   if ( !forceResend )
	forceResend = ( global != m_LastGlobalLight || personal != m_LastPersonalLight );
   if ( !forceResend )
	return;
   m_LastGlobalLight = global;
   m_LastPersonalLight = personal;
   ns.Send( GlobalLightLevel.Instantiate( global ) );
   ns.Send( new PersonalLightLevel( this, personal ) );
  }
  public override int GetMinResistance( ResistanceType type ) 
  {
   //int magicResist = (int)(Skills[SkillName.MagicResist].Value * 10);
   int min = int.MinValue;
   /* if ( magicResist >= 1000 )
	 min = 40 + ((magicResist - 1000) / 50);
	else if ( magicResist >= 400 )
	 min = (magicResist - 400) / 15;  */
   if ( min > MaxPlayerResistance )
	min = MaxPlayerResistance;
   int baseMin = base.GetMinResistance( type );
   if ( min < baseMin )
	min = baseMin;
   return min;
  }
  public override void AddNameProperties( ObjectPropertyList list )
  {
   base.AddNameProperties( list );
   if ( PvpPointSystem.EnablePointSystem == true && PvpPointSystem.EnableRankSystem == true )
   {
	if ( m_PvpRank != null && this.AccessLevel == AccessLevel.Player )
	 list.Add( 1060660, "Pvp Rank\t{0}", m_PvpRank );
	else
	 if ( this.AccessLevel == AccessLevel.Player  )
	 list.Add( 1060660, "Pvp Rank\tNoob" );
   }
  }
  private static void OnLogin( LoginEventArgs e ) 
  {
   Mobile from = e.Mobile;
   SacrificeVirtue.CheckAtrophy( from );
   JusticeVirtue.CheckAtrophy( from );
   CompassionVirtue.CheckAtrophy( from );
   if ( AccountHandler.LockdownLevel > AccessLevel.Player ) 
   {
	string notice;
	Accounting.Account acct = from.Account as Accounting.Account;
	if ( acct == null || !acct.HasAccess( from.NetState ) ) 
	{
	 if ( from.AccessLevel == AccessLevel.Player )
	  notice = "The server is currently under lockdown. No players are allowed to log in at this time.";
	 else
	  notice = "The server is currently under lockdown. You do not have sufficient access level to connect.";
	 Timer.DelayCall( TimeSpan.FromSeconds( 1.0 ), new TimerStateCallback( Disconnect ), from );
	}
	else if ( from.AccessLevel >= AccessLevel.Developer ) 
	{
	 notice = "The server is currently under lockdown. As you are an administrator, you may change this from the .Admin gump.";
	}
	else 
	{
	 notice = "The server is currently under lockdown. You have sufficient access level to connect.";
	}
	from.SendGump( new NoticeGump( 1060637, 30720, notice, 0xFFC000, 300, 140, null, null ) );
   }
  }
  private bool m_NoDeltaRecursion;
  public void ValidateEquipment() 
  {
   if ( m_NoDeltaRecursion || Map == null || Map == Map.Internal )
	return;
   if ( this.Items == null )
	return;
   m_NoDeltaRecursion = true;
   Timer.DelayCall( TimeSpan.Zero, new TimerCallback( ValidateEquipment_Sandbox ) );
  }
  private void ValidateEquipment_Sandbox() 
  {
   try 
   {
	if ( Map == null || Map == Map.Internal )
	 return;
	ArrayList items = this.Items;
	if ( items == null )
	 return;
	bool moved = false;
	int str = this.Str;
	int dex = this.Dex;
	int intel = this.Int;
	Mobile from = this;
	for ( int i = items.Count - 1; i >= 0; --i ) 
	{
	 if ( i >= items.Count )
	  continue;
	 Item item = (Item)items[i];
	 if ( item is BaseWeapon ) 
	 {
	  BaseWeapon weapon = (BaseWeapon)item;
	  bool drop = false;
	  if ( dex < weapon.DexRequirement )
	   drop = true;
	  else if ( str < AOS.Scale( weapon.StrRequirement, 100 - weapon.GetLowerStatReq() ) )
	   drop = true;
	  else if ( intel < weapon.IntRequirement )
	   drop = true;
	  if ( drop ) 
	  {
	   string name = weapon.Name;
	   if ( name == null )
		name = String.Format( "#{0}", weapon.LabelNumber );
	   from.SendLocalizedMessage( 1062001, name ); // You can no longer wield your ~1_WEAPON~
	   from.AddToBackpack( weapon );
	   moved = true;
	  }
	 }
	 else if ( item is BaseArmor ) 
	 {
	  BaseArmor armor = (BaseArmor)item;
	  bool drop = false;
	  if ( !armor.AllowMaleWearer && from.Body.IsMale && from.AccessLevel < AccessLevel.GameMaster ) 
	  {
	   drop = true;
	  }
	  else if ( !armor.AllowFemaleWearer && from.Body.IsFemale && from.AccessLevel < AccessLevel.GameMaster ) 
	  {
	   drop = true;
	  }
	  else 
	  {
	   int strBonus = armor.ComputeStatBonus( StatType.Str ), strReq = armor.ComputeStatReq( StatType.Str );
	   int dexBonus = armor.ComputeStatBonus( StatType.Dex ), dexReq = armor.ComputeStatReq( StatType.Dex );
	   int intBonus = armor.ComputeStatBonus( StatType.Int ), intReq = armor.ComputeStatReq( StatType.Int );
	   if ( dex < dexReq || (dex + dexBonus) < 1 )
		drop = true;
	   else if ( str < strReq || (str + strBonus) < 1 )
		drop = true;
	   else if ( intel < intReq || (intel + intBonus) < 1 )
		drop = true;
	  }
	  if ( drop ) 
	  {
	   string name = armor.Name;
	   if ( name == null )
		name = String.Format( "#{0}", armor.LabelNumber );
	   if ( armor is BaseShield )
		from.SendLocalizedMessage( 1062003, name ); // You can no longer equip your ~1_SHIELD~
	   else
		from.SendLocalizedMessage( 1062002, name ); // You can no longer wear your ~1_ARMOR~
	   from.AddToBackpack( armor );
	   moved = true;
	  }
	 }
	}
	if ( moved )
	 from.SendLocalizedMessage( 500647 ); // Some equipment has been moved to your backpack.
   }
   catch ( Exception e ) 
   {
	Console.WriteLine( e );
   }
   finally 
   {
	m_NoDeltaRecursion = false;
   }
  }
  public override void Delta( MobileDelta flag ) 
  {
   base.Delta( flag );
   if ( (flag & MobileDelta.Stat) != 0 )
	ValidateEquipment();
   if ( (flag & (MobileDelta.Name | MobileDelta.Hue)) != 0 )
	InvalidateMyRunUO();
  }
  private static void Disconnect( object state ) 
  {
   NetState ns = ((Mobile)state).NetState;
   if ( ns != null )
	ns.Dispose();
  }
  private static void OnLogout( LogoutEventArgs e ) 
  {
  }
  private static void EventSink_Connected( ConnectedEventArgs e ) 
  {
   ((Accounting.Account)e.Mobile.Account).NetState = e.Mobile.NetState;
   PlayerMobile pm = e.Mobile as PlayerMobile;
   if ( pm != null ) 
   {
	pm.m_SessionStart = DateTime.Now;
	if ( pm.m_Quest != null )
	 pm.m_Quest.StartTimer();
   }
  }
  private static void EventSink_Disconnected( DisconnectedEventArgs e ) 
  {
   Mobile from = e.Mobile;
   DesignContext context = DesignContext.Find( from );
   if ( context != null ) 
   {
	/* Client disconnected
	 *  - Remove design context
	 *  - Eject client from house
	 */
	// Remove design context
	DesignContext.Remove( from );
	// Eject client from house
	from.RevealingAction();
	from.MoveToWorld( context.Foundation.BanLocation, context.Foundation.Map );
   }
   PlayerMobile pm = e.Mobile as PlayerMobile;
   if ( pm != null ) 
   {
	TimeSpan OnlineTime = DateTime.Now - pm.m_SessionStart;
	pm.m_GameTime += OnlineTime;
	if ( pm.m_Quest != null )
	 pm.m_Quest.StopTimer();
   }
   ((Accounting.Account)from.Account).NetState = null;
  }
  public override void RevealingAction() 
  {
   if ( m_DesignContext != null )
	return;
   Spells.Sixth.InvisibilitySpell.RemoveTimer( this );
   base.RevealingAction();
  }
  public override void OnSubItemAdded( Item item ) 
  {
   if ( AccessLevel < AccessLevel.GameMaster && item.IsChildOf( this.Backpack ) ) 
   {
	int maxWeight = WeightOverloading.GetMaxWeight( this );
	int curWeight = Mobile.BodyWeight + this.TotalWeight;
	if ( curWeight > maxWeight )
	 this.SendLocalizedMessage( 1019035, true, String.Format( " : {0} / {1}", curWeight, maxWeight ) );
   }
  }
  public override bool CanBeHarmful( Mobile target, bool message, bool ignoreOurBlessedness ) 
  {
   if (this.AccessLevel > target.AccessLevel || this.AccessLevel >= AccessLevel.Developer)
	return true;
   if ( m_DesignContext != null || (target is PlayerMobile && ((PlayerMobile)target).m_DesignContext != null) )
	return false;
   if ( (target is BaseVendor && ((BaseVendor)target).IsInvulnerable) || target is PlayerVendor || target is TownCrier ) 
   {
	if ( message ) 
	{
	 if ( target.Title == null )
	  SendMessage( "{0} the vendor cannot be harmed.", target.Name );
	 else
	  SendMessage( "{0} {1} cannot be harmed.", target.Name, target.Title );
	}
	return false;
   }
   return base.CanBeHarmful( target, message, ignoreOurBlessedness );
  }
  public override bool CanBeBeneficial( Mobile target, bool message, bool allowDead ) 
  {
   if ( m_DesignContext != null || (target is PlayerMobile && ((PlayerMobile)target).m_DesignContext != null) )
	return false;
   return base.CanBeBeneficial( target, message, allowDead );
  }
  public override bool CheckContextMenuDisplay( IEntity target ) 
  {
   return ( m_DesignContext == null );
  }
  public override void OnItemAdded( Item item ) 
  {
   base.OnItemAdded( item );
   if ( item is BaseArmor || item is BaseWeapon ) 
   {
	Hits=Hits; Stam=Stam; Mana=Mana;
   }
   InvalidateMyRunUO();
  }
  public override void OnItemRemoved( Item item ) 
  {
   base.OnItemRemoved( item );
   if ( item is BaseArmor || item is BaseWeapon ) 
   {
	Hits=Hits; Stam=Stam; Mana=Mana;
   }
   InvalidateMyRunUO();
  }
  /*public override int HitsMax
  {
   get
   {
	int strBase;
	int strOffs = GetStatOffset( StatType.Str );
	if ( Core.AOS )
	{
	 strBase = this.Str;
	 strOffs += AosAttributes.GetValue( this, AosAttribute.BonusHits );
	}
	else
	{
	 strBase = this.RawStr;
	}
	return (strBase / 2) + 50 + strOffs;
   }
  }
  public override int StamMax
  {
   get{ return base.StamMax + AosAttributes.GetValue( this, AosAttribute.BonusStam ); }
  }
  public override int ManaMax
  {
   get{ return base.ManaMax + AosAttributes.GetValue( this, AosAttribute.BonusMana ); }
  }*/
  public override bool Move( Direction d ) 
  {
   NetState ns = this.NetState;
   if ( ns != null ) 
   {
	Gump[] gumps = ns.Gumps;
	for ( int i = 0; i < gumps.Length; ++i ) 
	{
	 if ( gumps[i] is ResurrectGump ) 
	 {
	  if ( Alive ) 
	  {
	   CloseGump( typeof( ResurrectGump ) );
	  }
	  else 
	  {
	   SendLocalizedMessage( 500111 ); // You are frozen and cannot move.
	   return false;
	  }
	 }
	}
   }
   TimeSpan speed = ComputeMovementSpeed( d );
   if ( !base.Move( d ) )
	return false;
   m_NextMovementTime += speed;
   return true;
  }
  public override bool CheckMovement( Direction d, out int newZ ) 
  {
   DesignContext context = m_DesignContext;
   if ( context == null )
	return base.CheckMovement( d, out newZ );
   HouseFoundation foundation = context.Foundation;
   newZ = foundation.Z + HouseFoundation.GetLevelZ( context.Level );
   int newX = this.X, newY = this.Y;
   Movement.Movement.Offset( d, ref newX, ref newY );
   int startX = foundation.X + foundation.Components.Min.X + 1;
   int startY = foundation.Y + foundation.Components.Min.Y + 1;
   int endX = startX + foundation.Components.Width - 1;
   int endY = startY + foundation.Components.Height - 2;
   return ( newX >= startX && newY >= startY && newX < endX && newY < endY && Map == foundation.Map );
  }
  public override bool AllowSkillUse( SkillName skill ) 
  {
   return DesignContext.Check( this );
  }
  private bool m_LastProtectedMessage;
  private int m_NextProtectionCheck = 10;
  public virtual void RecheckTownProtection() 
  {
   m_NextProtectionCheck = 10;
   Regions.GuardedRegion reg = this.Region as Regions.GuardedRegion;
   bool isProtected = ( reg != null && !reg.IsDisabled() );
   if ( isProtected != m_LastProtectedMessage ) 
   {
	if ( isProtected )
	 SendLocalizedMessage( 500112 ); // You are now under the protection of the town guards.
	else
	 SendLocalizedMessage( 500113 ); // You have left the protection of the town guards.
	m_LastProtectedMessage = isProtected;
   }
  }
  public override void MoveToWorld( Point3D loc, Map map ) 
  {
   base.MoveToWorld( loc, map );
   RecheckTownProtection();
  }
  public override void SetLocation( Point3D loc, bool isTeleport ) 
  {
   base.SetLocation( loc, isTeleport );
   if ( isTeleport || --m_NextProtectionCheck == 0 )
	RecheckTownProtection();
  }
  public override void GetContextMenuEntries( Mobile from, ArrayList list ) 
  {
   base.GetContextMenuEntries( from, list );
   if ( from == this ) 
   {
	if ( m_Quest != null )
	 m_Quest.GetContextMenuEntries( list );
	if ( Alive && InsuranceEnabled ) 
	{
	 list.Add( new CallbackEntry( 6201, new ContextCallback( ToggleItemInsurance ) ) );
	 if ( AutoRenewInsurance )
	  list.Add( new CallbackEntry( 6202, new ContextCallback( CancelRenewInventoryInsurance ) ) );
	 else
	  list.Add( new CallbackEntry( 6200, new ContextCallback( AutoRenewInventoryInsurance ) ) );
	}
	// TODO: Toggle champ titles
	BaseHouse house = BaseHouse.FindHouseAt( this );
	if ( house != null && house.IsAosRules )
	 list.Add( new CallbackEntry( 6207, new ContextCallback( LeaveHouse ) ) );
	if ( m_JusticeProtectors.Count > 0 )
	 list.Add( new CallbackEntry( 6157, new ContextCallback( CancelProtection ) ) );
   }
  }
  private void CancelProtection() 
  {
   for ( int i = 0; i < m_JusticeProtectors.Count; ++i ) 
   {
	Mobile prot = (Mobile)m_JusticeProtectors[i];
	string args = String.Format( "{0}\t{1}", this.Name, prot.Name );
	prot.SendLocalizedMessage( 1049371, args ); // The protective relationship between ~1_PLAYER1~ and ~2_PLAYER2~ has been ended.
	this.SendLocalizedMessage( 1049371, args ); // The protective relationship between ~1_PLAYER1~ and ~2_PLAYER2~ has been ended.
   }
   m_JusticeProtectors.Clear();
  }
  private void ToggleItemInsurance() 
  {
   if ( !CheckAlive() )
	return;
   BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
   SendLocalizedMessage( 1060868 ); // Target the item you wish to toggle insurance status on <ESC> to cancel
  }
  private bool CanInsure( Item item ) 
  {
   if ( item is Container )
	return false;
   if ( item is Spellbook || item is Runebook || item is PotionKeg )
	return false;
   if ( item.Stackable )
	return false;
   if ( item.LootType == LootType.Cursed )
	return false;
   if ( item.ItemID == 0x204E ) // death shroud
	return false;
   return true;
  }
  private void ToggleItemInsurance_Callback( Mobile from, object obj ) 
  {
   if ( !CheckAlive() )
	return;
   Item item = obj as Item;
   if ( item == null || !item.IsChildOf( this ) ) 
   {
	BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
	SendLocalizedMessage( 1060871, "", 0x23 ); // You can only insure items that you have equipped or that are in your backpack
   }
   else if ( item.Insured ) 
   {
	item.Insured = false;
	SendLocalizedMessage( 1060874, "", 0x35 ); // You cancel the insurance on the item
	BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
	SendLocalizedMessage( 1060868, "", 0x23 ); // Target the item you wish to toggle insurance status on <ESC> to cancel
   }
   else if ( !CanInsure( item ) ) 
   {
	BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
	SendLocalizedMessage( 1060869, "", 0x23 ); // You cannot insure that
   }
   else if ( item.LootType == LootType.Blessed || item.LootType == LootType.Newbied || item.BlessedFor == from ) 
   {
	BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
	SendLocalizedMessage( 1060870, "", 0x23 ); // That item is blessed and does not need to be insured
	SendLocalizedMessage( 1060869, "", 0x23 ); // You cannot insure that
   }
   else 
   {
	if ( !item.PayedInsurance ) 
	{
	 if ( Banker.Withdraw( from, 600 ) ) 
	 {
	  SendLocalizedMessage( 1060398, "600" ); // ~1_AMOUNT~ gold has been withdrawn from your bank box.
	  item.PayedInsurance = true;
	 }
	 else 
	 {
	  SendLocalizedMessage( 1061079, "", 0x23 ); // You lack the funds to purchase the insurance
	  return;
	 }
	}
	item.Insured = true;
	SendLocalizedMessage( 1060873, "", 0x23 ); // You have insured the item
	BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
	SendLocalizedMessage( 1060868, "", 0x23 ); // Target the item you wish to toggle insurance status on <ESC> to cancel
   }
  }
  private void AutoRenewInventoryInsurance() 
  {
   if ( !CheckAlive() )
	return;
   SendLocalizedMessage( 1060881, "", 0x23 ); // You have selected to automatically reinsure all insured items upon death
   AutoRenewInsurance = true;
  }
  private void CancelRenewInventoryInsurance() 
  {
   if ( !CheckAlive() )
	return;
   SendLocalizedMessage( 1061075, "", 0x23 ); // You have cancelled automatically reinsuring all insured items upon death
   AutoRenewInsurance = false;
  }
  // TODO: Champ titles, toggle
  private void LeaveHouse() 
  {
   BaseHouse house = BaseHouse.FindHouseAt( this );
   if ( house != null )
	this.Location = house.BanLocation;
  }
  private delegate void ContextCallback();
  private class CallbackEntry : ContextMenuEntry 
  {
   private ContextCallback m_Callback;
   public CallbackEntry( int number, ContextCallback callback ) : this( number, -1, callback ) 
   {
   }
   public CallbackEntry( int number, int range, ContextCallback callback ) : base( number, range ) 
   {
	m_Callback = callback;
   }
   public override void OnClick() 
   {
	if ( m_Callback != null )
	 m_Callback();
   }
  }
  public override void OnDoubleClick( Mobile from ) 
  {
   if ( this == from && !Warmode ) 
   {
	IMount mount = Mount;
	if ( mount != null && !DesignContext.Check( this ) )
	 return;
   }
   base.OnDoubleClick( from );
  }
  protected override bool OnMove( Direction d )
  {
   if( AccessLevel != AccessLevel.Player )
	return true;
   if( Hidden )
   {
	if( !Mounted && Skills.Stealth.Value >= 25.0 )
	{
	 bool running = (d & Direction.Running) != 0;
	 if( running )
	 {
	  if( (AllowedStealthSteps -= 2) <= 0 )
	   RevealingAction();
	 }
	 else if( AllowedStealthSteps-- <= 0 )
	 {
	  //Server.SkillHandlers.Stealth.OnUse( this );
	  RevealingAction();
	 }   
	}
	else if( Mounted && Skills.Stealth.Value >= 50.0 )
	{
	 bool running = (d & Direction.Running) != 0;
	 if( running )
	 {
	  RevealingAction();
	 }
	 else if( AllowedStealthSteps-- <= 0 )
	 {
	  //Server.SkillHandlers.Stealth.OnUse( this );
	  RevealingAction();
	 }   
	}
	else
	{
	 RevealingAction();
	}
   }
   return true;
  }
  public override void DisplayPaperdollTo( Mobile to ) 
  {
   if ( DesignContext.Check( this ) )
	base.DisplayPaperdollTo( to );
  }
  private static bool m_NoRecursion;
  protected override void OnLocationChange( Point3D oldLocation ) 
  {
   CheckLightLevels( false );
   DesignContext context = m_DesignContext;
   if ( context == null || m_NoRecursion )
	return;
   m_NoRecursion = true;
   HouseFoundation foundation = context.Foundation;
   int newX = this.X, newY = this.Y;
   int newZ = foundation.Z + HouseFoundation.GetLevelZ( context.Level );
   int startX = foundation.X + foundation.Components.Min.X + 1;
   int startY = foundation.Y + foundation.Components.Min.Y + 1;
   int endX = startX + foundation.Components.Width - 1;
   int endY = startY + foundation.Components.Height - 2;
   if ( newX >= startX && newY >= startY && newX < endX && newY < endY && Map == foundation.Map ) 
   {
	if ( Z != newZ )
	 Location = new Point3D( X, Y, newZ );
	m_NoRecursion = false;
	return;
   }
   Location = new Point3D( foundation.X, foundation.Y, newZ );
   Map = foundation.Map;
   m_NoRecursion = false;
  }
  protected override void OnMapChange( Map oldMap ) 
  {
   DesignContext context = m_DesignContext;
   if ( context == null || m_NoRecursion )
	return;
   m_NoRecursion = true;
   HouseFoundation foundation = context.Foundation;
   if ( Map != foundation.Map )
	Map = foundation.Map;
   m_NoRecursion = false;
  }
  public override void OnDamage( int amount, Mobile from, bool willKill ) 
  {
   /*if ( amount > (Core.AOS ? 25 : 0) ) 
   {
	BandageContext c = BandageContext.GetContext( this );
	if ( c != null )
	 c.Slip();
   }*/
   // Auto Attack
   if (this.Combatant == null || !this.Combatant.Alive || !this.Combatant.InRange( this, 15 ))
	this.Combatant = from;
   //End.
   WeightOverloading.FatigueOnDamage( this, amount );
   base.OnDamage( amount, from, willKill );
  }
  public static int ComputeSkillTotal( Mobile m ) 
  {
   int total = 0;
   for ( int i = 0; i < m.Skills.Length; ++i )
	total += m.Skills[i].BaseFixedPoint;
   return ( total / 10 );
  }
  public override void Resurrect() 
  {
   bool wasAlive = this.Alive;
   base.Resurrect();
   if ( this.Alive && !wasAlive ) 
   {
	Item deathRobe = new DeathRobe();
	if ( !EquipItem( deathRobe ) )
	 deathRobe.Delete();
   }
  }
  private Mobile m_InsuranceAward;
  private int m_InsuranceCost;
  private int m_InsuranceBonus;
  public override bool OnBeforeDeath() 
  {
   /* m_InsuranceCost = 0;
	m_InsuranceAward = base.FindMostRecentDamager( false );
	if ( m_InsuranceAward != null && !m_InsuranceAward.Player )
	 m_InsuranceAward = null;
	if ( m_InsuranceAward is PlayerMobile )
	 ((PlayerMobile)m_InsuranceAward).m_InsuranceBonus = 0; */
   if( this.IsInPvP == true )
   {
	Mobile die = FindMostRecentDamager( false );
	PlayerMobile killah = (PlayerMobile)die;
	PlayerMobile pvploser = this as PlayerMobile;
	PvPLost(pvploser);
	PvpPointSystem.GivePoints( this, killah );
	PvpPointSystem.CheckTitle( this, killah );
	return false;
   }
   if( this.IsInAnArena == true )
   {
	GuardianSave(this);
   }
   Mobile kill = FindMostRecentDamager( false );
   if ( kill is PlayerMobile )
   {
	PlayerMobile killer = (PlayerMobile)kill;
	
	if ( PvpPointSystem.EnablePointSystem == true )
	 PvpPointSystem.GivePoints( this, killer );
	if ( PvpPointSystem.EnableRankSystem == true )
	 PvpPointSystem.CheckTitle( this, killer );
   }
   return base.OnBeforeDeath();
  }
  public override void OnAfterResurrect() 
  {
   base.OnAfterResurrect ();
   LevelSystem.ShowLevelGump(this);
  }

  private bool CheckInsuranceOnDeath( Item item ) 
  {
   if ( InsuranceEnabled && item.Insured ) 
   {
	if ( AutoRenewInsurance ) 
	{
	 int cost = ( m_InsuranceAward == null ? 600 : 300 );
	 if ( Banker.Withdraw( this, cost ) ) 
	 {
	  m_InsuranceCost += cost;
	  item.PayedInsurance = true;
	 }
	 else 
	 {
	  SendLocalizedMessage( 1061079, "", 0x23 ); // You lack the funds to purchase the insurance
	  item.PayedInsurance = false;
	  item.Insured = false;
	 }
	}
	else 
	{
	 item.PayedInsurance = false;
	 item.Insured = false;
	}
	if ( m_InsuranceAward != null ) 
	{
	 if ( Banker.Deposit( m_InsuranceAward, 300 ) ) 
	 {
	  if ( m_InsuranceAward is PlayerMobile )
	   ((PlayerMobile)m_InsuranceAward).m_InsuranceBonus += 300;
	 }
	}
	return true;
   }
   return false;
  }
  public override DeathMoveResult GetParentMoveResultFor( Item item ) 
  {
   if ( CheckInsuranceOnDeath( item ) )
	return DeathMoveResult.MoveToBackpack;
   return base.GetParentMoveResultFor( item );
  }
  public override DeathMoveResult GetInventoryMoveResultFor( Item item ) 
  {
   if ( CheckInsuranceOnDeath( item ) )
	return DeathMoveResult.MoveToBackpack;
   return base.GetInventoryMoveResultFor( item );
  }
  public static void CheckScores(PlayerMobile pm)
  {
   pm.PureWins = pm.TotalWins - pm.TotalLoses - pm.TotalResKills;
   if(pm.PureWins <= 0)
   {
	pm.PureWins = 0;
   }
   if(pm.TotalPoints <= 0)
   {
	pm.TotalPoints = 0;
   }
   if(pm.TotalLoses <= 0)
   {
	pm.TotalLoses = 0;
   }
   if(pm.TotalPointsLost <= 0)
   {
	pm.TotalPointsLost = 0;
   }
   if(pm.TotalPointsSpent <= 0)
   {
	pm.TotalPointsSpent = 0;
   }
   if(pm.TotalResKilled <= 0)
   {
	pm.TotalResKilled = 0;
   }
   if(pm.TotalResKills <= 0)
   {
	pm.TotalResKills = 0;
   }
   if(pm.TotalWins <= 0)
   {
	pm.TotalWins = 0;
   }
  }
  public override void OnDeath( Container c ) 
  {
   base.OnDeath( c );
   LastDeath = DateTime.Now;
   HueMod = -1;
   NameMod = null;
   SavagePaintExpiration = TimeSpan.Zero;
   SetHairMods( -1, -1 );
   PolymorphSpell.StopTimer( this );
   IncognitoSpell.StopTimer( this );
   DisguiseGump.StopTimer( this );
   EndAction( typeof( PolymorphSpell ) );
   EndAction( typeof( IncognitoSpell ) );
   CheckScores(this);
   MeerMage.StopEffect( this, false );
   if ( m_PermaFlags.Count > 0 ) 
   {
	m_PermaFlags.Clear();
	if ( c is Corpse )
	 ((Corpse)c).Criminal = true;
	if ( SkillHandlers.Stealing.ClassicMode )
	 Criminal = true;
   }
   if ( this.Kills >= 5 && DateTime.Now >= m_NextJustAward ) 
   {
	Mobile m = FindMostRecentDamager( false );
	if ( m != null && m.Player ) 
	{
	 bool gainedPath = false;
	 int theirTotal = ComputeSkillTotal( m );
	 int ourTotal = ComputeSkillTotal( this );
	 int pointsToGain = 1 + ((theirTotal - ourTotal) / 50);
	 if ( pointsToGain < 1 )
	  pointsToGain = 1;
	 else if ( pointsToGain > 4 )
	  pointsToGain = 4;
	 if ( VirtueHelper.Award( m, VirtueName.Justice, pointsToGain, ref gainedPath ) ) 
	 {
	  if ( gainedPath )
	   m.SendLocalizedMessage( 1049367 ); // You have gained a path in Justice!
	  else
	   m.SendLocalizedMessage( 1049363 ); // You have gained in Justice.
	  m.FixedParticles( 0x375A, 9, 20, 5027, EffectLayer.Waist );
	  m.PlaySound( 0x1F7 );
	  m_NextJustAward = DateTime.Now + TimeSpan.FromMinutes( pointsToGain * 2 );
	 }
	}
   }
   if ( m_InsuranceCost > 0 )
	SendLocalizedMessage( 1060398, m_InsuranceCost.ToString() ); // ~1_AMOUNT~ gold has been withdrawn from your bank box.
   if ( m_InsuranceAward is PlayerMobile ) 
   {
	PlayerMobile pm = (PlayerMobile)m_InsuranceAward;
	if ( pm.m_InsuranceBonus > 0 )
	 pm.SendLocalizedMessage( 1060397, pm.m_InsuranceBonus.ToString() ); // ~1_AMOUNT~ gold has been deposited into your bank box.
   }
  }
  private ArrayList m_PermaFlags;
  private ArrayList m_VisList;
  private Hashtable m_AntiMacroTable;
  private TimeSpan m_GameTime;
  private TimeSpan m_ShortTermElapse;
  private TimeSpan m_LongTermElapse;
  private DateTime m_SessionStart;
  private DateTime m_LastEscortTime;
  private DateTime m_NextSmithBulkOrder;
  private DateTime m_NextTailorBulkOrder;
  private DateTime m_SavagePaintExpiration;
  private SkillName m_Learning = (SkillName)(-1);
  public SkillName Learning 
  {
   get{ return m_Learning; }
   set{ m_Learning = value; }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public TimeSpan SavagePaintExpiration 
  {
   get 
   {
	TimeSpan ts = m_SavagePaintExpiration - DateTime.Now;
	if ( ts < TimeSpan.Zero )
	 ts = TimeSpan.Zero;
	return ts;
   }
   set 
   {
	m_SavagePaintExpiration = DateTime.Now + value;
   }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public TimeSpan NextSmithBulkOrder 
  {
   get 
   {
	TimeSpan ts = m_NextSmithBulkOrder - DateTime.Now;
	if ( ts < TimeSpan.Zero )
	 ts = TimeSpan.Zero;
	return ts;
   }
   set 
   {
	try{ m_NextSmithBulkOrder = DateTime.Now + value; }
	catch{}
   }
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public TimeSpan NextTailorBulkOrder 
  {
   get 
   {
	TimeSpan ts = m_NextTailorBulkOrder - DateTime.Now;
	if ( ts < TimeSpan.Zero )
	 ts = TimeSpan.Zero;
	return ts;
   }
   set 
   {
	try{ m_NextTailorBulkOrder = DateTime.Now + value; }
	catch{}
   }
  }
  public DateTime LastEscortTime 
  {
   get{ return m_LastEscortTime; }
   set{ m_LastEscortTime = value; }
  }
  public PlayerMobile() 
  {
   m_HeroAbilities = new ArrayList();
   m_VisList = new ArrayList();
   m_PermaFlags = new ArrayList();
   m_AntiMacroTable = new Hashtable();
   m_BOBFilter = new Engines.BulkOrders.BOBFilter();
   m_GameTime = TimeSpan.Zero;
 
   m_ShortTermElapse = TimeSpan.FromHours( 8.0 );
   m_LongTermElapse = TimeSpan.FromHours( 40.0 );
   m_JusticeProtectors = new ArrayList();
   InvalidateMyRunUO();
   EventBackpack = new Backpack();
   EventBackpack.Movable = false;
   m_StamMax = 200;
   m_HitsMax = 400;
   m_ManaMax = 200;
   m_StatUpPoints = 5;
   Server.Misc.Stats.Register(this);
  }
  public override bool MutateSpeech( ArrayList hears, ref string text, ref object context ) 
  {
   if ( Alive )
	return false;
   if ( Core.AOS ) 
   {
	for ( int i = 0; i < hears.Count; ++i ) 
	{
	 object o = hears[i];
	 if ( o != this && o is Mobile && ((Mobile)o).Skills[SkillName.SpiritSpeak].Value >= 100.0 )
	  return false;
	}
   }
   return base.MutateSpeech( hears, ref text, ref context );
  }
  public override void Damage( int amount, Mobile from ) 
  {
   if ( Spells.Necromancy.EvilOmenSpell.CheckEffect( this ) )
	amount = (int)(amount * 1.25);
   Mobile oath = Spells.Necromancy.BloodOathSpell.GetBloodOath( from );
   if (from != null && from.Player)
	amount = (int)((double)amount * DamageScalar);
   if ( oath == this ) 
   {
	amount = (int)(amount * 1.1);
	from.Damage( amount, from );
   }
   base.Damage( amount, from );
  }
  public override ApplyPoisonResult ApplyPoison( Mobile from, Poison poison ) 
  {
   if ( !Alive )
	return ApplyPoisonResult.Immune;
   if ( Spells.Necromancy.EvilOmenSpell.CheckEffect( this ) )
	return base.ApplyPoison( from, PoisonImpl.IncreaseLevel( poison ) );
   return base.ApplyPoison( from, poison );
  }
  public PlayerMobile( Serial s ) : base( s ) 
  {
   Server.Misc.Stats.Register(this);
   m_VisList = new ArrayList();
   m_AntiMacroTable = new Hashtable();
   InvalidateMyRunUO();
  }
  public ArrayList VisibilityList 
  {
   get{ return m_VisList; }
  }
  public ArrayList PermaFlags 
  {
   get{ return m_PermaFlags; }
  }
  public override int Luck{ get{ return AosAttributes.GetValue( this, AosAttribute.Luck ); } }
  public override bool IsHarmfulCriminal( Mobile target ) 
  {
   if ( SkillHandlers.Stealing.ClassicMode && target is PlayerMobile && ((PlayerMobile)target).m_PermaFlags.Count > 0 ) 
   {
	int noto = Notoriety.Compute( this, target );
	if ( noto == Notoriety.Innocent )
	 target.Delta( MobileDelta.Noto );
	return false;
   }
   if ( target is BaseCreature && ((BaseCreature)target).InitialInnocent )
	return false;
   return base.IsHarmfulCriminal( target );
  }
  public bool AntiMacroCheck( Skill skill, object obj ) 
  {
   if ( obj == null || m_AntiMacroTable == null || this.AccessLevel != AccessLevel.Player )
	return true;
   Hashtable tbl = (Hashtable)m_AntiMacroTable[skill];
   if ( tbl == null )
	m_AntiMacroTable[skill] = tbl = new Hashtable();
   CountAndTimeStamp count = (CountAndTimeStamp)tbl[obj];
   if ( count != null ) 
   {
	if ( count.TimeStamp + SkillCheck.AntiMacroExpire <= DateTime.Now ) 
	{
	 count.Count = 1;
	 return true;
	}
	else 
	{
	 ++count.Count;
	 if ( count.Count <= SkillCheck.Allowance )
	  return true;
	 else
	  return false;
	}
   }
   else 
   {
	tbl[obj] = count = new CountAndTimeStamp();
	count.Count = 1;
	return true;
   }
  }
  private void RevertHair() 
  {
   SetHairMods( -1, -1 );
  }
  private Engines.BulkOrders.BOBFilter m_BOBFilter;
  public Engines.BulkOrders.BOBFilter BOBFilter 
  {
   get{ return m_BOBFilter; }
  }
  public override void Deserialize( GenericReader reader ) 
  {
   base.Deserialize( reader );
   int version = reader.ReadInt();
   m_HeroAbilities = new ArrayList();
   switch ( version ) 
   {
	case 26: 
	{ 
	 m_Voted = reader.ReadBool();
	 VoteTime = reader.ReadTimeSpan();
	 
	 goto case 25;
	}
	case 25: 
	{ 
	 goto case 24;
	}
	case 24: 
	{ 
	 m_IsInAnArena = reader.ReadBool();
	 m_ArenaLoseLoc = reader.ReadPoint3D();
	 m_ArenaLoseMap = reader.ReadMap();
	 goto case 23;
	}
	case 23: 
	{ 
	 m_ToggleRank = reader.ReadBool();
	 goto case 22;
	}
	case 22: 
	{ 
	 m_IsInPvP = reader.ReadBool();
	 goto case 21;
	}
	case 21: 
	{ 
	 m_ToggleRank = reader.ReadBool();
	 goto case 20;
	}
	case 20: 
	{ 
	 m_PvPLoseLoc = reader.ReadPoint3D();
	 goto case 19;
	}
	case 19: 
	{ 
	 m_PureWins = reader.ReadInt();
	 goto case 18;
	}
	case 18: 
	{ 
	 m_TotalPointsLost = reader.ReadInt();
	 m_TotalPointsSpent = reader.ReadInt();
	 ResKillTime = reader.ReadTimeSpan();
	 m_LastPwned = reader.ReadMobile();
	 m_TotalResKills = reader.ReadInt();
	 m_TotalResKilled = reader.ReadInt();
	 m_LastPwner = reader.ReadMobile();
	 m_TotalPoints = reader.ReadInt();
	 m_TotalWins = reader.ReadInt();
	 m_TotalLoses = reader.ReadInt();
	 m_PvpRank = reader.ReadString();
	 goto case 17;
	}
	case 17: 
	{ // changed how DoneQuests is serialized
	 m_Event = (BaseEvent) reader.ReadItem();
	 m_EventBackpack = (Backpack) reader.ReadItem();
	 if (m_Event != null)
	  m_Team = m_Event.FindTeam(this);
	 
	 m_HeroFlags = (HeroFlag) reader.ReadInt();
	 m_HeroUpPoints = reader.ReadInt();
	 m_StatUpPoints = reader.ReadInt();
	 m_HitsMax = reader.ReadInt();
	 m_StamMax = reader.ReadInt();
	 m_ManaMax = reader.ReadInt();
	 // Hits = m_HitsMax;
	 // Stam = m_StamMax;
	 // Mana = m_ManaMax;
	 goto case 16;
	}
	case 16: 
	{
	 m_Quest = QuestSerializer.DeserializeQuest( reader );
	 if ( m_Quest != null )
	  m_Quest.From = this;
	 int count = reader.ReadEncodedInt();
	 if ( count > 0 ) 
	 {
	  m_DoneQuests = new ArrayList();
	  for ( int i = 0; i < count; ++i ) 
	  {
	   Type questType = QuestSerializer.ReadType( QuestSystem.QuestTypes, reader );
	   DateTime restartTime;
	   if ( version < 17 )
		restartTime = DateTime.MaxValue;
	   else
		restartTime = reader.ReadDateTime();
	   m_DoneQuests.Add( new QuestRestartInfo( questType, restartTime ) );
	  }
	 }
	 m_Profession = reader.ReadEncodedInt();
	 goto case 15;
	}
	case 15: 
	{
	 m_LastCompassionLoss = reader.ReadDeltaTime();
	 goto case 14;
	}
	case 14: 
	{
	 m_CompassionGains = reader.ReadEncodedInt();
	 if ( m_CompassionGains > 0 )
	  m_NextCompassionDay = reader.ReadDeltaTime();
	 goto case 13;
	}
	case 13: // just removed m_PayedInsurance list
	case 12: 
	{
	 m_BOBFilter = new Engines.BulkOrders.BOBFilter( reader );
	 goto case 11;
	}
	case 11: 
	{
	 if ( version < 13 ) 
	 {
	  ArrayList payed = reader.ReadItemList();
	  for ( int i = 0; i < payed.Count; ++i )
	   ((Item)payed[i]).PayedInsurance = true;
	 }
	 goto case 10;
	}
	case 10: 
	{
	 if ( reader.ReadBool() ) 
	 {
	  m_HairModID = reader.ReadInt();
	  m_HairModHue = reader.ReadInt();
	  m_BeardModID = reader.ReadInt();
	  m_BeardModHue = reader.ReadInt();
	  // We cannot call SetHairMods( -1, -1 ) here because the items have not yet loaded
	  Timer.DelayCall( TimeSpan.Zero, new TimerCallback( RevertHair ) );
	 }
	 goto case 9;
	}
	case 9: 
	{
	 SavagePaintExpiration = reader.ReadTimeSpan();
	 if ( SavagePaintExpiration > TimeSpan.Zero ) 
	 {
	  BodyMod = ( Female ? 184 : 183 );
	  HueMod = 0;
	 }
	 goto case 8;
	}
	case 8: 
	{
	 m_NpcGuild = (NpcGuild)reader.ReadInt();
	 m_NpcGuildJoinTime = reader.ReadDateTime();
	 m_NpcGuildGameTime = reader.ReadTimeSpan();
	 goto case 7;
	}
	case 7: 
	{
	 m_PermaFlags = reader.ReadMobileList();
	 goto case 6;
	}
	case 6: 
	{
	 NextTailorBulkOrder = reader.ReadTimeSpan();
	 goto case 5;
	}
	case 5: 
	{
	 NextSmithBulkOrder = reader.ReadTimeSpan();
	 goto case 4;
	}
	case 4: 
	{
	 m_LastJusticeLoss = reader.ReadDeltaTime();
	 m_JusticeProtectors = reader.ReadMobileList();
	 goto case 3;
	}
	case 3: 
	{
	 m_LastSacrificeGain = reader.ReadDeltaTime();
	 m_LastSacrificeLoss = reader.ReadDeltaTime();
	 m_AvailableResurrects = reader.ReadInt();
	 goto case 2;
	}
	case 2: 
	{
	 m_Flags = (PlayerFlag)reader.ReadInt();
	 goto case 1;
	}
	case 1: 
	{
	 m_LongTermElapse = reader.ReadTimeSpan();
	 m_ShortTermElapse = reader.ReadTimeSpan();
	 m_GameTime = reader.ReadTimeSpan();
	 goto case 0;
	}
	case 0: 
	{
	 break;
	}
   }
   if ( m_PermaFlags == null )
	m_PermaFlags = new ArrayList();
   if ( m_JusticeProtectors == null )
	m_JusticeProtectors = new ArrayList();
   if ( m_BOBFilter == null )
	m_BOBFilter = new Engines.BulkOrders.BOBFilter();
   ArrayList list = this.Stabled;
   for ( int i = 0; i < list.Count; ++i ) 
   {
	BaseCreature bc = list[i] as BaseCreature;
	if ( bc != null )
	 bc.IsStabled = true;
   }
  }
  
  public override void Serialize( GenericWriter writer ) 
  {
   //cleanup our anti-macro table 
   foreach ( Hashtable t in m_AntiMacroTable.Values ) 
   {
	ArrayList remove = new ArrayList();
	foreach ( CountAndTimeStamp time in t.Values ) 
	{
	 if ( time.TimeStamp + SkillCheck.AntiMacroExpire <= DateTime.Now )
	  remove.Add( time );
	}
	for (int i=0;i<remove.Count;++i)
	 t.Remove( remove[i] );
   }
   //decay our kills
   if ( m_ShortTermElapse < this.GameTime ) 
   {
	m_ShortTermElapse += TimeSpan.FromMinutes( 30.0 );
	if ( ShortTermMurders > 0 )
	 --ShortTermMurders;
   }
   if ( m_LongTermElapse < this.GameTime ) 
   {
	m_LongTermElapse += TimeSpan.FromMinutes( 60.0 );
	if ( Kills > 0 )
	 --Kills;
   }
   base.Serialize( writer );
   
   writer.Write( (int) 26 ); // version
   //
   writer.Write( VoteTime );
   writer.Write( m_Voted );
   //
   writer.Write( m_IsInAnArena );
   writer.Write( m_ArenaLoseLoc );
   //
   writer.Write( m_ToggleRank );
   //
   writer.Write( m_IsInPvP );
   writer.Write( m_PvPLoseLoc );
   writer.Write( m_PureWins );
   writer.Write( m_TotalPointsLost );
   writer.Write( m_TotalPointsSpent );
   writer.Write( ResKillTime );
   writer.Write( m_LastPwned );
   writer.Write( m_TotalResKills );
   writer.Write( m_TotalResKilled );
   writer.Write( m_LastPwner );
   writer.Write( m_TotalPoints );
   writer.Write( m_TotalWins );
   writer.Write( m_TotalLoses );
   writer.Write( m_PvpRank );
   
   writer.Write( (Item) m_Event);
   writer.Write( (Item) m_EventBackpack);
   // Level System:
   writer.Write( (int) m_HeroFlags );
   writer.Write( (int) m_HeroUpPoints );
   writer.Write( (int) m_StatUpPoints );
   
   writer.Write( (int) m_HitsMax );
   writer.Write( (int) m_StamMax );
   writer.Write( (int) m_ManaMax );
   
   QuestSerializer.Serialize( m_Quest, writer );
   if ( m_DoneQuests == null ) 
   {
	writer.WriteEncodedInt( (int) 0 );
   }
   else 
   {
	writer.WriteEncodedInt( (int) m_DoneQuests.Count );
	for ( int i = 0; i < m_DoneQuests.Count; ++i ) 
	{
	 QuestRestartInfo restartInfo = (QuestRestartInfo)m_DoneQuests[i];
	 QuestSerializer.Write( (Type) restartInfo.QuestType, QuestSystem.QuestTypes, writer );
	 writer.Write( (DateTime) restartInfo.RestartTime );
	}
   }
   writer.WriteEncodedInt( (int) m_Profession );
   writer.WriteDeltaTime( m_LastCompassionLoss );
   writer.WriteEncodedInt( m_CompassionGains );
   if ( m_CompassionGains > 0 )
	writer.WriteDeltaTime( m_NextCompassionDay );
   m_BOBFilter.Serialize( writer );
   bool useMods = ( m_HairModID != -1 || m_BeardModID != -1 );
   writer.Write( useMods );
   if ( useMods ) 
   {
	writer.Write( (int) m_HairModID );
	writer.Write( (int) m_HairModHue );
	writer.Write( (int) m_BeardModID );
	writer.Write( (int) m_BeardModHue );
   }
   writer.Write( SavagePaintExpiration );
   writer.Write( (int) m_NpcGuild );
   writer.Write( (DateTime) m_NpcGuildJoinTime );
   writer.Write( (TimeSpan) m_NpcGuildGameTime );
   writer.WriteMobileList( m_PermaFlags, true );
   writer.Write( NextTailorBulkOrder );
   writer.Write( NextSmithBulkOrder );
   writer.WriteDeltaTime( m_LastJusticeLoss );
   writer.WriteMobileList( m_JusticeProtectors, true );
   writer.WriteDeltaTime( m_LastSacrificeGain );
   writer.WriteDeltaTime( m_LastSacrificeLoss );
   writer.Write( m_AvailableResurrects );
   writer.Write( (int) m_Flags );
   writer.Write( m_LongTermElapse );
   writer.Write( m_ShortTermElapse );
   writer.Write( this.GameTime );
  }
  public void ResetKillTime() 
  {
   m_ShortTermElapse = this.GameTime + TimeSpan.FromHours( 8 );
   m_LongTermElapse = this.GameTime + TimeSpan.FromHours( 40 );
  }
  [CommandProperty( AccessLevel.GameMaster )]
  public TimeSpan GameTime 
  {
   get 
   {
	if ( NetState != null )
	 return m_GameTime + (DateTime.Now - m_SessionStart);
	else
	 return m_GameTime;
   }
  }
  public override bool CanSee( Mobile m ) 
  {
   if ( m is PlayerMobile && ((PlayerMobile)m).m_VisList.Contains( this ) )
	return true;
   return base.CanSee( m );
  }
  public override bool CanSee( Item item ) 
  {
   if ( m_DesignContext != null && m_DesignContext.Foundation.IsHiddenToCustomizer( item ) )
	return false;
   return base.CanSee( item );
  }
  #region Quest stuff
  private QuestSystem m_Quest;
  private ArrayList m_DoneQuests;
  public QuestSystem Quest 
  {
   get{ return m_Quest; }
   set{ m_Quest = value; }
  }
  public ArrayList DoneQuests 
  {
   get{ return m_DoneQuests; }
   set{ m_DoneQuests = value; }
  }
  #endregion
  #region MyRunUO Invalidation
  private bool m_ChangedMyRunUO;
  public bool ChangedMyRunUO 
  {
   get{ return m_ChangedMyRunUO; }
   set{ m_ChangedMyRunUO = value; }
  }
  public void InvalidateMyRunUO() 
  {
   if ( !Deleted && !m_ChangedMyRunUO ) 
   {
	m_ChangedMyRunUO = true;
	Engines.MyRunUO.MyRunUO.QueueMobileUpdate( this );
   }
  }
  public override void OnKillsChange( int oldValue ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnGenderChanged( bool oldFemale ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnGuildChange( Server.Guilds.BaseGuild oldGuild ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnGuildTitleChange( string oldTitle ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnKarmaChange( int oldValue ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnFameChange( int oldValue ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnSkillChange( SkillName skill, double oldBase ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnAccessLevelChanged( AccessLevel oldLevel ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnRawStatChange( StatType stat, int oldValue ) 
  {
   InvalidateMyRunUO();
  }
  public override void OnDelete() 
  {
   Server.Misc.Stats.Unregister(this);
   InvalidateMyRunUO();
  }
  #endregion
  #region Fastwalk Prevention
  private static bool FastwalkPrevention = true; // Is fastwalk prevention enabled?
  private static TimeSpan FastwalkThreshold = TimeSpan.FromSeconds( 0.4 ); // Fastwalk prevention will become active after 0.4 seconds
  private DateTime m_NextMovementTime;
  public virtual bool UsesFastwalkPrevention{ get{ return ( AccessLevel < AccessLevel.GameMaster ); } }
  public virtual TimeSpan ComputeMovementSpeed( Direction dir ) 
  {
   if ( (dir & Direction.Mask) != (this.Direction & Direction.Mask) )
	return TimeSpan.Zero;
   bool running = ( (dir & Direction.Running) != 0 );
   bool onHorse = ( this.Mount != null );
   if ( onHorse )
	return ( running ? TimeSpan.FromSeconds( 0.1 ) : TimeSpan.FromSeconds( 0.2 ) );
   return ( running ? TimeSpan.FromSeconds( 0.2 ) : TimeSpan.FromSeconds( 0.4 ) );
  }
  public static bool MovementThrottle_Callback( NetState ns ) 
  {
   PlayerMobile pm = ns.Mobile as PlayerMobile;
   if ( pm == null || !pm.UsesFastwalkPrevention )
	return true;
   if ( pm.m_NextMovementTime == DateTime.MinValue ) 
   {
	// has not yet moved
	pm.m_NextMovementTime = DateTime.Now;
	return true;
   }
   TimeSpan ts = pm.m_NextMovementTime - DateTime.Now;
   if ( ts < TimeSpan.Zero ) 
   {
	// been a while since we've last moved
	pm.m_NextMovementTime = DateTime.Now;
	return true;
   }
   return ( ts < FastwalkThreshold );
  }
  #endregion
  #region Enemy of One
  private Type m_EnemyOfOneType;
  private bool m_WaitingForEnemy;
  public Type EnemyOfOneType 
  {
   get{ return m_EnemyOfOneType; }
   set 
   {
	Type oldType = m_EnemyOfOneType;
	Type newType = value;
	if ( oldType == newType )
	 return;
	m_EnemyOfOneType = value;
	DeltaEnemies( oldType, newType );
   }
  }
  public bool WaitingForEnemy 
  {
   get{ return m_WaitingForEnemy; }
   set{ m_WaitingForEnemy = value; }
  }
  private void DeltaEnemies( Type oldType, Type newType ) 
  {
   IPooledEnumerable mobs = GetMobilesInRange( 18 );
   foreach ( Mobile m in mobs ) 
   {
	Type t = m.GetType();
	if ( t == oldType || t == newType )
	 Send( new MobileMoving( m, Notoriety.Compute( this, m ) ) );
   }
   mobs.Free();
  }
  #endregion
  #region Hair and beard mods
  private int m_HairModID = -1, m_HairModHue;
  private int m_BeardModID = -1, m_BeardModHue;
  public void SetHairMods( int hairID, int beardID ) 
  {
   if ( hairID == -1 )
	InternalRestoreHair( true, ref m_HairModID, ref m_HairModHue );
   else if ( hairID != -2 )
	InternalChangeHair( true, hairID, ref m_HairModID, ref m_HairModHue );
   if ( beardID == -1 )
	InternalRestoreHair( false, ref m_BeardModID, ref m_BeardModHue );
   else if ( beardID != -2 )
	InternalChangeHair( false, beardID, ref m_BeardModID, ref m_BeardModHue );
  }
  private Item CreateHair( bool hair, int id, int hue ) 
  {
   if ( hair )
	return Server.Items.Hair.CreateByID( id, hue );
   else
	return Server.Items.Beard.CreateByID( id, hue );
  }
  private void InternalRestoreHair( bool hair, ref int id, ref int hue ) 
  {
   if ( id == -1 )
	return;
   Item item = FindItemOnLayer( hair ? Layer.Hair : Layer.FacialHair );
   if ( item != null )
	item.Delete();
   if ( id != 0 )
	AddItem( CreateHair( hair, id, hue ) );
   id = -1;
   hue = 0;
  }
  private void InternalChangeHair( bool hair, int id, ref int storeID, ref int storeHue ) 
  {
   Item item = FindItemOnLayer( hair ? Layer.Hair : Layer.FacialHair );
   if ( item != null ) 
   {
	if ( storeID == -1 ) 
	{
	 storeID = item.ItemID;
	 storeHue = item.Hue;
	}
	item.Delete();
   }
   else if ( storeID == -1 ) 
   {
	storeID = 0;
	storeHue = 0;
   }
   if ( id == 0 )
	return;
   AddItem( CreateHair( hair, id, 0 ) );
  }
  #endregion
  #region Virtue stuff
  private DateTime m_LastSacrificeGain;
  private DateTime m_LastSacrificeLoss;
  private int m_AvailableResurrects;
  public DateTime LastSacrificeGain{ get{ return m_LastSacrificeGain; } set{ m_LastSacrificeGain = value; } }
  public DateTime LastSacrificeLoss{ get{ return m_LastSacrificeLoss; } set{ m_LastSacrificeLoss = value; } }
  public int AvailableResurrects{ get{ return m_AvailableResurrects; } set{ m_AvailableResurrects = value; } }
  private DateTime m_NextJustAward;
  private DateTime m_LastJusticeLoss;
  private ArrayList m_JusticeProtectors;
  public DateTime LastJusticeLoss{ get{ return m_LastJusticeLoss; } set{ m_LastJusticeLoss = value; } }
  public ArrayList JusticeProtectors{ get{ return m_JusticeProtectors; } set{ m_JusticeProtectors = value; } }
  private DateTime m_LastCompassionLoss;
  private DateTime m_NextCompassionDay;
  private int m_CompassionGains;
  public DateTime LastCompassionLoss{ get{ return m_LastCompassionLoss; } set{ m_LastCompassionLoss = value; } }
  public DateTime NextCompassionDay{ get{ return m_NextCompassionDay; } set{ m_NextCompassionDay = value; } }
  public int CompassionGains{ get{ return m_CompassionGains; } set{ m_CompassionGains = value; } }
  #endregion
  #region Custom Scripts
  // remove staff restrictions
  public override void Use(Item item) 
  {
   if ((this.AccessLevel > AccessLevel.Counselor && !item.Deleted)) 
   {
	item.OnItemUsed(this, item);
	item.OnDoubleClick(this);
   }
   else
	base.Use (item);
  }
  public static double DamageScalar { get { return 1.1; } }
  public override bool EquipItem(Item item) 
  {
   if (item is BaseItem) 
   {
	BaseItem it = (BaseItem)item;
	if (it.RequiredLevel <= Level || this.AccessLevel > AccessLevel.Player)
	 return base.EquipItem (item);
	else 
	{
	 SendMessage("You need at least level {0} to wear this item!", it.RequiredLevel);
	 return false;
	}
   }
   return base.EquipItem (item);
  }
  public static void PvPLost( PlayerMobile pm )
  {
   PlayerMobile pvploser = pm as PlayerMobile;
   Point3D pvploseloc = pvploser.PvPLoseLoc;
   Map pvplosemap = pvploser.Map;
 
   if(pvploser.IsInPvP == true && pm != null)
   {
	Mobile diie = pvploser.FindMostRecentDamager( false );
	PlayerMobile killaah = (PlayerMobile)diie;
	Point3D from = pvploser.Location;
	Point3D to = pvploser.PvPLoseLoc;
	Effects.SendLocationParticles( EffectItem.Create( from, pvploser.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 2023 );
	Effects.SendLocationParticles( EffectItem.Create(   to, pvploser.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 5023 );
	
	pvploser.MoveToWorld( pvploseloc, pvplosemap );
	pvploser.IsInPvP = false;
	pvploser.Hits = pvploser.HitsMax;
	pvploser.Emote("You see {0} has been defeated by {1}", pvploser.Name, killaah.Name );
   }
   return;
  }
  public static void GuardianSave( PlayerMobile pm )
  {
   PlayerMobile loser = pm as PlayerMobile;
   Point3D arenaloseloc = loser.ArenaLoseLoc;
   Map arenalosemap = loser.Map;
 
   if(loser.IsInAnArena == true && pm != null)
   {
	Mobile dead = loser.FindMostRecentDamager( false );
	PlayerMobile killaah = (PlayerMobile)dead;
	Point3D from = loser.Location;
	Point3D to = loser.ArenaLoseLoc;
	Effects.SendLocationParticles( EffectItem.Create( from, loser.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 2023 );
	Effects.SendLocationParticles( EffectItem.Create(   to, loser.ArenaLoseMap, EffectItem.DefaultDuration ), 0x3728, 10, 10, 5023 );
	
	loser.MoveToWorld( arenaloseloc, arenalosemap );
	loser.IsInAnArena = false;
	loser.Hits = loser.HitsMax;
	loser.Emote( "*You Have Been Saved By The Guardians*" );
   }
   return;
  }
  // AutoLoot Protection
  TimeSpan AutoLootDelay = TimeSpan.FromSeconds(0.5);
  int MaxLootCount = 1;
  DateTime m_LastDragTime = DateTime.Now;
  int m_DragCount = 0;
  public override bool OnDragLift(Item item) 
  {
   if (item.RootParent != this) 
   {
	if (m_LastDragTime + AutoLootDelay > DateTime.Now) 
	{
	 m_DragCount++;
	 /*if (m_DragCount > 3)
	 {
	  // autoloot detected
	 }*/
	 if (m_DragCount > MaxLootCount) 
	 {
	  return false;
	 }
	}
	else 
	{
	 m_DragCount = 1;
	 m_LastDragTime = DateTime.Now;
	}
   }
   return base.OnDragLift (item);
  }
  #endregion
 }
}

THIS WILL BE THE MOST I'VE EVER ASKED FOR

[ArteGordon]

well, I see at least a few things,

you deser this

 m_ArenaLoseMap = reader.ReadMap();

but you dont serialize it

you also deser this twice, in case 23 and 21, but only write it once

m_ToggleRank = reader.ReadBool();

[Vorspire]

I noticed i serialized m_ToggleRank 2 times :/ but if i remove one of them, it gives the error :/

if i leave them both in, it loads without error :S


OK, everything seems to work fine, including restarts, when i leave ToggleRank (both of them) in the methods..

Saving ArenaLoseMap sorted the problem ^^

[ArteGordon]

Originally Posted by Admin Vorspire

I noticed i serialized m_ToggleRank 2 times :/ but if i remove one of them, it gives the error :/

if i leave them both in, it loads without error :S


OK, everything seems to work fine, including restarts, when i leave ToggleRank (both of them) in the methods..

Saving ArenaLoseMap sorted the problem ^^

it may load now with those two m_ToggleRank reads, but the next time you save and try to reload it will fail because you only write it out once. You need to get your Serialize method in sync with your Deser.

(edit)

what you want to do is this

1) get a Deser that loads your playermobile, and you have done that. Then at the same time you want to fix your Serialization so that it actually writes out exactly what you want. At this point the Serialize and Deserialize methods do not have to match.

2) do a load and save.

3) go back and fix your Deser so that it matches your Serialization exactly.

4) load up server and relax.

Note, that because you had messed up saves prior to this, once you fix the problem going through these steps, you will not necessarily be able to load those old saves but your new saves will all be correct.

[Vorspire]

Thanks for all help Arte, your the best