public partial class Tutorial : Form
	{
->		private const int TileSize = 16;
->		Bitmap TilesetBackbuffer, MapBackbuffer;
->		Graphics TilesetGraphics, MapGraphics;

		public Tutorial()
		{
			InitializeComponent();
->			TilesetBackbuffer = new Bitmap("tileset.png");
->			TilesetGraphics = Graphics.FromImage(TilesetBackbuffer);
->			tilesetPictureBox.Image = TilesetBackbuffer;
		}

		Graphics TilesetGraphics, MapGraphics;
->		int CurrentTile;

		private void tilesetPictureBox_MouseClick(object sender, MouseEventArgs e)
		{
			// Note: eight tiles per row in the tileset.
			CurrentTile = ((e.Y / TileSize) * 8) + (e.X / TileSize);
			this.Text = "CurrentTile: " + CurrentTile.ToString();
		}

		int CurrentTile;
->		int[,] Map;
->		int MapWidth, MapHeight;

			tilesetPictureBox.Image = TilesetBackbuffer;
->			MapWidth = 10;
->			MapHeight = 10;
->			Map = new int[MapWidth, MapHeight];
->			MapBackbuffer = new Bitmap(MapWidth * TileSize, MapHeight * TileSize);
->			MapGraphics = Graphics.FromImage(MapBackbuffer);
->			mapPictureBox.Image = MapBackbuffer;

		private void DrawTile(int x, int y, int tileNo)
		{
			Rectangle sourceRect = new Rectangle((tileNo % 8) * TileSize, (tileNo / 8) * TileSize, TileSize, TileSize);
			Rectangle destRect = new Rectangle(x * TileSize, y * TileSize, TileSize, TileSize);
			MapGraphics.DrawImage(TilesetBackbuffer, destRect, sourceRect, GraphicsUnit.Pixel);
		}

		private void DrawFullMap()
		{
			for (int x = 0; x < MapWidth; x++)
				for (int y = 0; y < MapHeight; y++)
					DrawTile(x, y, Map[x, y]);
		}

			mapPictureBox.Image = MapBackbuffer;
->			DrawFullMap();

		private void mapPictureBox_MouseMove(object sender, MouseEventArgs e)
		{
			int x = e.X / TileSize;
			int y = e.Y / TileSize;

			if (x < 0 || x >= MapWidth || y < 0 || y >= MapHeight)
				return;

			if (e.Button == MouseButtons.Left)
			{
				Map[x, y] = CurrentTile;
				DrawTile(x, y, CurrentTile);
				mapPictureBox.Refresh();
			}
		}

	//One single change of the map
	class TileChange
	{
		public int X { get; set; }
		public int Y { get; set; }
		public int From { get; set; }
		public int To { get; set; }
		public TileChange(int x, int y, int from, int to)
		{
			X = x;
			Y = y;
			From = from;
			To = to;
		}
	}

	//One "brush stroke" worth of edits, from mousedown to mouseup.
	class UndoState
	{
		public Bitmap Before { get; set; }
		public Bitmap After { get; set; }
		public List<TileChange> Changes { get; set; }
		public UndoState()
		{
			Changes = new List<TileChange>();
		}

	Stack<UndoState> UndoBuffer = new Stack<UndoState>();
	Stack<UndoState> RedoBuffer = new Stack<UndoState>();

		public void StartUndo()
		{
			RedoBuffer.Clear();
			NewUndo = new UndoState();
			NewUndo.Before = (Bitmap)MapBackbuffer.Clone();
		}

		public void AddTileUndo(int x, int y, int from, int to)
		{
			NewUndo.Changes.Add(new TileChange(x, y, from, to));
		}

		public void CommitUndo()
		{
			NewUndo.After = (Bitmap)MapBackBuffer.Clone();
			UndoBuffer.Push(NewUndo);
		}

		public void Undo()
		{
			if (UndoBuffer.Count == 0)
				return;
			UndoState ThisUndo = UndoBuffer.Pop();
			ApplyUndo(ThisUndo, false);
			RedoBuffer.Push(ThisUndo);
			mapPictureBox.Refresh();
		}

		private void ApplyUndo(UndoState buffer, bool redo)
		{
			MapGraphics.DrawImageUnscaled(redo ? buffer.After : buffer.Before, 0, 0);
			foreach (TileChange c in buffer.Changes)
			{
				int x = c.X;
				int y = c.Y;
				int tile = redo ? c.To : c.From;
				if (x < 0 || x >= MapWidth || y < 0 || y >= MapHeight)
					continue;
				Map[x, y] = tile;
			}
		}

			if (openFileDialog.ShowDialog() == DialogResult.OK)
			{
				BinaryReader mapFile = new BinaryReader(File.Open(openFileDialog.FileName, FileMode.Open));

				//Using ints for all this stuff makes all the values 32 bits.
				MapWidth = mapFile.ReadInt32();
				MapHeight = mapFile.ReadInt32();
				Map = new int[MapWidth, MapHeight];

				//We use a 2D array of something that's not bytes, so we have to take the long way home.
				for (int x = 0; x < MapWidth; x++)
					for (int y = 0; y < MapHeight; y++)
						Map[x, y] = mapFile.ReadInt32();

				MakeBackbuffers();
			}

		private void MakeBackbuffers()
		{
			MapBackbuffer = new Bitmap(MapWidth * TileWidth, MapHeight * TileHeight);
			MapGraphics = Graphics.FromImage(MapBackbuffer);
			mapPictureBox.Image = MapBackbuffer;
			DrawFullMap();
		}

			int srcX, srcY, dstX, dstY;
			for (int y = 0; y < mapHeight; y++)
			{
				dstY = y * 16;
				for (int x = 0; x < mapWidth; x++)
				{
					ushort rt = br.ReadUInt16();
					ushort tile = (ushort)(rt & 0x3FF);
					srcX = (tile % 8) * 16;
					srcY = (tile / 8) * 16;
					dstX = x * 16;
					for (int px = 0; px < 16; px++)
						for (int py = 0; py < 16; py++)
							mapBackBuffer.SetPixel(dstX + px, dstY + py, TilesetBackbuffer.GetPixel(srcX + px, srcY + py));
				}
			}