Bill Reiss posted an interesting article and code the other day concerning the WriteableBitmap class and some extension methods. I downloaded the code and wrote a tiling map control using the WriteableBitmap class for my multi-player role playing game. Here is a snippet of the important piece of code that does the rendering:

   1:  private void RenderMap()

   2:  {

   3:      var xPos = _center.X - _halfX;

   4:      var yPos = _center.Y - _halfY;

   5:   

   6:      for (int y = 0; y < _numTilesY; y++)

   7:      {

   8:          for (int x = 0; x < _numTilesX; x++)

   9:          {

  10:              var tile = _tiles[new Point3(xPos, yPos, _zIndex)];

  11:              var terrain = Game.Terrain.Where(t => t.ID == tile.Terrain).FirstOrDefault();

  12:              if (terrain == null)

  13:                  terrain = Game.GetDefaultTerrain();

  14:   

  15:              _surface.Blit(new Point(x * TileWidth, y * TileHeight), 

  16:                  _tileImage, 

  17:                  _tileRect, 

  18:                  terrain.GetColor(), 

  19:                  BlendMode.AlphaBlend);

  20:              xPos++;

  21:          }

  22:          xPos = _center.X - _halfX;

  23:          yPos++;

  24:      }

  25:   

  26:      _surface.Invalidate();

  27:  }

The _surface variable is just a WriteableBitmap instance initialized to the width and height of the map control. The _tiles variable holds a list of the map tiles in range of the _center position. The xPos and yPos are the world coordinates and the terrain instance just holds the color to paint the tile.

The end result looks something like this:

I thought I would share one of the core concepts I implemented in Perenthia that has been working quite well. Early on in development I decided to create templates and instances in regards to game objects. A template would define common, unchangable properties of an object whereas an instance would be the opposite. An example would be a Sword; there is a template for a Sword that defines its damage value, price, required skill level, etc. 

I have one table that stores all the objects for the game. Since objects being actively used are loaded into memory and the table is indexed for those queries it runs pretty fast. Since I store all of the objects into one table I make heavy use of the XML data type in SQL 2005 to provide a bunch of XML Serialized Key/Value pairs that define the properties of an object. On the code side of things a dictionary provides the underlying data store for properties of the object. For instance, the Sword example above has a Power property that is used in combination with the wielder's skill in swords to determine damage. The Power property just fetches the Power value from the properties dictionary using the property name. This works a lot like the dependency properties, just my collection serializes to XML for database storage. When an object is loaded from the database the xml from the template is retrieved and added to the object, then the object instance xml is dropped into the object, overriding any template properties of the same name.

This property dictionary also allows me to store whether or not the property belongs to a template or instance. If the property belongs to a template then when the instance is serialized and saved to the database those template properties are excluded. Likewise saving a template does not serialize and save the instance properties. This structure allows for a lot of flexibility with my objects and has been working out quite well. I probably would not have used serialization and xml the way I am if I was doing a typical call to the database qith each request as the extra overhead would not have been worth the effort. However, since my objects are loaded into memory and my saves are background threaded I experience a lot of benefit of an easy to use object.

I shuld note that players character data is stored in a separate table from the core objects table. It follows the same design buy allows me to migrate and change data in the objects table without overwriting player data, since players are essentially the same as mobiles. 

I have been working to modify the tool I wrote for building the Perenthia world. The tool started life as a WinForms application, migrated to a WPF application but is now a part of the Silverlight Client UI. Since all of the actions are role based and controlled with permission on the server having it in the main client UI allows me to make use of all of the framework already in place for Perenthia.

The world builder UI connects to the server via WCF services tailored for world building. What this will also give me is the ability to open up the world builder to allow users to create custom dungeons, towns, etc.

Some features of the world builder are a background map of the world so I know where to place rooms, zoom capabilities that scale the map, draggable map and the ability to drag items, creatures, NPCs, etc. onto rooms on the map and configure the properties of each.

Here is a draggable Window control I wrote in Silverlight for Perenthia. A screen shot of the Window being used can be seen at http://cameronalbert.com/post/2008/11/19/Silverlight-Game-Controls.aspx

Here is the XAML from my generics.xaml file:

