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

Scripts/Engines/Quests/Collector/Items/EnchantedPaints.cs

@@ -0,0 +1,141 @@
+using System;
+using Server;
+using Server.Mobiles;
+using Server.Targeting;
+using Server.Engines.Quests;
+
+namespace Server.Engines.Quests.Collector
+{
+	public class EnchantedPaints : QuestItem
+	{
+		[Constructable]
+		public EnchantedPaints() : base( 0xFC1 )
+		{
+			LootType = LootType.Blessed;
+
+			Weight = 1.0;
+		}
+
+		public EnchantedPaints( Serial serial ) : base( serial )
+		{
+		}
+
+		public override bool CanDrop( PlayerMobile player )
+		{
+			CollectorQuest qs = player.Quest as CollectorQuest;
+
+			if ( qs == null )
+				return true;
+
+			/*return !( qs.IsObjectiveInProgress( typeof( CaptureImagesObjective ) )
+				|| qs.IsObjectiveInProgress( typeof( ReturnImagesObjective ) ) );*/
+			return false;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			PlayerMobile player = from as PlayerMobile;
+
+			if ( player != null )
+			{
+				QuestSystem qs = player.Quest;
+
+				if ( qs is CollectorQuest )
+				{
+					if ( qs.IsObjectiveInProgress( typeof( CaptureImagesObjective ) ) )
+					{
+						player.SendAsciiMessage( 0x59, "Target the creature whose image you wish to create." );
+						player.Target = new InternalTarget( this );
+
+						return;
+					}
+				}
+			}
+
+			from.SendLocalizedMessage( 1010085 ); // You cannot use this.
+		}
+
+		private class InternalTarget : Target
+		{
+			private EnchantedPaints m_Paints;
+
+			public InternalTarget( EnchantedPaints paints ) : base( -1, false, TargetFlags.None )
+			{
+				CheckLOS = false;
+				m_Paints = paints;
+			}
+
+			protected override void OnTarget( Mobile from, object targeted )
+			{
+				if ( m_Paints.Deleted || !m_Paints.IsChildOf( from.Backpack ) )
+					return;
+
+				PlayerMobile player = from as PlayerMobile;
+
+				if ( player != null )
+				{
+					QuestSystem qs = player.Quest;
+
+					if ( qs is CollectorQuest )
+					{
+						CaptureImagesObjective obj = qs.FindObjective( typeof( CaptureImagesObjective ) ) as CaptureImagesObjective;
+
+						if ( obj != null && !obj.Completed )
+						{
+							if ( targeted is Mobile )
+							{
+								ImageType image;
+								CaptureResponse response = obj.CaptureImage(( targeted.GetType().Name=="GreaterMongbat" ? new Mongbat().GetType() : targeted.GetType() ), out image );
+
+								switch ( response )
+								{
+									case CaptureResponse.Valid:
+									{
+										player.SendLocalizedMessage( 1055125 ); // The enchanted paints swirl for a moment then an image begins to take shape. *Click*
+										player.AddToBackpack( new PaintedImage( image ) );
+
+										break;
+									}
+									case CaptureResponse.AlreadyDone:
+									{
+										player.SendAsciiMessage( 0x2C, "You have already captured the image of this creature" );
+
+										break;
+									}
+									case CaptureResponse.Invalid:
+									{
+										player.SendLocalizedMessage( 1055124 ); // You have no interest in capturing the image of this creature.
+
+										break;
+									}
+								}
+							}
+							else
+							{
+								player.SendAsciiMessage( 0x35, "You have no interest in that." );
+							}
+
+							return;
+						}
+					}
+				}
+
+				from.SendLocalizedMessage( 1010085 ); // You cannot use this.
+			}
+		}
+
+		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();
+		}
+	}
+}

