#W# Source and Scripts added. Added Scripts/Settings.cs to expose some basic tweak able settings.

Scripts/Items/Skill Items/Camping/Bedroll.cs

@@ -0,0 +1,131 @@
+using System;
+using Server;
+using Server.Network;
+using Server.Mobiles;
+using Server.Gumps;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xA57, 0xA58, 0xA59 )]
+	public class Bedroll : Item
+	{
+		[Constructable]
+		public Bedroll() : base( 0xA57 )
+		{
+			Weight = 5.0;
+		}
+
+		public Bedroll( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( this.Parent != null || !this.VerifyMove( from ) )
+				return;
+
+			if ( !from.InRange( this, 2 ) )
+			{
+				from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
+				return;
+			}
+
+			if ( this.ItemID == 0xA57 ) // rolled
+			{
+				Direction dir = PlayerMobile.GetDirection4( from.Location, this.Location );
+
+				if ( dir == Direction.North || dir == Direction.South )
+					this.ItemID = 0xA55;
+				else
+					this.ItemID = 0xA56;
+			}
+			else // unrolled
+			{
+				this.ItemID = 0xA57;
+
+				if ( !from.HasGump( typeof( LogoutGump ) ) )
+				{
+					CampfireEntry entry = Campfire.GetEntry( from );
+
+					if ( entry != null && entry.Safe )
+						from.SendGump( new LogoutGump( entry, this ) );
+				}
+			}
+		}
+
+		private class LogoutGump : Gump
+		{
+			private Timer m_CloseTimer;
+
+			private CampfireEntry m_Entry;
+			private Bedroll m_Bedroll;
+
+			public LogoutGump( CampfireEntry entry, Bedroll bedroll ) : base( 100, 0 )
+			{
+				m_Entry = entry;
+				m_Bedroll = bedroll;
+
+				m_CloseTimer = Timer.DelayCall( TimeSpan.FromSeconds( 10.0 ), new TimerCallback( CloseGump ) );
+
+				AddBackground( 0, 0, 400, 350, 0xA28 );
+
+				AddHtmlLocalized( 100, 20, 200, 35, 1011015, false, false ); // <center>Logging out via camping</center>
+
+				/* Using a bedroll in the safety of a camp will log you out of the game safely.
+				 * If this is what you wish to do choose CONTINUE and you will be logged out.
+				 * Otherwise, select the CANCEL button to avoid logging out at this time.
+				 * The camp will remain secure for 10 seconds at which time this window will close
+				 * and you not be logged out.
+				 */
+				AddHtmlLocalized( 50, 55, 300, 140, 1011016, true, true );
+
+				AddButton( 45, 298, 0xFA5, 0xFA7, 1, GumpButtonType.Reply, 0 );
+				AddHtmlLocalized( 80, 300, 110, 35, 1011011, false, false ); // CONTINUE
+
+				AddButton( 200, 298, 0xFA5, 0xFA7, 0, GumpButtonType.Reply, 0 );
+				AddHtmlLocalized( 235, 300, 110, 35, 1011012, false, false ); // CANCEL
+			}
+
+			public override void OnResponse( NetState sender, RelayInfo info )
+			{
+				PlayerMobile pm = m_Entry.Player;
+
+				m_CloseTimer.Stop();
+
+				if ( Campfire.GetEntry( pm ) != m_Entry )
+					return;
+
+				if ( info.ButtonID == 1 && m_Entry.Safe && m_Bedroll.Parent == null && m_Bedroll.IsAccessibleTo( pm )
+					&& m_Bedroll.VerifyMove( pm ) && m_Bedroll.Map == pm.Map && pm.InRange( m_Bedroll, 2 ) )
+				{
+					pm.PlaceInBackpack( m_Bedroll );
+
+					pm.BedrollLogout = true;
+					sender.Dispose();
+				}
+
+				Campfire.RemoveEntry( m_Entry );
+			}
+
+			private void CloseGump()
+			{
+				Campfire.RemoveEntry( m_Entry );
+				m_Entry.Player.CloseGump( typeof( LogoutGump ) );
+			}
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.WriteEncodedInt( 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadEncodedInt();
+		}
+	}
+}