<!-- Default style for Lionsguard.Window -->
	<Style TargetType="lg:Window">
		<Setter Property="Background" Value="#99000000" />
		<Setter Property="Foreground" Value="#FFFFFFFF" />
		<Setter Property="BorderBrush" Value="#FFC38312" />
		<Setter Property="Template">
			<Setter.Value>
				<ControlTemplate TargetType="lg:Window">
					<Grid x:Name="RootElement">
						<Border HorizontalAlignment="Stretch" Margin="0,24,0,0" Padding="4,4,4,4" VerticalAlignment="Stretch" BorderThickness="2,2,2,2" CornerRadius="0,0,4,4">
							<ContentControl x:Name="ContentElement" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch"/>
						</Border>
						<Border Height="24" HorizontalAlignment="Stretch" Margin="0,0,0,0" VerticalAlignment="Top" CornerRadius="4,4,0,0" BorderThickness="2,2,2,0" x:Name="TitleBarElement" />
						<Button Height="20" HorizontalAlignment="Right" Margin="0,3,3,0" VerticalAlignment="Top" Width="20" Content="X" FontWeight="Bold" FontFamily="Trebuchet MS" FontSize="14" x:Name="CloseButtonElement"/>
						<TextBlock Height="20" Margin="8,3,27,0" VerticalAlignment="Top" Text="Title" TextWrapping="Wrap" x:Name="TitleLabelElement" FontFamily="Georgia" FontSize="16" FontWeight="Bold" HorizontalAlignment="Left"/>
					</Grid>
				</ControlTemplate>
			</Setter.Value>
		</Setter>
	</Style>

And here is the code for the class:

using System;

using System.Collections.Generic;

using System.Net;

using System.Linq;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Markup;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

namespace Lionsguard

{

	[TemplatePart(Name = "RootElement", Type = typeof(FrameworkElement))]

	[TemplatePart(Name = "ContentElement", Type = typeof(ContentControl))]

	[TemplatePart(Name = "TitleBarElement", Type = typeof(Border))]

	[TemplatePart(Name = "CloseButtonElement", Type = typeof(Button))]

	[TemplatePart(Name = "TitleLabelElement", Type = typeof(TextBlock))]

	[ContentProperty("Content")]

	public class Window : Control

	{

		public FrameworkElement RootElement { get; set; }

		private ContentControl ContentElement { get; set; }

		private Border TitleBarElement { get; set; }

		private Button CloseButtonElement { get; set; }

		private TextBlock TitleLabelElement { get; set; }

		private Point MousePosition { get; set; }

		/// <summary>

		/// Gets or sets the Content of the Window.

		/// </summary>

		public UIElement Content

		{

			get { return (UIElement)GetValue(ContentProperty); }

			set { SetValue(ContentProperty, value); }

		}

		public static readonly DependencyProperty ContentProperty = DependencyProperty.Register("Content", typeof(UIElement), typeof(Window), new PropertyMetadata(null, new PropertyChangedCallback(Window.OnContentPropertyChanged)));

		private static void OnContentPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)

		{

			(obj as Window).SetControlValues();

		}

		/// <summary>

		/// Gets or sets the Title displayed in the title bar of the window.

		/// </summary>

		public string Title

		{

			get { return (string)GetValue(TitleProperty); }

			set { SetValue(TitleProperty, value); }

		}

		public static readonly DependencyProperty TitleProperty = DependencyProperty.Register("Title", typeof(string), typeof(Window), new PropertyMetadata("Title", new PropertyChangedCallback(Window.OnTitlePropertyChanged)));