Scripts/Engines/Quests/Collector/Items/ImageType.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Mobiles;
+
+namespace Server.Engines.Quests.Collector
+{
+	public enum ImageType
+	{
+		Betrayer,
+		Bogling,
+		BogThing,
+		Gazer,
+		Beetle,
+		GiantBlackWidow,
+		Scorpion,
+		JukaMage,
+		JukaWarrior,
+		Lich,
+		MeerMage,
+		MeerWarrior,
+		Mongbat,
+		Mummy,
+		Pixie,
+		PlagueBeast,
+		SandVortex,
+		StoneGargoyle,
+		SwampDragon,
+		Wisp,
+		Juggernaut
+	}
+
+	public class ImageTypeInfo
+	{
+		private static readonly ImageTypeInfo[] m_Table = new ImageTypeInfo[]
+			{
+				new ImageTypeInfo( 9734, typeof( Betrayer ), 75, 45 ),
+				new ImageTypeInfo( 9735, typeof( Bogling ), 75, 45 ),
+				new ImageTypeInfo( 9736, typeof( BogThing ), 60, 47 ),
+				new ImageTypeInfo( 9615, typeof( Gazer ), 75, 45 ),
+				new ImageTypeInfo( 9743, typeof( Beetle ), 60, 55 ),
+				new ImageTypeInfo( 9667, typeof( GiantBlackWidow ), 55, 52 ),
+				new ImageTypeInfo( 9657, typeof( Scorpion ), 65, 47 ),
+				new ImageTypeInfo( 9758, typeof( JukaMage ), 75, 45 ),
+				new ImageTypeInfo( 9759, typeof( JukaWarrior ), 75, 45 ),
+				new ImageTypeInfo( 9636, typeof( Lich ), 75, 45 ),
+				new ImageTypeInfo( 9756, typeof( MeerMage ), 75, 45 ),
+				new ImageTypeInfo( 9757, typeof( MeerWarrior ), 75, 45 ),
+				new ImageTypeInfo( 9638, typeof( Mongbat ), 70, 50 ),
+				new ImageTypeInfo( 9639, typeof( Mummy ), 75, 45 ),
+				new ImageTypeInfo( 9654, typeof( Pixie ), 75, 45 ),
+				new ImageTypeInfo( 9747, typeof( PlagueBeast ), 60, 45 ),
+				new ImageTypeInfo( 9750, typeof( SandVortex ), 60, 43 ),
+				new ImageTypeInfo( 9614, typeof( StoneGargoyle ), 75, 45 ),
+				new ImageTypeInfo( 9753, typeof( SwampDragon ), 50, 55 ),
+				new ImageTypeInfo( 8448, typeof( Wisp ), 75, 45 ),
+				new ImageTypeInfo( 9746, typeof( Juggernaut ), 55, 38 )
+			};
+
+		public static ImageTypeInfo Get( ImageType image )
+		{
+			int index = (int)image;
+			if ( index >= 0 && index < m_Table.Length )
+				return m_Table[index];
+			else
+				return m_Table[0];
+		}
+
+		public static ImageType[] RandomList( int count )
+		{
+			ArrayList list = new ArrayList( m_Table.Length );
+			for ( int i = 0; i < m_Table.Length; i++ )
+				list.Add( (ImageType)i );
+
+			ImageType[] images = new ImageType[count];
+
+			for ( int i = 0; i < images.Length; i++ )
+			{
+				int index = Utility.Random( list.Count );
+				images[i] = (ImageType)list[index];
+
+				list.RemoveAt( index );
+			}
+
+			return images;
+		}
+
+		private int m_Figurine;
+		private Type m_Type;
+		private int m_X;
+		private int m_Y;
+
+		public int Figurine { get { return m_Figurine; } }
+		public Type Type { get { return m_Type; } }
+		public int Name { get { return m_Figurine < 0x4000 ? 1020000 + m_Figurine : 1078872 + m_Figurine; } }
+		public int X { get { return m_X; } }
+		public int Y { get { return m_Y; } }
+
+		public ImageTypeInfo( int figurine, Type type, int x, int y )
+		{
+			m_Figurine = figurine;
+			m_Type = type;
+			m_X = x;
+			m_Y = y;
+		}
+	}
+}

Scripts/Engines/Quests/Collector/Items/Obsidian.cs