Scripts/Items/Skill Items/Camping/Campfire.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Network;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+	public enum CampfireStatus
+	{
+		Burning,
+		Extinguishing,
+		Off
+	}
+
+	public class Campfire : Item
+	{
+		public static readonly int SecureRange = 7;
+
+		private static readonly Hashtable m_Table = new Hashtable();
+
+		public static CampfireEntry GetEntry( Mobile player )
+		{
+			return (CampfireEntry) m_Table[player];
+		}
+
+		public static void RemoveEntry( CampfireEntry entry )
+		{
+			m_Table.Remove( entry.Player );
+			entry.Fire.m_Entries.Remove( entry );
+		}
+
+		private Timer m_Timer;
+		private DateTime m_Created;
+
+		private ArrayList m_Entries;
+
+		public Campfire() : base( 0xDE3 )
+		{
+			Movable = false;
+			Light = LightType.Circle300;
+
+			m_Entries = new ArrayList();
+
+			m_Created = DateTime.UtcNow;
+			m_Timer = Timer.DelayCall( TimeSpan.FromSeconds( 1.0 ), TimeSpan.FromSeconds( 1.0 ), new TimerCallback( OnTick ) );
+		}
+
+		public Campfire( Serial serial ) : base( serial )
+		{
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public DateTime Created
+		{
+			get{ return m_Created; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public CampfireStatus Status
+		{
+			get
+			{
+				switch ( this.ItemID )
+				{
+					case 0xDE3:
+						return CampfireStatus.Burning;
+
+					case 0xDE9:
+						return CampfireStatus.Extinguishing;
+
+					default:
+						return CampfireStatus.Off;
+				}
+			}
+			set
+			{
+				if ( this.Status == value )
+					return;
+
+				switch ( value )
+				{
+					case CampfireStatus.Burning:
+						this.ItemID = 0xDE3;
+						this.Light = LightType.Circle300;
+						break;
+
+					case CampfireStatus.Extinguishing:
+						this.ItemID = 0xDE9;
+						this.Light = LightType.Circle150;
+						break;
+
+					default:
+						this.ItemID = 0xDEA;
+						this.Light = LightType.ArchedWindowEast;
+						ClearEntries();
+						break;
+				}
+			}
+		}
+
+		private void OnTick()
+		{
+			DateTime now = DateTime.UtcNow;
+			TimeSpan age = now - this.Created;
+
+			if ( age >= TimeSpan.FromSeconds( 100.0 ) )
+				this.Delete();
+			else if ( age >= TimeSpan.FromSeconds( 90.0 ) )
+				this.Status = CampfireStatus.Off;
+			else if ( age >= TimeSpan.FromSeconds( 60.0 ) )
+				this.Status = CampfireStatus.Extinguishing;
+
+			if ( this.Status == CampfireStatus.Off || this.Deleted )
+				return;
+
+			foreach ( CampfireEntry entry in new ArrayList( m_Entries ) )
+			{
+				if ( !entry.Valid || entry.Player.NetState == null )
+				{
+					RemoveEntry( entry );
+				}
+				else if ( !entry.Safe && now - entry.Start >= TimeSpan.FromSeconds( 30.0 ) )
+				{
+					entry.Safe = true;
+					entry.Player.SendLocalizedMessage( 500621 ); // The camp is now secure.
+				}
+			}
+
+			IPooledEnumerable eable = this.GetClientsInRange( SecureRange );
+
+			foreach ( NetState state in eable )
+			{
+				PlayerMobile pm = state.Mobile as PlayerMobile;
+
+				if ( pm != null && GetEntry( pm ) == null )
+				{
+					CampfireEntry entry = new CampfireEntry( pm, this );
+
+					m_Table[pm] = entry;
+					m_Entries.Add( entry );
+
+					pm.SendLocalizedMessage( 500620 ); // You feel it would take a few moments to secure your camp.
+				}
+			}
+
+			eable.Free();
+		}
+
+		private void ClearEntries()
+		{
+			if ( m_Entries == null )
+				return;
+
+			foreach ( CampfireEntry entry in new ArrayList( m_Entries ) )
+			{
+				RemoveEntry( entry );
+			}
+		}
+
+		public override void OnAfterDelete()
+		{
+			if ( m_Timer != null )
+				m_Timer.Stop();
+
+			ClearEntries();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			this.Delete();
+		}
+	}
+
+	public class CampfireEntry
+	{
+		private PlayerMobile m_Player;
+		private Campfire m_Fire;
+		private DateTime m_Start;
+		private bool m_Safe;
+
+		public PlayerMobile Player{ get{ return m_Player; } }
+		public Campfire Fire{ get{ return m_Fire; } }
+		public DateTime Start{ get{ return m_Start; } }
+
+		public bool Valid
+		{
+			get{ return !Fire.Deleted && Fire.Status != CampfireStatus.Off && Player.Map == Fire.Map && Player.InRange( Fire, Campfire.SecureRange ); }
+		}
+
+		public bool Safe
+		{
+			get{ return Valid && m_Safe; }
+			set{ m_Safe = value; }
+		}
+
+		public CampfireEntry( PlayerMobile player, Campfire fire )
+		{
+			m_Player = player;
+			m_Fire = fire;
+			m_Start = DateTime.UtcNow;
+			m_Safe = false;
+		}
+	}
+}

Scripts/Items/Skill Items/Camping/Kindling.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Network;
+using Server.Regions;
+
+namespace Server.Items
+{
+	public class Kindling : Item
+	{
+		[Constructable]
+		public Kindling() : this( 1 )
+		{
+		}
+
+		[Constructable]
+		public Kindling( int amount ) : base( 0xDE1 )
+		{
+			Stackable = true;
+			Weight = 5.0;
+			Amount = amount;
+		}
+
+		public Kindling( Serial serial ) : base( serial )
+		{
+		}
+
+		
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !this.VerifyMove( from ) )
+				return;
+
+			if ( !from.InRange( this.GetWorldLocation(), 2 ) )
+			{
+				from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
+				return;
+			}
+
+			Point3D fireLocation = GetFireLocation( from );
+
+			if ( fireLocation == Point3D.Zero )
+			{
+				from.SendLocalizedMessage( 501695 ); // There is not a spot nearby to place your campfire.
+			}
+			else if ( !from.CheckSkill( SkillName.Camping, 0.0, 100.0 ) )
+			{
+				from.SendLocalizedMessage( 501696 ); // You fail to ignite the campfire.
+			}
+			else
+			{
+				Consume();
+
+				if ( !this.Deleted && this.Parent == null )
+					from.PlaceInBackpack( this );
+
+				new Campfire().MoveToWorld( fireLocation, from.Map );
+			}
+		}
+
+		private Point3D GetFireLocation( Mobile from )
+		{
+			if ( from.Region.IsPartOf( typeof( DungeonRegion ) ) )
+				return Point3D.Zero;
+
+			if ( this.Parent == null )
+				return this.Location;
+
+			ArrayList list = new ArrayList( 4 );
+
+			AddOffsetLocation( from,  0, -1, list );
+			AddOffsetLocation( from, -1,  0, list );
+			AddOffsetLocation( from,  0,  1, list );
+			AddOffsetLocation( from,  1,  0, list );
+
+			if ( list.Count == 0 )
+				return Point3D.Zero;
+
+			int idx = Utility.Random( list.Count );
+			return (Point3D) list[idx];
+		}
+
+		private void AddOffsetLocation( Mobile from, int offsetX, int offsetY, ArrayList list )
+		{
+			Map map = from.Map;
+
+			int x = from.X + offsetX;
+			int y = from.Y + offsetY;
+
+			Point3D loc = new Point3D( x, y, from.Z );
+
+			if ( map.CanFit( loc, 1 ) && from.InLOS( loc ) )
+			{
+				list.Add( loc );
+			}
+			else
+			{
+				loc = new Point3D( x, y, map.GetAverageZ( x, y ) );
+
+				if ( map.CanFit( loc, 1 ) && from.InLOS( loc ) )
+					list.Add( loc );
+			}
+		}
+	}
+}