		private static void OnTitlePropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)

		{

			(obj as Window).SetControlValues();

		}

		/// <summary>

		/// Gets or sets a value indicating whether or not the close button of the title bar should be displayed.

		/// </summary>

		public bool ShowCloseButton

		{

			get { return (bool)GetValue(ShowCloseButtonProperty); }

			set { SetValue(ShowCloseButtonProperty, value); }	

		}

		public static readonly DependencyProperty ShowCloseButtonProperty = DependencyProperty.Register("ShowCloseButton", typeof(bool), typeof(Window), new PropertyMetadata(true, new PropertyChangedCallback(Window.OnShowCloseButtonPropertyChanged)));

		private static void OnShowCloseButtonPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)

		{

			(obj as Window).SetControlValues();

		}

		/// <summary>

		/// Gets a value indicating whether or not the window is currently open and visible.

		/// </summary>

		public bool IsOpen

		{

			get { return this.Visibility == Visibility.Visible; }

		}

		/// <summary>

		/// An event that is raised when the window is closed.

		/// </summary>

		public event EventHandler Closed = delegate { };

		/// <summary>

		/// Initializes a new instance of the Lionsguard.Window class.

		/// </summary>

		public Window()

		{

			this.DefaultStyleKey = typeof(Window);

		}

		public override void OnApplyTemplate()

		{

			base.OnApplyTemplate();

			this.RootElement = base.GetTemplateChild("RootElement") as FrameworkElement;

			this.ContentElement = base.GetTemplateChild("ContentElement") as ContentControl;

			this.TitleBarElement = base.GetTemplateChild("TitleBarElement") as Border;

			this.CloseButtonElement = base.GetTemplateChild("CloseButtonElement") as Button;

			this.TitleLabelElement = base.GetTemplateChild("TitleLabelElement") as TextBlock;

			if (this.RootElement != null)

			{

				this.RootElement.MouseLeftButtonDown += new MouseButtonEventHandler(OnRootElementMouseLeftButtonDown);

				this.TitleBarElement.MouseLeftButtonDown += new MouseButtonEventHandler(OnTitleBarMouseLeftButtonDown);

				this.TitleBarElement.MouseEnter += new MouseEventHandler(OnTitleBarMouseEnter);

				this.TitleBarElement.MouseLeave += new MouseEventHandler(OnTitleBarMouseLeave);

				this.TitleLabelElement.MouseLeftButtonDown += new MouseButtonEventHandler(OnTitleBarMouseLeftButtonDown);

				this.TitleLabelElement.MouseEnter += new MouseEventHandler(OnTitleBarMouseEnter);

				this.TitleLabelElement.MouseLeave += new MouseEventHandler(OnTitleBarMouseLeave);

				this.CloseButtonElement.Click += new RoutedEventHandler(OnCloseButtonClick);

				this.SetControlValues();

			}

		}

		private void SetControlValues()

		{

			if (this.ContentElement != null && this.Content != null)

			{

				this.ContentElement.Content = this.Content;

			}

			if (this.TitleLabelElement != null)

			{

				this.TitleLabelElement.Text = this.Title;

				ToolTipService.SetToolTip(this.TitleLabelElement, this.Title);

			}

			if (this.CloseButtonElement != null)

			{

				if (this.ShowCloseButton) this.CloseButtonElement.Visibility = Visibility.Visible;

				else this.CloseButtonElement.Visibility = Visibility.Collapsed;

			}

		}

		private void OnRootElementMouseLeftButtonDown(object sender, MouseButtonEventArgs e)

		{

			// Set the Z-Index of the window to the top most position.

			this.BringToFront();

		}

		private void OnCloseButtonClick(object sender, RoutedEventArgs e)

		{

			this.Close();

		}

		private void OnTitleBarMouseLeave(object sender, MouseEventArgs e)

		{

			this.Cursor = Cursors.Arrow;

		}

		private void OnTitleBarMouseEnter(object sender, MouseEventArgs e)

		{

			this.Cursor = Cursors.Hand;

		}

		private void OnTitleBarMouseMove(object sender, MouseEventArgs e)

		{

			Point position = e.GetPosition(null);

			// Prevent the mouse from moving outside the bounds of the parent canvas.

			if (position.X <= 30) position.X = 30;

			if (position.Y <= 30) position.Y = 30;

			Canvas parent = this.Parent as Canvas;

			if (parent != null)

			{

				if (position.X >= (parent.Width - 30)) position.X = parent.Width - 30;

				if (position.Y >= (parent.Height - 30)) position.Y = parent.Height - 30;

			}

			System.Diagnostics.Debug.WriteLine("position = {0}", position);

			double deltaX = position.X - this.MousePosition.X;

			double deltaY = position.Y - this.MousePosition.Y;

			Point newPosition = new Point(

				((double)this.GetValue(Canvas.LeftProperty)) + deltaX,

				((double)this.GetValue(Canvas.TopProperty)) + deltaY);

			this.SetValue(Canvas.LeftProperty, newPosition.X);

			this.SetValue(Canvas.TopProperty, newPosition.Y);

			this.MousePosition = position;

		}

		private void OnTitleBarMouseLeftButtonUp(object sender, MouseButtonEventArgs e)

		{

			((UIElement)sender).ReleaseMouseCapture();

			this.Cursor = Cursors.Arrow;

			this.TitleBarElement.MouseLeftButtonUp -= new MouseButtonEventHandler(OnTitleBarMouseLeftButtonUp);

			this.TitleBarElement.MouseMove -= new MouseEventHandler(OnTitleBarMouseMove);

			this.TitleLabelElement.MouseLeftButtonUp -= new MouseButtonEventHandler(OnTitleBarMouseLeftButtonUp);

			this.TitleLabelElement.MouseMove -= new MouseEventHandler(OnTitleBarMouseMove);

		}

		private void OnTitleBarMouseLeftButtonDown(object sender, MouseButtonEventArgs e)

		{

			this.MousePosition = e.GetPosition(null);

			this.Cursor = Cursors.Hand;

			((UIElement)sender).CaptureMouse();

			this.TitleBarElement.MouseLeftButtonUp += new MouseButtonEventHandler(OnTitleBarMouseLeftButtonUp);

			this.TitleBarElement.MouseMove += new MouseEventHandler(OnTitleBarMouseMove);

			this.TitleLabelElement.MouseLeftButtonUp += new MouseButtonEventHandler(OnTitleBarMouseLeftButtonUp);

			this.TitleLabelElement.MouseMove += new MouseEventHandler(OnTitleBarMouseMove);

		}

		/// <summary>

		/// Causes the current window to be re-z-indexed to the top most window.

		/// </summary>

		protected void BringToFront()

		{

			// Search the top most "Window" and swap z-indexes.

			Panel parent = this.Parent as Panel; // Panel is the base for Canvas, Grid and StackPanel.

			if (parent != null)

			{

				int currentZIndex = (int)this.GetValue(Canvas.ZIndexProperty);

				var child = (from c in parent.Children where c is Window select c as Window).OrderByDescending(c => (int)c.GetValue(Canvas.ZIndexProperty)).FirstOrDefault();

				if (child != null)

				{

					int topZIndex = (int)child.GetValue(Canvas.ZIndexProperty);

					if (topZIndex == 0) topZIndex = 1; // If the value has not been set then just default it to 1.

					if (topZIndex > currentZIndex)

					{

						this.SetValue(Canvas.ZIndexProperty, topZIndex);

						child.SetValue(Canvas.ZIndexProperty, currentZIndex);

					}

				}

			}

		}

		public void Show()

		{

			this.Visibility = Visibility.Visible;

			// If content is present show that as well.

			if (this.Content != null) this.Content.Visibility = Visibility.Visible;

		}

		public void Close()

		{

			this.Visibility = Visibility.Collapsed;

			// If content is present hide that as well.

			if (this.Content != null) this.Content.Visibility = Visibility.Collapsed;

			this.Closed(this, EventArgs.Empty);

		}

		public void ToggleWindow()

		{

			if (this.Visibility == Visibility.Visible)

			{

				this.Close();

			}

			else

			{

				this.Show();

			}

		}

	}

}

