Writing a Multiplayer Game (in WPF)

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Media.Imaging;
using Pfz.Caching;
using Pfz.Drawing.Wpf;
using RemoteGameSample.Common;

namespace RemoteGameSample.Server
{
	public sealed class Map
	{
		private static readonly Map[] _maps;

		static Map()
		{
			var directories = Directory.GetDirectories("Data\\Maps");
			Array.Sort(directories);
			int count = directories.Length;
			_maps = new Map[count];
			Titles = new string[count];
			Names = new string[count];
			for(int i=0; i<count; i++)
			{
				string directory = directories[i]; 
				string name = Path.GetFileName(directory);
				var map = new Map(name);
				_maps[i] = map;
				Titles[i] = map.Title;
				Names[i] = name;
			}
		}
		public static int Count
		{
			get
			{
				return _maps.Length;
			}
		}
		public static Map Get(int index)
		{
			return _maps[index];
		}

		private Map(string name)
		{
			Name = name;

			var lines = File.ReadAllLines("Data\\Maps\\" + name + "\\info.txt");
			Angle = int.Parse(lines[0]);
			Title = lines[1];

			Information = new MapInfo(Name);
		}

		private readonly object _lock = new object();
		private readonly ThreadUnsafeReference<LockedBitmap> _lockedBitmapReference = new ThreadUnsafeReference<LockedBitmap>(null, GCHandleType.Weak);
		private LockedBitmap _LoadBitmapIfNeeded()
		{
			lock(_lock)
			{
				var result = _lockedBitmapReference.Value;
				if (result != null)
					return result;

				LockedBitmap lockedBitmap;

				using(var stream = File.OpenRead("Data\\Maps\\" + Name + "\\map.png"))
				{
					var decoder = new PngBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
					var frame = decoder.Frames[0];
					var managedBitmap = new ManagedBitmap(frame);
					lockedBitmap = managedBitmap.Lock();
					_lockedBitmapReference.Value = lockedBitmap;
				}

				_startPositions = new Point[4];

				int width = lockedBitmap.Width;
				int height = lockedBitmap.Height;
				for(int y=0; y<height; y++)
				{
					for(int x=0; x<width; x++)
					{
						var color = lockedBitmap[x, y];

						if (color == new Argb(0, 0, 255))
							_startPositions[0] = new Point(x, y);
						else
						if (color == new Argb(0, 255, 0))
							_startPositions[1] = new Point(x, y);
						else
						if (color == new Argb(255, 0, 0))
							_startPositions[2] = new Point(x, y);
						else
						if (color == new Argb(255, 255, 0))
							_startPositions[3] = new Point(x, y);
						else
						{
							if (color.Red < 10 && color.Blue < 10)
							{
								var green = color.Green;
								if (green % 10 == 0)
									_lastCheckpoint = Math.Max(green, _lastCheckpoint);
							}
						}
					}
				}

				GCUtils.KeepAlive(lockedBitmap);
				return lockedBitmap;
			}
		}

		public LockedBitmap Bitmap
		{
			get
			{
				return _LoadBitmapIfNeeded();
			}
		}

		private Point[] _startPositions;
		public Point[] StartPositions
		{
			get
			{
				_LoadBitmapIfNeeded();
				return _startPositions;
			}
		}

		private int _lastCheckpoint;
		public int LastCheckpoint
		{
			get
			{
				_LoadBitmapIfNeeded();
				return _lastCheckpoint;
			}
		}

		public int Angle { get; private set; }
		public string Name { get; private set; }
		public string Title { get; private set; }
		public MapInfo Information { get; private set; }

		public static string[] Titles { get; private set; }
		public static string[] Names { get; private set; }
	}
}