@@ -0,0 +1,264 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Network;
+using Server.Targeting;
+using Server.ContextMenus;
+
+namespace Server.Engines.Quests.Collector
+{
+	public class Obsidian : Item
+	{
+		private static readonly string[] m_Names = new string[]
+			{
+				null,
+				"an aggressive cavalier",
+				"a beguiling rogue",
+				"a benevolent physician",
+				"a brilliant artisan",
+				"a capricious adventurer",
+				"a clever beggar",
+				"a convincing charlatan",
+				"a creative inventor",
+				"a creative tinker",
+				"a cunning knave",
+				"a dauntless explorer",
+				"a despicable ruffian",
+				"an earnest malcontent",
+				"an exultant animal tamer",
+				"a famed adventurer",
+				"a fanatical crusader",
+				"a fastidious clerk",
+				"a fearless hunter",
+				"a festive harlequin",
+				"a fidgety assassin",
+				"a fierce soldier",
+				"a fierce warrior",
+				"a frugal magnate",
+				"a glib pundit",
+				"a gnomic shaman",
+				"a graceful noblewoman",
+				"a idiotic madman",
+				"a imaginative designer",
+				"an inept conjurer",
+				"an innovative architect",
+				"an inventive blacksmith",
+				"a judicious mayor",
+				"a masterful chef",
+				"a masterful woodworker",
+				"a melancholy clown",
+				"a melodic bard",
+				"a merciful guard",
+				"a mirthful jester",
+				"a nervous surgeon",
+				"a peaceful scholar",
+				"a prolific gardener",
+				"a quixotic knight",
+				"a regal aristocrat",
+				"a resourceful smith",
+				"a reticent alchemist",
+				"a sanctified priest",
+				"a scheming patrician",
+				"a shrewd mage",
+				"a singing minstrel",
+				"a skilled tailor",
+				"a squeamish assassin",
+				"a stoic swordsman",
+				"a studious scribe",
+				"a thought provoking writer",
+				"a treacherous scoundrel",
+				"a troubled poet",
+				"an unflappable wizard",
+				"a valiant warrior",
+				"a wayward fool"
+			};
+
+		public static string RandomName( Mobile from )
+		{
+			int index = Utility.Random( m_Names.Length );
+			if ( m_Names[index] == null )
+				return from.Name;
+			else
+				return m_Names[index];
+		}
+
+		private const int m_Partial = 2;
+		private const int m_Completed = 10;
+
+		private int m_Quantity;
+		private string m_StatueName;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int Quantity
+		{
+			get { return m_Quantity; }
+			set
+			{
+				if ( value <= 1 )
+					m_Quantity = 1;
+				else if ( value >= m_Completed )
+					m_Quantity = m_Completed;
+				else
+					m_Quantity = value;
+
+				if ( m_Quantity < m_Partial )
+					ItemID = 0x1EA7;
+				else if ( m_Quantity < m_Completed )
+					ItemID = 0x1F13;
+				else
+					ItemID = 0x12CB;
+
+				InvalidateProperties();
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public string StatueName
+		{
+			get { return m_StatueName; }
+			set { m_StatueName = value; InvalidateProperties(); }
+		}
+
+		public override bool ForceShowProperties { get { return ObjectPropertyList.Enabled; } }
+
+		[Constructable]
+		public Obsidian() : base( 0x1EA7 )
+		{
+			Hue = 0x497;
+
+			m_Quantity = 1;
+			m_StatueName = "";
+		}
+
+		public override void AddNameProperty( ObjectPropertyList list )
+		{
+			if ( m_Quantity < m_Partial )
+				list.Add( 1055137 ); // a section of an obsidian statue
+			else if ( m_Quantity < m_Completed )
+				list.Add( 1055138 ); // a partially reconstructed obsidian statue
+			else
+				list.Add( 1055139, m_StatueName ); // an obsidian statue of ~1_STATUE_NAME~
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			if ( m_Quantity < m_Partial )
+				LabelTo( from, 1055137 ); // a section of an obsidian statue
+			else if ( m_Quantity < m_Completed )
+				LabelTo( from, 1055138 ); // a partially reconstructed obsidian statue
+			else
+				LabelTo( from, 1055139, m_StatueName ); // an obsidian statue of ~1_STATUE_NAME~
+		}
+
+		public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
+		{
+			base.GetContextMenuEntries( from, list );
+
+			if ( from.Alive && m_Quantity >= m_Partial && m_Quantity < m_Completed && IsChildOf( from.Backpack ) )
+				list.Add( new DisassembleEntry( this ) );
+		}
+
+		private class DisassembleEntry : ContextMenuEntry
+		{
+			private Obsidian m_Obsidian;
+
+			public DisassembleEntry( Obsidian obsidian ) : base( 6142 )
+			{
+				m_Obsidian = obsidian;
+			}
+
+			public override void OnClick()
+			{
+				Mobile from = Owner.From;
+				if ( !m_Obsidian.Deleted && m_Obsidian.Quantity >= Obsidian.m_Partial && m_Obsidian.Quantity < Obsidian.m_Completed && m_Obsidian.IsChildOf( from.Backpack ) && from.CheckAlive() )
+				{
+					for ( int i = 0; i < m_Obsidian.Quantity - 1; i++ )
+						from.AddToBackpack( new Obsidian() );
+
+					m_Obsidian.Quantity = 1;
+				}
+			}
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( m_Quantity < m_Completed )
+			{
+				if ( !IsChildOf( from.Backpack ) )
+					from.Send( new MessageLocalized( Serial, ItemID, MessageType.Regular, 0x2C, 3, 500309, "", "" ) ); // Nothing Happens.
+				else
+					from.Target = new InternalTarget( this );
+			}
+		}
+
+		private class InternalTarget : Target
+		{
+			private Obsidian m_Obsidian;
+
+			public InternalTarget( Obsidian obsidian ) : base( -1, false, TargetFlags.None )
+			{
+				m_Obsidian = obsidian;
+			}
+
+			protected override void OnTarget( Mobile from, object targeted )
+			{
+				Item targ = targeted as Item;
+				if ( m_Obsidian.Deleted || m_Obsidian.Quantity >= Obsidian.m_Completed || targ == null )
+					return;
+
+				if ( m_Obsidian.IsChildOf( from.Backpack ) && targ.IsChildOf( from.Backpack ) && targ is Obsidian && targ != m_Obsidian )
+				{
+					Obsidian targObsidian = (Obsidian)targ;
+					if ( targObsidian.Quantity < Obsidian.m_Completed )
+					{
+						if ( targObsidian.Quantity + m_Obsidian.Quantity <= Obsidian.m_Completed )
+						{
+							targObsidian.Quantity += m_Obsidian.Quantity;
+							m_Obsidian.Delete();
+						}
+						else
+						{
+							int delta = Obsidian.m_Completed - targObsidian.Quantity;
+							targObsidian.Quantity += delta;
+							m_Obsidian.Quantity -= delta;
+						}
+
+						if ( targObsidian.Quantity >= Obsidian.m_Completed )
+							targObsidian.StatueName = Obsidian.RandomName( from );
+
+						from.Send( new AsciiMessage( targObsidian.Serial, targObsidian.ItemID, MessageType.Regular, 0x59, 3, m_Obsidian.Name, "Something Happened." ) );
+
+						return;
+					}
+				}
+
+				from.Send( new MessageLocalized( m_Obsidian.Serial, m_Obsidian.ItemID, MessageType.Regular, 0x2C, 3, 500309, m_Obsidian.Name, "" ) ); // Nothing Happens.
+			}
+		}
+
+		public Obsidian( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.WriteEncodedInt( m_Quantity );
+			writer.Write( (string) m_StatueName );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			m_Quantity = reader.ReadEncodedInt();
+			m_StatueName = Utility.Intern( reader.ReadString() );
+		}
+	}
+}

Scripts/Engines/Quests/Collector/Items/PaintedImage.cs

@@ -0,0 +1,86 @@
+using System;
+using Server;
+using Server.Gumps;
+using Server.Network;
+
+namespace Server.Engines.Quests.Collector
+{
+	public class PaintedImage : Item
+	{
+		private ImageType m_Image;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public ImageType Image
+		{
+			get { return m_Image; }
+			set { m_Image = value; InvalidateProperties(); } 
+		}
+
+		[Constructable]
+		public PaintedImage( ImageType image ) : base( 0xFF3 )
+		{
+			Weight = 1.0;
+			Hue = 0x8FD;
+
+			m_Image = image;
+		}
+
+		public override void AddNameProperty( ObjectPropertyList list )
+		{
+			ImageTypeInfo info = ImageTypeInfo.Get( m_Image );
+			list.Add( 1060847, "#1055126\t#" + info.Name ); // a painted image of:
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			ImageTypeInfo info = ImageTypeInfo.Get( m_Image );
+			LabelTo( from, 1060847, "#1055126\t#" + info.Name ); // a painted image of:
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !from.InRange( GetWorldLocation(), 2 ) )
+			{
+				from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
+				return;
+			}
+
+			from.SendGump( new InternalGump( m_Image ) );
+		}
+
+		private class InternalGump : Gump
+		{
+			public InternalGump( ImageType image ) : base( 75, 25 )
+			{
+				ImageTypeInfo info = ImageTypeInfo.Get( image );
+
+				AddBackground( 45, 20, 100, 100, 0xA3C );
+				AddBackground( 52, 29, 86, 82, 0xBB8 );
+
+				AddItem( info.X, info.Y, info.Figurine );
+			}
+		}
+
+		public PaintedImage( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.WriteEncodedInt( (int) m_Image );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			m_Image = (ImageType) reader.ReadEncodedInt();
+		}
+	}
+}