Scripts/Items/Misc/Corpses/Corpse.cs

@@ -0,0 +1,965 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.ContextMenus;
+using Server.Engines.PartySystem;
+using Server.Engines.Quests;
+using Server.Engines.Quests.Doom;
+using Server.Engines.Quests.Haven;
+using Server.Guilds;
+using Server.Misc;
+using Server.Mobiles;
+using Server.Network;
+
+namespace Server.Items
+{
+	public class Corpse : Container, ICarvable
+	{
+		private Mobile		m_Owner;				// Whos corpse is this?
+		private Mobile		m_Killer;				// Who killed the owner?
+		private bool		m_Carved;				// Has this corpse been carved?
+
+		private List<Mobile>	m_Looters;				// Who's looted this corpse?
+		private List<Item>		m_EquipItems;			// List of items equiped when the owner died. Ingame, these items display /on/ the corpse, not just inside
+		private List<Mobile>	m_Aggressors;			// Anyone from this list will be able to loot this corpse; we attacked them, or they attacked us when we were freely attackable
+
+		private string		m_CorpseName;			// Value of the CorpseNameAttribute attached to the owner when he died -or- null if the owner had no CorpseNameAttribute; use "the remains of ~name~"
+		private bool		m_NoBones;				// If true, this corpse will not turn into bones
+
+		private bool		m_VisitedByTaxidermist;	// Has this corpse yet been visited by a taxidermist?
+		private bool		m_Channeled;			// Has this corpse yet been used to channel spiritual energy? (AOS Spirit Speak)
+
+		// For notoriety:
+		private AccessLevel	m_AccessLevel;			// Which AccessLevel the owner had when he died
+		private Guild		m_Guild;				// Which Guild the owner was in when he died
+		private int			m_Kills;				// How many kills the owner had when he died
+		private bool		m_Criminal;				// Was the owner criminal when he died?
+
+		private DateTime	m_TimeOfDeath;			// What time was this corpse created?
+
+		private HairInfo m_Hair;					// This contains the hair of the owner
+		private FacialHairInfo m_FacialHair;		// This contains the facial hair of the owner
+
+		public static readonly TimeSpan MonsterLootRightSacrifice = TimeSpan.FromMinutes( 2.0 );
+
+		public override bool IsDecoContainer
+		{
+			get{ return false; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public DateTime TimeOfDeath
+		{
+			get{ return m_TimeOfDeath; }
+			set{ m_TimeOfDeath = value; }
+		}
+
+		public HairInfo Hair { get { return m_Hair; } }
+		public FacialHairInfo FacialHair { get { return m_FacialHair; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Carved
+		{
+			get{ return m_Carved; }
+			set{ m_Carved = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool VisitedByTaxidermist
+		{
+			get{ return m_VisitedByTaxidermist; }
+			set{ m_VisitedByTaxidermist = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Channeled
+		{
+			get{ return m_Channeled; }
+			set{ m_Channeled = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public AccessLevel AccessLevel
+		{
+			get{ return m_AccessLevel; }
+		}
+
+		public List<Mobile> Aggressors
+		{
+			get{ return m_Aggressors; }
+		}
+
+		public List<Mobile> Looters
+		{
+			get{ return m_Looters; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Mobile Killer
+		{
+			get{ return m_Killer; }
+		}
+
+		public List<Item> EquipItems
+		{
+			get{ return m_EquipItems; }
+		}
+
+		public Guild Guild
+		{
+			get{ return m_Guild; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int Kills
+		{
+			get{ return m_Kills; }
+			set{ m_Kills = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Criminal
+		{
+			get{ return m_Criminal; }
+			set{ m_Criminal = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Mobile Owner
+		{
+			get{ return m_Owner; }
+		}
+
+		public void TurnToBones()
+		{
+			if ( Deleted )
+				return;
+
+			ProcessDelta();
+			SendRemovePacket();
+			ItemID = Utility.Random( 0xECA, 9 ); // bone graphic
+			Hue = 0;
+			ProcessDelta();
+
+			m_NoBones = true;
+			BeginDecay( m_BoneDecayTime );
+
+			/*DecayedCorpse c = new DecayedCorpse( Name );
+
+			c.MoveToWorld( Location, Map );
+
+			ArrayList list = Items;
+
+			for ( int i = list.Count - 1; i >= 0; --i )
+			{
+				if ( i < list.Count )
+					c.AddItem( (Item)list[i] );
+			}
+
+			Delete();*/
+		}
+
+		private static TimeSpan m_DefaultDecayTime = TimeSpan.FromMinutes( 7.0 );
+		private static TimeSpan m_BoneDecayTime = TimeSpan.FromMinutes( 7.0 );
+
+		private Timer m_DecayTimer;
+		private DateTime m_DecayTime;
+
+		public void BeginDecay( TimeSpan delay )
+		{
+			if ( m_DecayTimer != null )
+				m_DecayTimer.Stop();
+
+			m_DecayTime = DateTime.Now + delay;
+
+			m_DecayTimer = new InternalTimer( this, delay );
+			m_DecayTimer.Start();
+		}
+
+		public override void OnAfterDelete()
+		{
+			if ( m_DecayTimer != null )
+				m_DecayTimer.Stop();
+
+			m_DecayTimer = null;
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Corpse m_Corpse;
+
+			public InternalTimer( Corpse c, TimeSpan delay ) : base( delay )
+			{
+				m_Corpse = c;
+				Priority = TimerPriority.FiveSeconds;
+			}
+
+			protected override void OnTick()
+			{
+				if ( !m_Corpse.m_NoBones )
+					m_Corpse.TurnToBones();
+				else
+					m_Corpse.Delete();
+			}
+		}
+
+		public static string GetCorpseName( Mobile m )
+		{
+			Type t = m.GetType();
+
+			object[] attrs = t.GetCustomAttributes( typeof( CorpseNameAttribute ), true );
+
+			if ( attrs != null && attrs.Length > 0 )
+			{
+				CorpseNameAttribute attr = attrs[0] as CorpseNameAttribute;
+
+				if ( attr != null )
+					return attr.Name;
+			}
+
+			return null;
+		}
+
+		public static void Initialize()
+		{
+			Mobile.CreateCorpseHandler += new CreateCorpseHandler( Mobile_CreateCorpseHandler );
+		}
+
+		public static Container Mobile_CreateCorpseHandler( Mobile owner, HairInfo hair, FacialHairInfo facialhair, List<Item> initialContent, List<Item> equipItems )
+		{
+			bool shouldFillCorpse = true;
+
+			//if ( owner is BaseCreature )
+			//	shouldFillCorpse = !((BaseCreature)owner).IsBonded;
+
+			Corpse c;
+			if( owner is MilitiaFighter )
+				c = new MilitiaFighterCorpse( owner, hair, facialhair, shouldFillCorpse ? equipItems : new List<Item>() );
+			else
+				c = new Corpse( owner, hair, facialhair, shouldFillCorpse ? equipItems : new List<Item>() );
+
+			owner.Corpse = c;
+
+			if ( shouldFillCorpse )
+			{
+				for ( int i = 0; i < initialContent.Count; ++i )
+				{
+					Item item = initialContent[i];
+
+					if ( Core.AOS && owner.Player && item.Parent == owner.Backpack )
+						c.AddItem( item );
+					else
+						c.DropItem( item );
+
+					if ( owner.Player && Core.AOS )
+						c.SetRestoreInfo( item, item.Location );
+				}
+			}
+			else
+			{
+				c.Carved = true; // TODO: Is it needed?
+			}
+
+			Point3D loc = owner.Location;
+			Map map = owner.Map;
+
+			if ( map == null || map == Map.Internal )
+			{
+				loc = owner.LogoutLocation;
+				map = owner.LogoutMap;
+			}
+
+			c.MoveToWorld( loc, map );
+
+			return c;
+		}
+
+		public override bool IsPublicContainer{ get{ return true; } }
+
+		public Corpse( Mobile owner, List<Item> equipItems ) : this( owner, null, null, equipItems )
+		{
+		}
+		public Corpse( Mobile owner, HairInfo hair, FacialHairInfo facialhair, List<Item> equipItems )
+			: base( 0x2006 )
+		{
+			// To supress console warnings, stackable must be true
+			Stackable = true;
+			Amount = owner.Body; // protocol defines that for itemid 0x2006, amount=body
+			Stackable = false;
+
+			Movable = false;
+			Hue = owner.Hue;
+			Direction = owner.Direction;
+			Name = owner.Name;
+
+			m_Owner = owner;
+
+			m_CorpseName = GetCorpseName( owner );
+
+			m_TimeOfDeath = DateTime.Now;
+
+			m_AccessLevel = owner.AccessLevel;
+			m_Guild = owner.Guild as Guild;
+			m_Kills = owner.Kills;
+			m_Criminal = owner.Criminal;
+
+			m_Hair = hair;
+			m_FacialHair = facialhair;
+
+
+#if false
+			// This corpse does not turn to bones if:
+			//    (the owner is not a player) and (the owner doesn't have a human body)
+			m_NoBones = !owner.Player && !owner.Body.IsHuman;
+#else
+			// This corpse does not turn to bones if:
+			//    (the owner is not a player)
+			m_NoBones = !owner.Player;
+#endif
+
+			m_Looters = new List<Mobile>();
+			m_EquipItems = equipItems;
+
+			m_Aggressors = new List<Mobile>( owner.Aggressors.Count + owner.Aggressed.Count );
+			bool addToAggressors = !( owner is BaseCreature );
+
+			TimeSpan lastTime = TimeSpan.MaxValue;
+
+			for ( int i = 0; i < owner.Aggressors.Count; ++i )
+			{
+				AggressorInfo info = owner.Aggressors[i];
+
+				if ( (DateTime.Now - info.LastCombatTime) < lastTime )
+				{
+					m_Killer = info.Attacker;
+					lastTime = (DateTime.Now - info.LastCombatTime);
+				}
+
+				if ( addToAggressors && !info.CriminalAggression )
+					m_Aggressors.Add( info.Attacker );
+			}
+
+			for ( int i = 0; i < owner.Aggressed.Count; ++i )
+			{
+				AggressorInfo info = owner.Aggressed[i];
+
+				if ( (DateTime.Now - info.LastCombatTime) < lastTime )
+				{
+					m_Killer = info.Defender;
+					lastTime = (DateTime.Now - info.LastCombatTime);
+				}
+
+				if ( addToAggressors )
+					m_Aggressors.Add( info.Defender );
+			}
+
+			if ( !addToAggressors )
+			{
+				BaseCreature bc = (BaseCreature)owner;
+
+				Mobile master = bc.GetMaster();
+				if( master != null )
+					m_Aggressors.Add( master );
+
+				List<DamageStore> rights = BaseCreature.GetLootingRights( bc.DamageEntries, bc.HitsMax );
+				for ( int i = 0; i < rights.Count; ++i )
+				{
+					DamageStore ds = rights[i];
+
+					if ( ds.m_HasRight )
+						m_Aggressors.Add( ds.m_Mobile );
+				}
+			}
+
+			BeginDecay( m_DefaultDecayTime );
+		}
+
+		public Corpse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 10 ); // version
+
+			writer.WriteDeltaTime( m_TimeOfDeath );
+
+			ArrayList list = ( m_RestoreTable == null ? null : new ArrayList( m_RestoreTable ) );
+			int count = ( list == null ? 0 : list.Count );
+
+			writer.Write( count );
+
+			for ( int i = 0; list != null && i < list.Count; ++i )
+			{
+				DictionaryEntry de = (DictionaryEntry)list[i];
+				Item item = (Item)de.Key;
+				Point3D loc = (Point3D)de.Value;
+
+				writer.Write( item );
+
+				if ( item.Location == loc )
+				{
+					writer.Write( false );
+				}
+				else
+				{
+					writer.Write( true );
+					writer.Write( loc );
+				}
+			}
+
+			writer.Write( m_VisitedByTaxidermist );
+
+			writer.Write( m_DecayTimer != null );
+
+			if ( m_DecayTimer != null )
+				writer.WriteDeltaTime( m_DecayTime );
+
+			writer.Write( m_Looters );
+			writer.Write( m_Killer );
+
+			writer.Write( (bool) m_Carved );
+
+			writer.Write( m_Aggressors );
+
+			writer.Write( m_Owner );
+
+			writer.Write( m_NoBones );
+
+			writer.Write( (string) m_CorpseName );
+
+			writer.Write( (int) m_AccessLevel );
+			writer.Write( (Guild) m_Guild );
+			writer.Write( (int) m_Kills );
+			writer.Write( (bool) m_Criminal );
+
+			writer.Write( m_EquipItems );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 10:
+				{
+					m_TimeOfDeath = reader.ReadDeltaTime();
+
+					goto case 9;
+				}
+				case 9:
+				{
+					int count = reader.ReadInt();
+
+					for ( int i = 0; i < count; ++i )
+					{
+						Item item = reader.ReadItem();
+
+						if ( reader.ReadBool() )
+							SetRestoreInfo( item, reader.ReadPoint3D() );
+						else if ( item != null )
+							SetRestoreInfo( item, item.Location );
+					}
+
+					goto case 8;
+				}
+				case 8:
+				{
+					m_VisitedByTaxidermist = reader.ReadBool();
+
+					goto case 7;
+				}
+				case 7:
+				{
+					if ( reader.ReadBool() )
+						BeginDecay( reader.ReadDeltaTime() - DateTime.Now );
+
+					goto case 6;
+				}
+				case 6:
+				{
+					m_Looters = reader.ReadStrongMobileList();
+					m_Killer = reader.ReadMobile();
+
+					goto case 5;
+				}
+				case 5:
+				{
+					m_Carved = reader.ReadBool();
+
+					goto case 4;
+				}
+				case 4:
+				{
+					m_Aggressors = reader.ReadStrongMobileList();
+
+					goto case 3;
+				}
+				case 3:
+				{
+					m_Owner = reader.ReadMobile();
+
+					goto case 2;
+				}
+				case 2:
+				{
+					m_NoBones = reader.ReadBool();
+
+					goto case 1;
+				}
+				case 1:
+				{
+					m_CorpseName = reader.ReadString();
+
+					goto case 0;
+				}
+				case 0:
+				{
+					if ( version < 10 )
+						m_TimeOfDeath = DateTime.Now;
+
+					if ( version < 7 )
+						BeginDecay( m_DefaultDecayTime );
+
+					if ( version < 6 )
+						m_Looters = new List<Mobile>();
+
+					if ( version < 4 )
+						m_Aggressors = new List<Mobile>();
+
+					m_AccessLevel = (AccessLevel)reader.ReadInt();
+					reader.ReadInt(); // guild reserve
+					m_Kills = reader.ReadInt();
+					m_Criminal = reader.ReadBool();
+
+					m_EquipItems = reader.ReadStrongItemList();
+
+					break;
+				}
+			}
+		}
+
+		public override void SendInfoTo( NetState state )
+		{
+			base.SendInfoTo( state );
+
+			if ( ItemID == 0x2006 )
+			{
+				state.Send( new CorpseContent( state.Mobile, this ) );
+				state.Send( new CorpseEquip( state.Mobile, this ) );
+			}
+		}
+
+		public bool IsCriminalAction( Mobile from )
+		{
+			if ( from == m_Owner || from.AccessLevel >= AccessLevel.GameMaster )
+				return false;
+
+			Party p = Party.Get( m_Owner );
+
+			if ( p != null && p.Contains( from ) )
+			{
+				PartyMemberInfo pmi = p[m_Owner];
+
+				if ( pmi != null && pmi.CanLoot )
+					return false;
+			}
+
+			return ( NotorietyHandlers.CorpseNotoriety( from, this ) == Notoriety.Innocent );
+		}
+
+		public override bool CheckItemUse( Mobile from, Item item )
+		{
+			if ( !base.CheckItemUse( from, item ) )
+				return false;
+
+			if ( item != this )
+				return CanLoot( from );
+
+			return true;
+		}
+
+		public override bool CheckLift( Mobile from, Item item, ref LRReason reject )
+		{
+			if ( !base.CheckLift( from, item, ref reject ) )
+				return false;
+
+			return CanLoot( from );
+		}
+
+		public override void OnItemUsed( Mobile from, Item item )
+		{
+			base.OnItemUsed( from, item );
+
+			if ( from != m_Owner )
+				from.RevealingAction();
+
+			if ( item != this && IsCriminalAction( from ) )
+				from.CriminalAction( true );
+
+			if ( !m_Looters.Contains( from ) )
+				m_Looters.Add( from );
+		}
+
+		public override void OnItemLifted( Mobile from, Item item )
+		{
+			base.OnItemLifted( from, item );
+
+			if ( item != this && from != m_Owner )
+				from.RevealingAction();
+
+			if ( item != this && IsCriminalAction( from ) )
+				from.CriminalAction( true );
+
+			if ( !m_Looters.Contains( from ) )
+				m_Looters.Add( from );
+		}
+
+		private class OpenCorpseEntry : ContextMenuEntry
+		{
+			public OpenCorpseEntry() : base( 6215, 2 )
+			{
+			}
+
+			public override void OnClick()
+			{
+				Corpse corpse = Owner.Target as Corpse;
+
+				if ( corpse != null && Owner.From.CheckAlive() )
+					corpse.Open( Owner.From, false );
+			}
+		}
+
+		public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
+		{
+			base.GetContextMenuEntries( from, list );
+
+			if ( Core.AOS && m_Owner == from && from.Alive )
+				list.Add( new OpenCorpseEntry() );
+		}
+
+		private Hashtable m_RestoreTable;
+
+		public bool GetRestoreInfo( Item item, ref Point3D loc )
+		{
+			if ( m_RestoreTable == null || item == null )
+				return false;
+
+			object obj = m_RestoreTable[item];
+
+			if ( obj == null )
+				return false;
+
+			loc = (Point3D)obj;
+			return true;
+		}
+
+		public void SetRestoreInfo( Item item, Point3D loc )
+		{
+			if ( item == null )
+				return;
+
+			if ( m_RestoreTable == null )
+				m_RestoreTable = new Hashtable();
+
+			m_RestoreTable[item] = loc;
+		}
+
+		public void ClearRestoreInfo( Item item )
+		{
+			if ( m_RestoreTable == null || item == null )
+				return;
+
+			m_RestoreTable.Remove( item );
+
+			if ( m_RestoreTable.Count == 0 )
+				m_RestoreTable = null;
+		}
+
+		public bool CanLoot( Mobile from )
+		{
+			if ( !IsCriminalAction( from ) )
+				return true;
+
+			Map map = this.Map;
+
+			if ( map == null || (map.Rules & MapRules.HarmfulRestrictions) != 0 )
+				return false;
+
+			return true;
+		}
+
+		public bool CheckLoot( Mobile from )
+		{
+			if ( !CanLoot( from ) )
+			{
+				if ( m_Owner == null || !m_Owner.Player )
+					from.SendLocalizedMessage( 1005035 ); // You did not earn the right to loot this creature!
+				else
+					from.SendLocalizedMessage( 1010049 ); // You may not loot this corpse.
+
+				return false;
+			}
+			else if ( IsCriminalAction( from ) )
+			{
+				if ( m_Owner == null || !m_Owner.Player )
+					from.SendLocalizedMessage( 1005036 ); // Looting this monster corpse will be a criminal act!
+				else
+					from.SendLocalizedMessage( 1005038 ); // Looting this corpse will be a criminal act!
+			}
+
+			return true;
+		}
+
+		public virtual void Open( Mobile from, bool checkSelfLoot )
+		{
+			if ( from.AccessLevel > AccessLevel.Player || from.InRange( this.GetWorldLocation(), 2 ) )
+			{
+				bool selfLoot = ( checkSelfLoot && ( from == m_Owner ) );
+
+				if ( selfLoot )
+				{
+					List<Item> items = new List<Item>( this.Items );
+
+					bool gathered = false;
+					bool didntFit = false;
+
+					Container pack = from.Backpack;
+
+					bool checkRobe = true;
+
+					for ( int i = 0; !didntFit && i < items.Count; ++i )
+					{
+						Item item = items[i];
+						Point3D loc = item.Location;
+
+						if ( (item.Layer == Layer.Hair || item.Layer == Layer.FacialHair) || !item.Movable || !GetRestoreInfo( item, ref loc ) )
+							continue;
+
+						if ( checkRobe )
+						{
+							DeathRobe robe = from.FindItemOnLayer( Layer.OuterTorso ) as DeathRobe;
+
+							if ( robe != null )
+							{
+								if ( Core.SE )
+								{
+									robe.Delete();
+								}
+								else
+								{
+									Map map = from.Map;
+	
+									if ( map != null && map != Map.Internal )
+										robe.MoveToWorld( from.Location, map );
+								}
+							}
+						}
+
+						if ( m_EquipItems.Contains( item ) && from.EquipItem( item ) )
+						{
+							gathered = true;
+						}
+						else if ( pack != null && pack.CheckHold( from, item, false, true ) )
+						{
+							item.Location = loc;
+							pack.AddItem( item );
+							gathered = true;
+						}
+						else
+						{
+							didntFit = true;
+						}
+					}
+
+					if ( gathered && !didntFit )
+					{
+						m_Carved = true;
+
+						if ( ItemID == 0x2006 )
+						{
+							ProcessDelta();
+							SendRemovePacket();
+							ItemID = Utility.Random( 0xECA, 9 ); // bone graphic
+							Hue = 0;
+							ProcessDelta();
+						}
+
+						from.PlaySound( 0x3E3 );
+						from.SendLocalizedMessage( 1062471 ); // You quickly gather all of your belongings.
+						return;
+					}
+
+					if ( gathered && didntFit )
+						from.SendLocalizedMessage( 1062472 ); // You gather some of your belongings. The rest remain on the corpse.
+				}
+
+				if ( !CheckLoot( from ) )
+					return;
+
+				PlayerMobile player = from as PlayerMobile;
+
+				if ( player != null )
+				{
+					QuestSystem qs = player.Quest;
+
+					if ( qs is UzeraanTurmoilQuest )
+					{
+						GetDaemonBoneObjective obj = qs.FindObjective( typeof( GetDaemonBoneObjective ) ) as GetDaemonBoneObjective;
+
+						if ( obj != null && obj.CorpseWithBone == this && ( !obj.Completed || UzeraanTurmoilQuest.HasLostDaemonBone( player ) ) )
+						{
+							Item bone = new QuestDaemonBone();
+
+							if ( player.PlaceInBackpack( bone ) )
+							{
+								obj.CorpseWithBone = null;
+								player.SendLocalizedMessage( 1049341, "", 0x22 ); // You rummage through the bones and find a Daemon Bone!  You quickly place the item in your pack.
+
+								if ( !obj.Completed )
+									obj.Complete();
+							}
+							else
+							{
+								bone.Delete();
+								player.SendLocalizedMessage( 1049342, "", 0x22 ); // Rummaging through the bones you find a Daemon Bone, but can't pick it up because your pack is too full.  Come back when you have more room in your pack.
+							}
+
+							return;
+						}
+					}
+					else if ( qs is TheSummoningQuest )
+					{
+						VanquishDaemonObjective obj = qs.FindObjective( typeof( VanquishDaemonObjective ) ) as VanquishDaemonObjective;
+
+						if ( obj != null && obj.Completed && obj.CorpseWithSkull == this )
+						{
+							GoldenSkull sk = new GoldenSkull();
+
+							if ( player.PlaceInBackpack( sk ) )
+							{
+								obj.CorpseWithSkull = null;
+								player.SendLocalizedMessage( 1050022 ); // For your valor in combating the devourer, you have been awarded a golden skull.
+								qs.Complete();
+							}
+							else
+							{
+								sk.Delete();
+								player.SendLocalizedMessage( 1050023 ); // You find a golden skull, but your backpack is too full to carry it.
+							}
+						}
+					}
+				}
+
+				base.OnDoubleClick( from );
+
+				if ( from != m_Owner )
+					from.RevealingAction();
+			}
+			else
+			{
+				from.SendLocalizedMessage( 500446 ); // That is too far away.
+				return;
+			}
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			Open( from, Core.AOS );
+		}
+
+		public override bool CheckContentDisplay( Mobile from )
+		{
+			return false;
+		}
+
+		public override bool DisplaysContent{ get{ return false; } }
+
+		public override void AddNameProperty( ObjectPropertyList list )
+		{
+			if ( ItemID == 0x2006 ) // Corpse form
+			{
+				if ( m_CorpseName != null )
+					list.Add( m_CorpseName );
+				else
+					list.Add( 1046414, this.Name ); // the remains of ~1_NAME~
+			}
+			else // Bone form
+			{
+				list.Add( 1046414, this.Name ); // the remains of ~1_NAME~
+			}
+		}
+
+		public override void OnAosSingleClick( Mobile from )
+		{
+			int hue = Notoriety.GetHue( NotorietyHandlers.CorpseNotoriety( from, this ) );
+			ObjectPropertyList opl = this.PropertyList;
+
+			if ( opl.Header > 0 )
+				from.Send( new MessageLocalized( Serial, ItemID, MessageType.Label, hue, 3, opl.Header, Name, opl.HeaderArgs ) );
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			int hue = Notoriety.GetHue( NotorietyHandlers.CorpseNotoriety( from, this ) );
+
+			if ( ItemID == 0x2006 ) // Corpse form
+			{
+				if ( m_CorpseName != null )
+					from.Send( new AsciiMessage( Serial, ItemID, MessageType.Label, hue, 3, "", m_CorpseName ) );
+				else
+					from.Send( new MessageLocalized( Serial, ItemID, MessageType.Label, hue, 3, 1046414, "", Name ) );
+			}
+			else // Bone form
+			{
+				from.Send( new MessageLocalized( Serial, ItemID, MessageType.Label, hue, 3, 1046414, "", Name ) );
+			}
+		}
+
+		public void Carve( Mobile from, Item item )
+		{
+			Mobile dead = m_Owner;
+
+			if ( m_Carved || dead == null )
+			{
+				from.SendLocalizedMessage( 500485 ); // You see nothing useful to carve from the corpse.
+			}
+			else if ( ((Body)Amount).IsHuman && ItemID == 0x2006 )
+			{
+				new Blood( 0x122D ).MoveToWorld( Location, Map );
+
+				new Torso().MoveToWorld( Location, Map );
+				new LeftLeg().MoveToWorld( Location, Map );
+				new LeftArm().MoveToWorld( Location, Map );
+				new RightLeg().MoveToWorld( Location, Map );
+				new RightArm().MoveToWorld( Location, Map );
+				new Head( dead.Name ).MoveToWorld( Location, Map );
+
+				m_Carved = true;
+
+				ProcessDelta();
+				SendRemovePacket();
+				ItemID = Utility.Random( 0xECA, 9 ); // bone graphic
+				Hue = 0;
+				ProcessDelta();
+
+				if ( IsCriminalAction( from ) )
+					from.CriminalAction( true );
+			}
+			else if ( dead is BaseCreature )
+			{
+				((BaseCreature)dead).OnCarve( from, this );
+			}
+			else
+			{
+				from.SendLocalizedMessage( 500485 ); // You see nothing useful to carve from the corpse.
+			}
+		}
+	}
+}

Scripts/Items/Misc/Corpses/CorpseNameAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Server
+{
+	[AttributeUsage( AttributeTargets.Class )]
+	public class CorpseNameAttribute : Attribute
+	{
+		private string m_Name;
+
+		public string Name
+		{
+			get{ return m_Name; }
+		}
+
+		public CorpseNameAttribute( string name )
+		{
+			m_Name = name;
+		}
+	}
+}

Scripts/Items/Misc/Corpses/DecayedCorpse.cs

@@ -0,0 +1,115 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class DecayedCorpse : Container
+	{
+		private Timer m_DecayTimer;
+		private DateTime m_DecayTime;
+
+		private static TimeSpan m_DefaultDecayTime = TimeSpan.FromMinutes( 7.0 );
+
+		public DecayedCorpse( string name ) : base( Utility.Random( 0xECA, 9 ) )
+		{
+			Movable = false;
+			Name = name;
+
+			BeginDecay( m_DefaultDecayTime );
+		}
+
+		public void BeginDecay( TimeSpan delay )
+		{
+			if ( m_DecayTimer != null )
+				m_DecayTimer.Stop();
+
+			m_DecayTime = DateTime.Now + delay;
+
+			m_DecayTimer = new InternalTimer( this, delay );
+			m_DecayTimer.Start();
+		}
+
+		public override void OnAfterDelete()
+		{
+			if ( m_DecayTimer != null )
+				m_DecayTimer.Stop();
+
+			m_DecayTimer = null;
+		}
+
+		private class InternalTimer : Timer
+		{
+			private DecayedCorpse m_Corpse;
+
+			public InternalTimer( DecayedCorpse c, TimeSpan delay ) : base( delay )
+			{
+				m_Corpse = c;
+				Priority = TimerPriority.FiveSeconds;
+			}
+
+			protected override void OnTick()
+			{
+				m_Corpse.Delete();
+			}
+		}
+
+		// Do not display (x items, y stones)
+		public override bool CheckContentDisplay( Mobile from )
+		{
+			return false;
+		}
+
+		// Do not display (x items, y stones)
+		public override bool DisplaysContent{ get{ return false; } }
+
+		public override void AddNameProperty( ObjectPropertyList list )
+		{
+			list.Add( 1046414, Name ); // the remains of ~1_NAME~
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			this.LabelTo( from, 1046414, Name ); // the remains of ~1_NAME~
+		}
+
+		public DecayedCorpse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( m_DecayTimer != null );
+
+			if ( m_DecayTimer != null )
+				writer.WriteDeltaTime( m_DecayTime );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					BeginDecay( m_DefaultDecayTime );
+
+					break;
+				}
+				case 1:
+				{
+					if ( reader.ReadBool() )
+						BeginDecay( reader.ReadDeltaTime() - DateTime.Now );
+
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Items/Misc/Corpses/Packets.cs

@@ -0,0 +1,125 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Items;
+
+namespace Server.Network
+{
+	public sealed class CorpseEquip : Packet
+	{
+		public CorpseEquip( Mobile beholder, Corpse beheld ) : base( 0x89 )
+		{
+			List<Item> list = beheld.EquipItems;
+
+			int count = list.Count;
+			if( beheld.Hair != null && beheld.Hair.ItemID > 0 )
+				count++;
+			if( beheld.FacialHair != null && beheld.FacialHair.ItemID > 0 )
+				count++;
+
+			EnsureCapacity( 8 + (count * 5) );
+
+			m_Stream.Write( (int) beheld.Serial );
+
+			for ( int i = 0; i < list.Count; ++i )
+			{
+				Item item = list[i];
+
+				if ( !item.Deleted && beholder.CanSee( item ) && item.Parent == beheld )
+				{
+					m_Stream.Write( (byte) (item.Layer + 1) );
+					m_Stream.Write( (int) item.Serial );
+				}
+			}
+
+			if( beheld.Hair != null && beheld.Hair.ItemID > 0 )
+			{
+				m_Stream.Write( (byte)(Layer.Hair + 1) );
+				m_Stream.Write( (int)HairInfo.FakeSerial( beheld.Owner ) - 2 );
+			}
+
+			if( beheld.FacialHair != null && beheld.FacialHair.ItemID > 0 )
+			{
+				m_Stream.Write( (byte)(Layer.FacialHair + 1) );
+				m_Stream.Write( (int)FacialHairInfo.FakeSerial( beheld.Owner ) - 2 );
+			}
+
+			m_Stream.Write( (byte) Layer.Invalid );
+		}
+	}
+
+	public sealed class CorpseContent : Packet
+	{
+		public CorpseContent( Mobile beholder, Corpse beheld )
+			: base( 0x3C )
+		{
+			List<Item> items = beheld.EquipItems;
+			int count = items.Count;
+
+			if( beheld.Hair != null && beheld.Hair.ItemID > 0 )
+				count++;
+			if( beheld.FacialHair != null && beheld.FacialHair.ItemID > 0 )
+				count++;
+
+			EnsureCapacity( 5 + (count * 19) );
+
+			long pos = m_Stream.Position;
+
+			int written = 0;
+
+			m_Stream.Write( (ushort)0 );
+
+			for( int i = 0; i < items.Count; ++i )
+			{
+				Item child = items[i];
+
+				if( !child.Deleted && child.Parent == beheld && beholder.CanSee( child ) )
+				{
+					m_Stream.Write( (int)child.Serial );
+					m_Stream.Write( (ushort)child.ItemID );
+					m_Stream.Write( (byte)0 ); // signed, itemID offset
+					m_Stream.Write( (ushort)child.Amount );
+					m_Stream.Write( (short)child.X );
+					m_Stream.Write( (short)child.Y );
+					m_Stream.Write( (int)beheld.Serial );
+					m_Stream.Write( (ushort)child.Hue );
+
+					++written;
+				}
+			}
+
+			if( beheld.Hair != null && beheld.Hair.ItemID > 0 )
+			{
+				m_Stream.Write( (int)HairInfo.FakeSerial( beheld.Owner ) - 2 );
+				m_Stream.Write( (ushort)beheld.Hair.ItemID );
+				m_Stream.Write( (byte)0 ); // signed, itemID offset
+				m_Stream.Write( (ushort)1 );
+				m_Stream.Write( (short)0 );
+				m_Stream.Write( (short)0 );
+				m_Stream.Write( (int)beheld.Serial );
+				m_Stream.Write( (ushort)beheld.Hair.Hue );
+
+				++written;
+			}
+
+			if( beheld.FacialHair != null && beheld.FacialHair.ItemID > 0 )
+			{
+				m_Stream.Write( (int)FacialHairInfo.FakeSerial( beheld.Owner ) - 2 );
+				m_Stream.Write( (ushort)beheld.FacialHair.ItemID );
+				m_Stream.Write( (byte)0 ); // signed, itemID offset
+				m_Stream.Write( (ushort)1 );
+				m_Stream.Write( (short)0 );
+				m_Stream.Write( (short)0 );
+				m_Stream.Write( (int)beheld.Serial );
+				m_Stream.Write( (ushort)beheld.FacialHair.Hue );
+
+				++written;
+			}
+
+			m_Stream.Seek( pos, SeekOrigin.Begin );
+			m_Stream.Write( (ushort)written );
+		}
+	}
+}