This is how I am using it within the Pernethia UI (The content of window is actually the Character Sheet as displayed in the screenshot from above):

Namespace: xmlns:Lionsguard="clr-namespace:Lionsguard;assembly=Lionsguard.Silverlight"

<Lionsguard:Window Height="375" x:Name="diagCharacterSheet" Visibility="Collapsed" Width="634" Canvas.Left="8" Canvas.Top="19" Title="Character Sheet" Style="{StaticResource WindowStyle}" d:IsLocked="True">
    		<Perenthia_Dialogs:CharacterSheetDialog x:Name="diagCharacterSheetContent" SkillChanged="diagCharacterSheetContent_SkillChanged"/>
		</Lionsguard:Window>

Enjoy!

I have been porting out the multi-player aspects of Perenthia into a separate library I hope to get up on CodePlex before too long. What the library will provide is some interfaces and classes related to handling multi-player environments. A central static class will manage connected clients and three protocol classes for HTTP, Polling Duplex and Sockets will use the static class to retrieve connected clients and push information down to them. A simple set of "tags" are used to send information back and forth and some providers allow for defining your own implementation of handling commands and encrypting data.

The library will be focused on providing an easy way to get setup and implement a multi-player structure. You will still need our own game engine and associated components.

As soon as I get it cleaned up a little and tested out I will put it up on CodePlex and provide a tutorial and sample application showing how to implement and use the component.

I am hoping to start writing some articles about building multi-player games in Silverlight. I am planning on charting my development progress and ideas in my design and development of Perenthia.

Silverlight is a great platform for .NET developers to be able to write multi-player browser based games. You get a great tool for building a UI, animations, sounds, etc. and can program everything in your .NET language of choice. Silverlight 3 is supposed to support 3D so that will open it up even more for some great games.

Over the next few months, in between working on Perenthia, I am going to work on the first of a series of articles outlining how I built Perenthia. I will start with the Server component, outlining the core communication architecture and design decisions.

Keep checking back for more information.

I uploaded the Perenthia Armorial Version 1.0 to the Perenthia Alpha site tonight. The Perenthia Armorial is a way to provide external access to Perenthia information. The first version includes the Player Bar feature, where you pass a player name to the service and renders back HTML with player details.

The call to http://alpha.perenthia.com/Armorial/Armorial.ashx?n=Aldarian renders the following:

I did a Character Creation, Movement and Chat test last night with the Perenthia Alpha players. The tests went well, I chatted with a few players, found some bugs and was very encouraged by the whole thing. The next test should start next weekend and will include some combat/spell tests. After that we will do some questing tests, travel tests (boats and stuff) and then I will open up more of the world for the alpha players to help resolve other issues not covered by the main feature tests.

I am enjoying Silverlight as the client UI, it provides a Windows like interface with ability to be run in a browser.

While developing Perenthia I tried several different communication formats from sending JSON serialized objects back and forth to sending byte arrays containing mostly integers indicating what should be loaded and displayed, what commands to execute etc. What I eventually settled on was a bit of a hybrid. I've created a simple set of "tags" that can be sent to and from the server. The tags are nothing more than pipe delimited strings contained within curly braces and there are a limited number of tags that provide simplicity yet flexibility with the data that is transmitted. The tags are represented in C# by tag objects allow me to create them, query them, etc.

A simple command tag for the SAY command might look like this: {CMD|SAY|"Hello World!"}

I wrote a custom tag writer class that parses the tag objects into strings to be sent to the client and likewise a tag reader that reads the strings sent from the client and parses them into tag objects.

The client can only send commands to the server but the server sends commands, messages and objects to the client. The commands are all the same, the CMD text then the one word name of the command and then a list of arguments, messages are system, chat and tell messages but objects have a bit more information. For instance, an object tag encompasses several different types starting with a base ACTOR, a PLACE, a PLAYER and a PROP or property. The ACTOR, PLACE and PLAYER tags all define the ID, Name and Descriptions of the objects, with some additional data per type but the PROP tag defines the object id of its owner and a name/value pair. An example of a PLAYER tag with properties for x, y and z coordinates might be:

{OBJ|PLAYER|3756|"Aldarian"|"My character description..."}

{OBJ|PROP|3756|"X"|45}

{OBJ|PROP|3756|"Y"|26}

{OBJ|PROP|3756|"Z"|0}

The client can find and parse the player tag and then find the properties associated with that player instance. The way the server works now it will send the full player tag once logged in and a character is selected and then from then on out it just sends property updates.

Using this type of tag structure allows quite a bit of flexibility for the client. I could choose to write a very simple client that only displays MSG tags, much like a MUD, I could write a simple 2D interface client and display and move sprites about the map using the properties from the server, etc. Once Perenthia is up and running I will probably post some information on the tags and how to talk with the server should someone feel the need to write their own client. :)

For those waiting, Perenthia is almost ready for alpha. I have a few more things to complete and then the first phase of the Alpha will be ready. Hopefully you have had time to look over the various races, attributes and skills on the Perenthia web site and will be ready to create a character and begin your journey.

Here is a list of the remaining tasks I need to complete before Alpha, this does not include testing and fixing bugs with these features, just implementing them:

• Spellcasting (Basic framework is in place, just need to define some spells and test them out)
• Monster drops, including currency, gold, silver, etc. (They don't drop anything right now, stingy)
• Help (Just need the framework in place as the help will get compiled during the alpha)
• Quests (May not finish these for the first phase of alpha, want to try and keep it simple to start)
• Some UI cleanup (got some windows not responding to updates from the server)
• Content (Need to finish adding monsters to the dungeon, just the one dungeon for alpha)

I thought I would include a couple of screen shots along with this update. The first is a shot of the map window of the world builder tool I wrote for managing the places and things within the Perenthia world. This is the shot of the Alpha testing area, a small village called "Delcor". This view is actually a windows forms application with a WPF (ElementHost) control for rendering the map. The little red dots are NPCs that I can actually drag around into other rooms on the map after I create them, makes for moving the monsters in the dungeon a lot easier. :)

This second shot is the game user interface showing the same map that I was working on in the screen shot above.