/*
 * Interpreter.cs - Callback and control functions of the Level 9 interpreter.
 *
 * Copyright (C) 2004 - 2011 Andreas Scherrer
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
 * USA.
 */

using System;
using System.Collections;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace Level9
{
	/// <summary>
	/// Callback and control functions of the Level 9 interpreter.
	/// </summary>
	public unsafe class Interpreter
	{
		// -- Constants ------------------------------------------------------

		/// <summary>
		/// The number of characters until os_flush() is called in dictionary
		/// output mode.
		/// </summary>
		const int DICTIONARY_FLUSH = 256;

		// -- Delegates ------------------------------------------------------

		/// <summary>
		/// Represents the method that handles calls to os_printchar().
		/// See <see cref="Interpreter.os_printchar"></see> for details.
		/// </summary>
		delegate void OS_PRINTCHAR(char c);

		/// <summary>
		/// Represents the method that handles calls to os_input().
		/// See <see cref="Interpreter.os_input"></see> for details.
		/// </summary>
		delegate bool OS_INPUT(byte *ibuff, int size);

		/// <summary>
		/// Represents the method that handles calls to os_readchar().
		/// See <see cref="Interpreter.os_readchar"></see> for details.
		/// </summary>
		delegate byte OS_READCHAR(int millis);

		/// <summary>
		/// Represents the method that handles calls to os_flush().
		/// See <see cref="Interpreter.os_flush"></see> for details.
		/// </summary>
		delegate void OS_FLUSH();

		/// <summary>
		/// Represents the method that handles calls to os_save_file().
		/// See <see cref="Interpreter.os_save_file"></see> for details.
		/// </summary>
		delegate bool OS_SAVE_FILE(byte *Ptr, int Bytes);

		/// <summary>
		/// Represents the method that handles calls to os_load_file().
		/// See <see cref="Interpreter.os_load_file"></see> for details.
		/// </summary>
		delegate bool OS_LOAD_FILE(byte *Ptr, int *Bytes, int Max);

		/// <summary>
		/// Represents the method that handles calls to os_get_game_file().
		/// See <see cref="Interpreter.os_get_game_file"></see> for details.
		/// </summary>
		delegate bool OS_GET_GAME_FILE(byte *NewName, int Size);

		/// <summary>
		/// Represents the method that handles calls to os_set_filenumber().
		/// See <see cref="Interpreter.os_set_filenumber"></see> for details.
		/// </summary>
		delegate void OS_SET_FILENUMBER(byte *NewName, int Size, int n);

		/// <summary>
		/// Represents the method that handles calls to os_graphics().
		/// See <see cref="Interpreter.os_graphics"></see> for details.
		/// </summary>
		delegate void OS_GRAPHICS(int mode);

		/// <summary>
		/// Represents the method that handles calls to os_cleargraphics().
		/// See <see cref="Interpreter.os_cleargraphics"></see> for details.
		/// </summary>
		delegate void OS_CLEARGRAPHICS();

		/// <summary>
		/// Represents the method that handles calls to os_setcolour().
		/// See <see cref="Interpreter.os_setcolour"></see> for details.
		/// </summary>
		delegate void OS_SETCOLOUR(int colour, int index);

		/// <summary>
		/// Represents the method that handles calls to os_fill().
		/// See <see cref="Interpreter.os_fill"></see> for details.
		/// </summary>
		delegate void OS_FILL(int x, int y, byte colour1, byte colour2);

		/// <summary>
		/// Represents the method that handles calls to os_show_bitmap().
		/// See <see cref="Interpreter.os_show_bitmap"></see> for details.
		/// </summary>
		delegate void OS_SHOW_BITMAP(int pic, int x, int y);

		/// <summary>
		/// Represents the method that handles calls to os_drawline().
		/// See <see cref="Interpreter.os_drawline"></see> for details.
		/// </summary>
		delegate void OS_DRAWLINE(int x1, int y1, int x2, int y2, byte colour1,
			byte colour2);

		// -- Imports --------------------------------------------------------

		/// <summary>
		/// Import declaration of the L9_LoadGame method.
		/// See <see cref="Interpreter.LoadGame"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern bool L9_LoadGame(string filename, string picname);

		/// <summary>
		/// Import declaration of the L9_RunGame method.
		/// See <see cref="Interpreter.RunGame"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern bool L9_RunGame();

		/// <summary>
		/// Import declaration of the L9_StopGame method.
		/// See <see cref="Interpreter.StopGame"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern void L9_StopGame();

		/// <summary>
		/// Import declaration of the L9_RestoreGame method.
		/// See <see cref="Interpreter.RestoreGame"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern void L9_RestoreGame(string inFile);

		/// <summary>
		/// Import declaration of the L9_FreeMemory method.
		/// See <see cref="Interpreter.FreeMemory"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern void L9_FreeMemory();

		/// <summary>
		/// Import declaration of the L9_GetPictureSize method.
		/// See <see cref="Interpreter.GetPictureSize"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern void L9_GetPictureSize(ref int width, ref int height);

		/// <summary>
		/// Import declaration of the L9_RunGraphics method.
		/// See <see cref="Interpreter.RunGraphics"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern bool L9_RunGraphics();

		/// <summary>
		/// Import declaration of the L9_DetectBitmaps method.
		/// See <see cref="Interpreter.DetectBitmaps"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern bool L9_DetectBitmaps(string path);

		/// <summary>
		/// Import declaration of the L9_DecodeBitmap method.
		/// See <see cref="Interpreter.DecodeBitmap"></see> for details.
		/// </summary>
		[DllImport(Config.LEVEL9_DLL)]
		static extern IntPtr L9_DecodeBitmap(int n);

		/// <summary>
		/// Import declaration of the L9_SetCallbackFunctions method.
		/// Sets the callback functions for the Level 9 interpreter.
		/// </summary>
		/// <param name="os_printchar">
		/// the os_printchar callback function
		/// </param>
		/// <param name="os_input">
		/// the os_input callback function
		/// </param>
		/// <param name="os_readchar">
		/// the os_readchar callback function
		/// </param>
		/// <param name="os_flush">
		/// the os_flush callback function
		/// </param>
		/// <param name="os_save_file">
		/// the os_save_file callback function
		/// </param>
		/// <param name="os_load_file">
		/// the os_load_file callback function
		/// </param>
		/// <param name="os_get_game_file">
		/// the os_get_game_file callback function
		/// </param>
		/// <param name="os_set_filenumber">
		/// the os_set_filenumber callback function
		/// </param>
		/// <param name="os_graphics">
		/// the os_graphics callback function
		/// </param>
		/// <param name="os_cleargraphics">
		/// the os_cleargraphics callback function
		/// </param>
		/// <param name="os_setcolour">
		/// the os_setcolour callback function
		/// </param>
		/// <param name="os_drawline">
		/// the os_drawline callback function
		/// </param>
		/// <param name="os_fill">
		/// the os_fill callback function
		/// </param>
		/// <param name="os_show_bitmap">
		/// the os_show_bitmap callback function
		/// </param>
		[DllImport(Config.LEVEL9_DLL)]
		static extern void L9_SetCallbackFunctions(
			OS_PRINTCHAR      os_printchar,
			OS_INPUT          os_input,
			OS_READCHAR       os_readchar,
			OS_FLUSH          os_flush,
			OS_SAVE_FILE      os_save_file,
			OS_LOAD_FILE      os_load_file,
			OS_GET_GAME_FILE  os_get_game_file,
			OS_SET_FILENUMBER os_set_filenumber,
			OS_GRAPHICS       os_graphics,
			OS_CLEARGRAPHICS  os_cleargraphics,
			OS_SETCOLOUR      os_setcolour,
			OS_DRAWLINE       os_drawline,
			OS_FILL           os_fill,
			OS_SHOW_BITMAP    os_show_bitmap
		);

		// -- Structs, Enums, Inner Classes ----------------------------------

		/// <summary>
		/// An enumeration of special interpreter commands.
		/// </summary>
		public enum Commands : int
		{
			/// <summary>
			/// No command.
			/// </summary>
			None = -1,
			/// <summary>
			/// Saves position file directly (bypasses any disk change prompts).
			/// </summary>
			Save = 0,
			/// <summary>
			/// Restores position file directly (bypasses any protection code).
			/// </summary>
			Restore,
			/// <summary>
			/// Terminates current game, RunGame() will return false.
			/// </summary>
			Quit,
			/// <summary>
			/// Tries to bypass restore protection on v3,4 games (can be slow).
			/// </summary>
			Cheat,
			/// <summary>
			/// Lists the game dictionary.
			/// </summary>
			Dictionary
		};

		/// <summary>
		/// The bitmap structure used in games with bitmap graphics.
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		public class L9BITMAP
		{
			/// <summary>
			/// The bitmap width.
			/// </summary>
			public short width;

			/// <summary>
			/// The bitmap height.
			/// </summary>
			public short height;

			/// <summary>
			/// A pointer to the bitmap pixels.
			/// </summary>
			public IntPtr bitmap;

			/// <summary>
			/// The bitmap palette. Each entry consists of three bytes
			/// (red, green, blue).
			/// </summary>
			[MarshalAs(UnmanagedType.ByValArray, SizeConst=96)]
			public byte[] palette;

			/// <summary>
			/// The number of palette entries.
			/// </summary>
			public short npalette;
		}

		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// An array that stores the interpreter callback functions.
		/// </summary>
		static Delegate[] callbacks = new Delegate[]
		{
			new OS_PRINTCHAR(os_printchar),
			new OS_INPUT(os_input),
			new OS_READCHAR(os_readchar),
			new OS_FLUSH(os_flush),
			new OS_SAVE_FILE(os_save_file),
			new OS_LOAD_FILE(os_load_file),
			new OS_GET_GAME_FILE(os_get_game_file),
			new OS_SET_FILENUMBER(os_set_filenumber),
			new OS_GRAPHICS(os_graphics),
			new OS_CLEARGRAPHICS(os_cleargraphics),
			new OS_SETCOLOUR(os_setcolour),
			new OS_DRAWLINE(os_drawline),
			new OS_FILL(os_fill),
			new OS_SHOW_BITMAP(os_show_bitmap)
		};

		/// <summary>
		/// The interpreter commands that correspond to the
		/// <see cref="Interpreter.Commands"></see> enumeration.
		/// </summary>
		static string[] commands = new string[]
		{
			"#save",
			"#restore",
			"#quit",
			"#cheat",
			"#dictionary",
		};

		/// <summary>
		/// The current interpreter command.
		/// </summary>
		static Commands currentCommand = Commands.None;

		/// <summary>
		/// Stores interpreter commands that were added with
		/// <see cref="Interpreter.AddInputRequest"></see>. Those commands
		/// are executed in calls to <see cref="Interpreter.os_input"></see>.
		/// </summary>
		static ArrayList inputRequests = new ArrayList();

		/// <summary>
		/// A text buffer used in calls to os_printchar.
		/// </summary>
		static StringBuilder outputBuffer = new StringBuilder();

		/// <summary>
		/// The current game file's path.
		/// </summary>
		static string gameFilePath;

		/// <summary>
		/// The current game's title.
		/// </summary>
		static string gameTitle;

		/// <summary>
		/// 
		/// </summary>
		static OsReadcharEventArgs readcharArgs = new OsReadcharEventArgs(0);

		// -- Events ---------------------------------------------------------

		/// <summary>
		/// Occurs when the interpreter flushes a portion of text.
		/// </summary>
		public static event OsFlushEventHandler OsFlush;

		/// <summary>
		/// Occurs when a running game waits for user input.
		/// </summary>
		public static event OsInputEventHandler OsInput;

		/// <summary>
		/// Occurs when a running game waits for a key press.
		/// </summary>
		public static event OsReadcharEventHandler OsReadchar;

		/// <summary>
		/// Occurs when the interpreter requests to save a file.
		/// </summary>
		public static event OsSaveFileEventHandler OsSaveFile;

		/// <summary>
		/// Occurs when the interpreter requests to load a file.
		/// </summary>
		public static event OsLoadFileEventHandler OsLoadFile;

		/// <summary>
		/// Occurs when the interpreter requests for a game file.
		/// </summary>
		public static event OsGetGameFileEventHandler OsGetGameFile;

		/// <summary>
		/// Occurs when graphics are turned on or off in a running game.
		/// </summary>
		public static event OsGraphicsEventHandler OsGraphics;

		/// <summary>
		/// Occurs when the graphics area must be cleared in a running game.
		/// </summary>
		public static event OsClearGraphicsEventHandler OsClearGraphics;

		/// <summary>
		/// Occurs when a line must be drawn in a running game.
		/// </summary>
		public static event OsDrawLineEventHandler OsDrawLine;

		/// <summary>
		/// Occurs when an area must be filled in a running game.
		/// </summary>
		public static event OsFillEventHandler OsFill;

		/// <summary>
		/// Occurs when a palette color must be set in a running game.
		/// </summary>
		public static event OsSetColourEventHandler OsSetColour;

		/// <summary>
		/// Occurs when a bitmap must be displayed in a running game.
		/// </summary>
		public static event OsShowBitmapEventHandler OsShowBitmap;

		/// <summary>
		/// Occurs when a new game has been loaded.
		/// </summary>
		public static event NewGameFileEventHandler NewGameFile;

		/// <summary>
		/// Occurs when the interpreter detects a game file error.
		/// </summary>
		public static event GameFileErrorEventHandler GameFileError;

		/// <summary>
		/// Occurs when the user has finished an input line.
		/// </summary>
		public static event InputFinishedEventHandler InputFinished;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes static members of the Interpreter class.
		/// </summary>
		static Interpreter()
		{
			L9_SetCallbackFunctions(
				(OS_PRINTCHAR)     callbacks[0],
				(OS_INPUT)         callbacks[1],
				(OS_READCHAR)      callbacks[2],
				(OS_FLUSH)         callbacks[3],
				(OS_SAVE_FILE)     callbacks[4],
				(OS_LOAD_FILE)     callbacks[5],
				(OS_GET_GAME_FILE) callbacks[6],
				(OS_SET_FILENUMBER)callbacks[7],
				(OS_GRAPHICS)      callbacks[8],
				(OS_CLEARGRAPHICS) callbacks[9],
				(OS_SETCOLOUR)     callbacks[10],
				(OS_DRAWLINE)      callbacks[11],
				(OS_FILL)          callbacks[12],
				(OS_SHOW_BITMAP)   callbacks[13]
			);
		}

		// -- Methods --------------------------------------------------------

		/// <summary>
		/// os_printchar() prints a character to the output. The interface
		/// can either buffer this character or print it immediately, but
		/// if buffering is used then the characters must all be sent to the
		/// output when the interpreter calls os_flush(). A paragraph of
		/// text is output as one long stream of characters, without line
		/// breaks, so the interface must provide its own word wrapping and
		/// any other features that are desired, such as justification or a
		/// [More] prompt. The carriage return character is always '\\r',
		/// rather than '\\n'.
		/// </summary>
		/// <param name="c">the character to print</param>
		public static void os_printchar(char c)
		{
			outputBuffer.Append(c);
			if (currentCommand == Commands.Dictionary
					&& outputBuffer.Length >= DICTIONARY_FLUSH && c == ' ') {
				OsFlushEventArgs args =
					new OsFlushEventArgs(outputBuffer.ToString());
				args.Command = currentCommand;
				OsFlush(args);
				outputBuffer.Remove(0, outputBuffer.Length);
			}
		}

		/// <summary>
		/// os_input() reads a line of text from the user, usually to accept
		/// the next command to be sent to the game. The text input must be
		/// stored in ibuff with a terminating zero, and be no longer than
		/// size characters. Normally os_input() should return true, but may
		/// return false to cause the entire input so far to be discarded.
		/// </summary>
		/// <param name="ibuff">the zero terminated input line</param>
		/// <param name="size">the maximum length of an input line</param>
		/// <returns>false if the entire input should be discarded</returns>
		public static bool os_input(byte *ibuff, int size)
		{
			Logger.Log(typeof(Interpreter), "os_input: Start");
			OsInputEventArgs args = new OsInputEventArgs();
			OsInput(args);
			//
			// Notify listeners that user input finished
			//
			if (InputFinished != null) {
				InputFinishedEventArgs ifArgs =
					new InputFinishedEventArgs(args.Input);
				InputFinished(ifArgs);
			}
			//
			// Remove input request, if one exists
			//
			if (inputRequests.Count > 0) {
				args.Input = commands[(int)inputRequests[0]];
				currentCommand = (Commands)inputRequests[0];
				inputRequests.RemoveAt(0);
			}
			Logger.Log(typeof(Interpreter), "os_input: '" + args.Input + "'");
			StringToBytes(args.Input, ibuff, size);

			return true;
		}

		/// <summary>
		/// os_readchar() looks to see if a key has been pressed if one has,
		/// returns the character to the interpreter immediately. If no key
		/// has been pressed the interpreter should wait for a key for at
		/// least the number of milliseconds given in the argument. If after
		/// this period no key has been pressed, 0 should be returned. This
		/// is most commonly used when a game is exited, causing it to print
		/// "Press SPACE to play again" and then call os_readchar().
		/// </summary>
		/// <param name="millis">
		/// the number of milliseconds to wait for a keystroke
		/// </param>
		/// <returns>
		/// 0 if no key has been pressed; otherwise a character
		/// </returns>
		public static byte os_readchar(int millis)
		{
			readcharArgs.Character = 0;
			readcharArgs.Millis = millis;

			OsReadchar(readcharArgs);
			if (readcharArgs.Character != 0) {
				Logger.Log(typeof(Interpreter), "os_readchar: '"
					+ readcharArgs.Character + "'");
			}

			return readcharArgs.Character;
		}

		/// <summary>
		/// If the calls to os_printchar() are being buffered by the
		/// interface then the buffered text must be printed when os_flush()
		/// is called.
		/// </summary>
		public static void os_flush()
		{
			if (outputBuffer.Length == 0
					&& currentCommand != Commands.Dictionary) {
				return;
			}
			Logger.Log(typeof(Interpreter), "os_flush: '" +
				outputBuffer.ToString().Replace("\r", "\\r") + "'");
			if (currentCommand == Commands.Dictionary) {
				outputBuffer.Append("\0");
			}
			OsFlushEventArgs args =
				new OsFlushEventArgs(outputBuffer.ToString());
			args.Command = currentCommand;
			OsFlush(args);
			outputBuffer.Remove(0, outputBuffer.Length);
			currentCommand = Commands.None;
		}

		/// <summary>
		/// os_save_file() should prompt the user in some way (with either
		/// text or a file requester) for a filename to save the area of
		/// memory of size Bytes pointed to by Ptr. true or false should be
		/// returned depending on whether or not the operation was successful.
		/// </summary>
		/// <param name="Ptr">the area of memory to save</param>
		/// <param name="Bytes">the number of bytes to save</param>
		/// <returns>
		/// true if the operation was successful; otherwise false
		/// </returns>
		public static bool os_save_file(byte *Ptr, int Bytes)
		{
			Logger.Log(typeof(Interpreter), "os_save_file");
			byte[] bytes = new byte[Bytes];
			for (int i = 0; i < Bytes; i++) {
				bytes[i] = Ptr[i];
			}
			OsSaveFileEventArgs args = new OsSaveFileEventArgs(bytes);
			OsSaveFile(args);

			return args.Success;
		}

		/// <summary>
		/// os_load_file() should prompt the user for the name of a file to
		/// load. At most Max bytes should be loaded into the memory pointed
		/// to by Ptr, and the number of bytes read should be placed into the
		/// variable pointed to by Bytes.
		/// </summary>
		/// <param name="Ptr">an area of memory to write the data to</param>
		/// <param name="Bytes">the number of bytes read</param>
		/// <param name="Max">the maximum number of bytes to read</param>
		/// <returns>
		/// true if the operation was successful; otherwise false
		/// </returns>
		public static bool os_load_file(byte *Ptr, int *Bytes, int Max)
		{
			Logger.Log(typeof(Interpreter), "os_load_file");
			OsLoadFileEventArgs args = new OsLoadFileEventArgs(Max);
			OsLoadFile(args);
			if (args.Bytes != null) {
				for (int i = 0; i < args.Bytes.Length; i++) {
					Ptr[i] = args.Bytes[i];
				}
				*Bytes = args.Bytes.Length;
			}
			else {
				*Bytes = 0;
			}

			return args.Success;
		}

		/// <summary>
		/// os_get_game_file() should prompt the user for a new game file, to
		/// be stored in NewName, which can take a maximum name of Size
		/// characters. When this function is called the NewName array
		/// contains the name of the currently loaded game, which can be used
		/// to derive a name to prompt the user with.
		/// This is used by at least the Adrian Mole games, which load in the
		/// next part of the game after the part currently being played has
		/// been completed. These games were originally written for tape-based
		/// systems where the call was simply "load the next game from the
		/// tape".
		/// </summary>
		/// <param name="NewName">the name of a game file</param>
		/// <param name="Size">the maximum length of NewName</param>
		/// <returns>
		/// true if the operation was successful; otherwise false
		/// </returns>
		public static bool os_get_game_file(byte *NewName, int Size)
		{
			string currentFile = BytesToString(NewName, Size);

			OsGetGameFileEventArgs args =
				new OsGetGameFileEventArgs(currentFile);
			OsGetGameFile(args);
			Logger.Log(typeof(Interpreter), "os_get_game_file: "
				+ args.Filename);
			StringToBytes(args.Filename, NewName, Size);
			if (args.Success) {
				SetGameFile(args.Filename);
			}

			return args.Success;
		}

		/// <summary>
		/// os_set_filenumber() is for multi-part games originally written for
		/// disk-based systems, which used game filenames such as
		/// <code>
		/// gamedat1.dat
		/// gamedat2.dat
		/// gamedat3.dat
		/// </code>
		/// etc. The routine should take the full filename in NewName (of
		/// maximum size Size) and modify it to reflect the number n, e.g.
		/// os_set_filename("gamedat1.dat", 2) should leave "gamedat2.dat"
		/// in NewName.
		/// </summary>
		/// <param name="NewName">the name of the new game file</param>
		/// <param name="Size">the maximum length of NewName</param>
		/// <param name="n">the number of the new game file</param>
		public static void os_set_filenumber(byte *NewName, int Size, int n)
		{
			StringBuilder path =
				new StringBuilder(BytesToString(NewName, Size));
			int i = path.Length;

			while (!Char.IsDigit(path[--i]) && i > 0);
			path.Replace(path[i], (char)('0' + n), i, 1);
			string newPath = path.ToString();
			if (File.Exists(newPath)) {
				StringToBytes(newPath, NewName, Size);
				SetGameFile(newPath);
			}
			Logger.Log(typeof(Interpreter), "os_set_filenumber: '" + newPath
				+ "', n: " + n);
		}

		/// <summary>
		/// Called when graphics are turned on or off, either by the game or
		/// by the user entering "graphics" or "text" as a command. If mode
		/// is 0 graphics should be turned off, else they should be turned on.
		/// After a os_graphics(0) call all the other graphics functions
		/// should do nothing.
		/// Typically, if mode is not 0 the code will allocate some suitable
		/// bitmap for drawing graphics into. To determine the size of the
		/// bitmap, the code should call GetPictureSize(). The graphics
		/// routines should draw in a bitmap of the size returned by this
		/// function, and then scale the bitmap appropriately for display.
		/// If instead the graphics code tries to scale the co-ordinates
		/// passed to os_drawline() and os_fill() then problems occur with
		/// fill colours "leaking" into other areas of the picture. The
		/// values returned by GetPictureSize() will not change unless a new
		/// game is loaded.
		/// The graphis bitmap is always 4 colour. The 4 colours are chosen
		/// from a possible 8 by calls to os_setcolour. Note that
		/// calls to os_setcolour() must affect the colour of pixels already
		/// drawn on the bitmap. For example, suppose a pixel in the bitmap
		/// is set to the first colour in the palette during drawing, which at
		/// that moment is red. If later the first colour in the palette is
		/// set to blue, at the end the pixel should be shown blue.
		/// In order to actually draw graphics, the input routines os_input()
		/// and os_readchar() should call RunGraphics().
		/// </summary>
		/// <param name="mode">the graphics mode</param>
		public static void os_graphics(int mode)
		{
			Logger.Log(typeof(Interpreter), "os_graphics: " + mode);
			OsGraphics(new OsGraphicsEventArgs(mode));
		}

		/// <summary>
		/// Clear the current graphics bitmap by filling the entire bitmap
		/// with colour 0.
		/// </summary>
		public static void os_cleargraphics()
		{
			Logger.Log(typeof(Interpreter), "os_cleargraphics");
			OsClearGraphics(new OsClearGraphicsEventArgs());
		}

		/// <summary>
		/// Set the given colour in the graphics bitmap's palette to the
		/// colour at the given index in the interpreter's table of colours.
		/// The actual table of colours in the interpreters provided by
		/// Level 9 vary across different machines. An acceptable palette
		/// that matches reasonably closely to the Amiga releases is as
		/// follows (all colours are 8 bit R,G,B):
		/// <code>
		/// 0x00,0x00,0x00  (black)
		/// 0xFF,0x00,0x00  (red)
		/// 0x30,0xE8,0x30  (green)
		/// 0xFF,0xFF,0x00  (yellow)
		/// 0x00,0x00,0xFF  (blue)
		/// 0xA0,0x68,0x00  (brown)
		/// 0x00,0xFF,0xFF  (cyan)
		/// 0xFF,0xFF,0xFF  (white)
		/// </code>
		/// </summary>
		/// <param name="colour">
		/// the colour in the graphics bitmap's palette
		/// </param>
		/// <param name="index">
		/// the index in the interpreter's table of colours
		/// </param>
		public static void os_setcolour(int colour, int index)
		{
			OsSetColour(new OsSetColourEventArgs(colour, index));
		}

		/// <summary>
		/// Draw a line on the graphics bitmap between (x1,y1) and (x2,y2).
		/// Note that either point may lie outside of the bitmap, and that it
		/// is the responsibility of the routine to clip to the appropriate
		/// coordinates.
		/// For each point on the line, if the colour at that point is equal
		/// to colour2 the pixel's colour should be changed to colour1, else
		/// it should not be modified.
		/// </summary>
		/// <param name="x1">the x coordinate of (x1,y1)</param>
		/// <param name="y1">the y coordinate of (x1,y1)</param>
		/// <param name="x2">the x coordinate of (x2,y2)</param>
		/// <param name="y2">the y coordinate of (x2,y2)</param>
		/// <param name="colour1">the index of colour 1</param>
		/// <param name="colour2">the index of colour 2</param>
		public static void os_drawline(int x1, int y1, int x2, int y2,
			byte colour1, byte colour2)
		{
			OsDrawLineEventArgs args = new OsDrawLineEventArgs(
				x1, y1, x2, y2, colour1, colour2);
			OsDrawLine(args);
		}

		/// <summary>
		/// If the pixel's colour at (x,y) is equal to colour2, fill the
		/// region containing (x,y) with colour1. The boundaries of the
		/// region are defined as those areas of the bitmap with a colour
		/// other than colour2.
		/// </summary>
		/// <param name="x">the x coordinate of pixel (x,y)</param>
		/// <param name="y">the y coordinate of pixel (x,y)</param>
		/// <param name="colour1">the index of colour 1</param>
		/// <param name="colour2">the index of colour 2</param>
		public static void os_fill(int x, int y, byte colour1, byte colour2)
		{
			OsFillEventArgs args = new OsFillEventArgs(x, y, colour1, colour2);
			OsFill(args);
		}

		/// <summary>
		/// Show the bitmap given by the number pic at the coordinates (x,y).
		/// Note that the game can request the same picture several times
		/// in a row: it is a good idea for ports to record the last picture
		/// number and check it against any new requests.
		/// </summary>
		/// <param name="pic">the bitmap's number</param>
		/// <param name="x">the x coordinate</param>
		/// <param name="y">the y coordinate</param>
		public static void os_show_bitmap(int pic, int x, int y)
		{
			Logger.Log(typeof(Interpreter), "os_show_bitmap: " + pic + ", x: "
				+ x + ", y: " + y);
			OsShowBitmap(new OsShowBitmapEventArgs(pic, x, y));
		}

		/// <summary>
		/// LoadGame() attempts to load a filename and then searches it for
		/// a valid Level 9 game. If it is successful true is returned, else
		/// false. The previous game in memory will be overwritten if the
		/// file filename can be loaded, even if it does not contain a Level9
		/// game, so even if LoadGame() returns false it must be assumed that
		/// the game memory has changed.
		/// The second argument is the name of the file containing picture
		/// data, and may be NULL. Ports should usually ask the user for just
		/// the filename and derive picname from it in some way. The
		/// recommended approach is to first try the filename with an extension
		/// of ".pic" and then try replacing the filename with "picture.dat".
		/// </summary>
		/// <param name="filename">the file to load</param>
		/// <param name="picname">the file containing picture data</param>
		/// <returns>
		/// true if successful, else false
		/// </returns>
		public static bool LoadGame(string filename, string picname)
		{
			Logger.Log(typeof(Interpreter), "LoadGame: " + filename);
			bool success = L9_LoadGame(filename, picname);

			if (success) {
				SetGameFile(filename);
			}
			else {
				GameFileError(new GameFileErrorEventArgs());
				os_flush();
			}

			return success;
		}

		/// <summary>
		/// If LoadGame() has been successful, RunGame() can be called to run
		/// the Level 9 game. Each call to RunGame() executes a single opcode
		/// of the game. In pre-emptive multitasking systems or systems without
		/// any multitasking it is enough to sit in a loop calling RunGame(),
		/// e.g.
		/// <code>
		/// while (RunGame());
		/// </code>
		/// RunGame() returns true if an opcode code was executed and false if
		/// the game is stopped, either by an error or by calls to StopGame().
		/// </summary>
		/// <returns>
		/// true if an opcode code was executed and false if the game is
		/// stopped.
		/// </returns>
		public static bool RunGame()
		{
			return L9_RunGame();
		}

		/// <summary>
		/// StopGame() stops the current game from playing.
		/// </summary>
		public static void StopGame()
		{
			L9_StopGame();
		}

		/// <summary>
		/// RestoreGame() attempts to restore the currently running game to
		/// the position stored in the inFile saved game file. This gives
		/// interface code a means to restore a game position.
		/// </summary>
		/// <param name="inFile">the saved game file</param>
		public static void RestoreGame(string inFile)
		{
			L9_RestoreGame(inFile);
		}

		/// <summary>
		/// FreeMemory() frees memory used to store the game. This routine
		/// should be called when exiting the interpreter.
		/// </summary>
		public static void FreeMemory()
		{
			L9_FreeMemory();
		}

		/// <summary>
		/// Returns the width and height of the bitmap that graphics should
		/// be drawn into. This is constant for any particular game.
		/// </summary>
		/// <param name="width">the bitmap's width</param>
		/// <param name="height">the bitmap's height</param>
		public static void GetPictureSize(ref int width, ref int height)
		{
			L9_GetPictureSize(ref width, ref height);
		}

		/// <summary>
		/// Runs an opcode of the graphics routines. The simplest way to
		/// display graphics. If a graphics opcode was run true is returned,
		/// otherwise false.
		/// The simplest way to get graphics to display is to add a loop to
		/// repeatedly call RunGraphics() to os_input() and os_readchar():
		/// <code>
		/// while (RunGraphics());
		/// // Now draw graphics bitmap on display...
		/// </code>
		/// Optionally, the code can provide a more "atmospheric" recreation
		/// of the games by drawing the graphics slowly, as was the case on
		/// the old 8-bit computers. This is achieved by calling RunGraphics()
		/// several times then waiting for a while before calling it again.
		/// Note that when waiting the code should still respond to user
		/// input.
		/// </summary>
		/// <returns>
		/// true if a graphics opcode was run; otherwise false
		/// </returns>
		public static bool RunGraphics()
		{
			return L9_RunGraphics();
		}

		/// <summary>
		/// This function must be called first to initialize the decoder.
		/// It tries to determine which format of bitmap pictures is
		/// available in the given directory.
		/// </summary>
		/// <param name="path">the game directory</param>
		/// <returns>true if supported pictures are found</returns>
		public static bool DetectBitmaps(string path)
		{
			return L9_DetectBitmaps(path);
		}

		/// <summary>
		/// Decode and return picture with the given number.
		/// </summary>
		/// <param name="n">the picture's number</param>
		/// <returns>
		/// IntPtr.Zero if decoding fails; otherwise IntPtr is a reference to
		/// a L9Bitmap structure
		/// </returns>
		public static IntPtr DecodeBitmap(int n)
		{
			return L9_DecodeBitmap(n);
		}

		/// <summary>
		/// Adds an input request. Typically used by the application to
		/// execute special interpreter commands. See
		/// <see cref="Interpreter.Commands"></see> for details.
		/// </summary>
		/// <param name="command">an input command</param>
		public static void AddInputRequest(Commands command)
		{
			Logger.Log(typeof(Interpreter), "AddInputRequest: " + command);
			inputRequests.Add(command);
		}

		/// <summary>
		/// Sets a new game file and notifies the listeners.
		/// </summary>
		/// <param name="filePath">the game file's path</param>
		public static void SetGameFile(string filePath)
		{
			gameFilePath = filePath;
			gameTitle    = L9Cut.GetGameTitle(filePath);
			NewGameFile(new NewGameFileEventArgs());
		}

		/// <summary>
		/// Converts a byte array into a string.
		/// </summary>
		/// <param name="source">a byte array</param>
		/// <param name="size">the maximum number of bytes to convert</param>
		/// <returns>a string representation of the byte array</returns>
		static string BytesToString(byte *source, int size)
		{
			StringBuilder builder = new StringBuilder();

			for (int i = 0; (source[i] != 0 && i < size); i++) {
				builder.Append(Convert.ToChar(source[i]));
			}

			return builder.ToString();
		}

		/// <summary>
		/// Converts a string into a byte array.
		/// </summary>
		/// <param name="source">the source string</param>
		/// <param name="target">a byte array</param>
		/// <param name="max">
		/// the maximum number of characters to convert
		/// </param>
		static void StringToBytes(String source, byte *target, int max)
		{
			int i = 0;

			if (source == null || source.Length > max) {
				return;
			}
			for (i = 0; (i < source.Length) && (i < max - 1); i++) {
				target[i] = Convert.ToByte(source[i]);
			}
			target[i] = 0;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets the current game file's path.
		/// </summary>
		public static string GameFilePath
		{
			get {
				return gameFilePath;
			}
		}

		/// <summary>
		/// Gets the current game's title.
		/// </summary>
		public static string GameTitle
		{
			get {
				return gameTitle;
			}
		}

	}

	/// <summary>
	/// Represents the method that handles a OsFlush event.
	/// </summary>
	public delegate void OsFlushEventHandler(OsFlushEventArgs e);

	/// <summary>
	/// Provides data for the OsFlush event.
	/// </summary>
	public class OsFlushEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The text to flush.
		/// </summary>
		string text = null;

		/// <summary>
		/// The current interpreter command.
		/// See <see cref="Interpreter.Commands"></see> for details.
		/// </summary>
		Interpreter.Commands command = Interpreter.Commands.None;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsFlushEventArgs class.
		/// </summary>
		/// <param name="text">the text to flush</param>
		public OsFlushEventArgs(string text)
		{
			this.text = text;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the current interpreter command.
		/// </summary>
		public Interpreter.Commands Command
		{
			get {
				return command;
			}
			set {
				command = value;
			}
		}

		/// <summary>
		/// Gets or sets the text to flush.
		/// </summary>
		public string Text
		{
			get {
				return text;
			}
			set {
				text = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsInput event.
	/// </summary>
	public delegate void OsInputEventHandler(OsInputEventArgs e);

	/// <summary>
	/// Provides data for the OsInput event.
	/// </summary>
	public class OsInputEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The input line.
		/// </summary>
		string input = null;

		// -- Accessors ------------------------------------------------------

		/// <summary>Gets or sets the input line.</summary>
		public string Input
		{
			get {
				return input;
			}
			set {
				input = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsReadchar event.
	/// </summary>
	public delegate void OsReadcharEventHandler(OsReadcharEventArgs e);

	/// <summary>
	/// Provides data for the OsReadchar event.
	/// </summary>
	public class OsReadcharEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The input character.
		/// </summary>
		byte character = 0;

		/// <summary>
		/// The number of milliseconds to wait for a keystroke.
		/// </summary>
		int  millis = 0;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsReadcharEventArgs class.
		/// </summary>
		/// <param name="millis">
		/// the number of milliseconds to wait for a keystroke
		/// </param>
		public OsReadcharEventArgs(int millis)
		{
			this.millis = millis;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the input character.
		/// </summary>
		public byte Character
		{
			get {
				return character;
			}
			set {
				character = value;
			}
		}

		/// <summary>
		/// Gets or sets the number of milliseconds to wait for a keystroke.
		/// </summary>
		public int Millis
		{
			get {
				return millis;
			}
			set {
				millis = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsSaveFile event.
	/// </summary>
	public delegate void OsSaveFileEventHandler(OsSaveFileEventArgs e);

	/// <summary>
	/// Provides data for the OsSaveFile event.
	/// </summary>
	public class OsSaveFileEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The portion of bytes to save.
		/// </summary>
		byte[] bytes;

		/// <summary>
		/// This property indicates whether the operation was successful.
		/// </summary>
		bool success = false;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsSaveFileEventArgs class.
		/// </summary>
		/// <param name="bytes">the portion of bytes to save</param>
		public OsSaveFileEventArgs(byte[] bytes)
		{
			this.bytes = bytes;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the portion of bytes to save.
		/// </summary>
		public byte[] Bytes
		{
			get {
				return bytes;
			}
			set {
				bytes = value;
			}
		}

		/// <summary>
		/// Gets or sets a value that indicates whether the operation was
		/// successful.
		/// </summary>
		public bool Success
		{
			get {
				return success;
			}
			set {
				success = value;
			}
		}

	}

	/// <summary>
	/// Represents the method that handles a OsLoadFile event.
	/// </summary>
	public delegate void OsLoadFileEventHandler(OsLoadFileEventArgs e);

	/// <summary>
	/// Provides data for the OsLoadFile event.
	/// </summary>
	public class OsLoadFileEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The number of bytes loaded.
		/// </summary>
		byte[] bytes;

		/// <summary>
		/// The maximum number of bytes to load.
		/// </summary>
		int maxBytes;

		/// <summary>
		/// This property indicates whether the operation was successful.
		/// </summary>
		bool success = false;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsLoadFileEventArgs class.
		/// </summary>
		/// <param name="maxBytes">the maximum number of bytes to load</param>
		public OsLoadFileEventArgs(int maxBytes)
		{
			this.maxBytes = maxBytes;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the number of bytes loaded.
		/// </summary>
		public byte[] Bytes
		{
			get {
				return bytes;
			}
			set {
				bytes = value;
			}
		}

		/// <summary>
		/// Gets or sets a value that indicates whether the operation was
		/// successful.
		/// </summary>
		public bool Success
		{
			get {
				return success;
			}
			set {
				success = value;
			}
		}

		/// <summary>
		/// Gets or sets the maximum number of bytes to load.
		/// </summary>
		public int MaxBytes
		{
			get {
				return maxBytes;
			}
			set {
				maxBytes = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsGetGameFile event.
	/// </summary>
	public delegate void OsGetGameFileEventHandler(OsGetGameFileEventArgs e);

	/// <summary>
	/// Provides data for the OsGetGameFile event.
	/// </summary>
	public class OsGetGameFileEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The game file name.
		/// </summary>
		string filename = null;

		/// <summary>
		/// This property indicates whether the operation was successful.
		/// </summary>
		bool success = false;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsGetGameFileEventArgs class.
		/// </summary>
		/// <param name="filename">the game file name</param>
		public OsGetGameFileEventArgs(string filename)
		{
			this.filename = filename;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the game file name.
		/// </summary>
		public string Filename
		{
			get {
				return filename;
			}
			set {
				filename = value;
			}
		}

		/// <summary>
		/// Gets or sets a value that indicates whether the operation was
		/// successful.
		/// </summary>
		public bool Success
		{
			get {
				return success;
			}
			set {
				success = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a NewGameFile event.
	/// </summary>
	public delegate void NewGameFileEventHandler(NewGameFileEventArgs e);

	/// <summary>
	/// Provides data for the NewGameFile event.
	/// </summary>
	public class NewGameFileEventArgs : EventArgs
	{
		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the NewGameFileEventArgs class.
		/// </summary>
		public NewGameFileEventArgs() { }
	}

	/// <summary>
	/// Represents the method that handles a OsGraphics event.
	/// </summary>
	public delegate void OsGraphicsEventHandler(OsGraphicsEventArgs e);

	/// <summary>
	/// Provides data for the OsGraphics event.
	/// </summary>
	public class OsGraphicsEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The graphics mode.
		/// See <see cref="Interpreter.os_graphics"></see> for details.
		/// </summary>
		int mode = 0;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsGraphicsEventArgs class.
		/// </summary>
		/// <param name="mode">the graphics mode</param>
		public OsGraphicsEventArgs(int mode)
		{
			this.mode = mode;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the graphics mode.
		/// </summary>
		public int Mode
		{
			get {
				return mode;
			}
			set {
				mode = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsClearGraphics event.
	/// </summary>
	public delegate void OsClearGraphicsEventHandler(
		OsClearGraphicsEventArgs e);

	/// <summary>
	/// Provides data for the OsClearGraphics event.
	/// </summary>
	public class OsClearGraphicsEventArgs : EventArgs
	{
		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsClearGraphicsEventArgs class.
		/// </summary>
		public OsClearGraphicsEventArgs() { }
	}

	/// <summary>
	/// Delegate declaration of the OsDrawLine event handler.
	/// </summary>
	public delegate void OsDrawLineEventHandler(OsDrawLineEventArgs e);

	/// <summary>
	/// Provides data for the OsDrawLine event.
	/// </summary>
	public class OsDrawLineEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The x coordinate of pixel (x1,y1).
		/// </summary>
		int x1 = 0;

		/// <summary>
		/// The y coordinate of pixel (x1,y1).
		/// </summary>
		int y1 = 0;

		/// <summary>
		/// The x coordinate of pixel (x2,y2).
		/// </summary>
		int x2 = 0;

		/// <summary>
		/// The y coordinate of pixel (x2,y2).
		/// </summary>
		int y2 = 0;

		/// <summary>
		/// The index of colour 1.
		/// </summary>
		byte colour1 = 0;

		/// <summary>
		/// The index of colour 2.
		/// </summary>
		byte colour2 = 0;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsDrawLineEventArgs class.
		/// </summary>
		/// <param name="x1">the x coordinate of pixel (x1,y1)</param>
		/// <param name="y1">the y coordinate of pixel (x1,y1)</param>
		/// <param name="x2">the x coordinate of pixel (x2,y2)</param>
		/// <param name="y2">the y coordinate of pixel (x2,y2)</param>
		/// <param name="colour1">the index of colour 1</param>
		/// <param name="colour2">the index of colour 2</param>
		public OsDrawLineEventArgs(int x1, int y1, int x2, int y2,
			byte colour1, byte colour2)
		{
			this.x1 = x1;
			this.y1 = y1;
			this.x2 = x2;
			this.y2 = y2;
			this.colour1 = colour1;
			this.colour2 = colour2;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the x coordinate of pixel (x1,y1).
		/// </summary>
		public int X1
		{
			get {
				return x1;
			}
			set {
				x1 = value;
			}
		}

		/// <summary>
		/// Gets or sets the y coordinate of pixel (x1,y1).
		/// </summary>
		public int Y1
		{
			get {
				return y1;
			}
			set {
				y1 = value;
			}
		}

		/// <summary>
		/// Gets or sets the x coordinate of pixel (x2,y2).
		/// </summary>
		public int X2
		{
			get {
				return x2;
			}
			set {
				x2 = value;
			}
		}

		/// <summary>
		/// Gets or sets the y coordinate of pixel (x2,y2).
		/// </summary>
		public int Y2
		{
			get {
				return y2;
			}
			set {
				y2 = value;
			}
		}

		/// <summary>
		/// Gets or sets the index of colour 1.
		/// </summary>
		public byte Colour1
		{
			get {
				return colour1;
			}
			set {
				colour1 = value;
			}
		}

		/// <summary>
		/// Gets or sets the index of colour 2.
		/// </summary>
		public byte Colour2
		{
			get {
				return colour2;
			}
			set {
				colour2 = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsFill event.
	/// </summary>
	public delegate void OsFillEventHandler(OsFillEventArgs e);

	/// <summary>
	/// Provides data for the OsFill event.
	/// </summary>
	public class OsFillEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The x coordinate of pixel (x,y).
		/// </summary>
		int x = 0;

		/// <summary>
		/// The y coordinate of pixel (x,y).
		/// </summary>
		int y = 0;

		/// <summary>
		/// The index of colour 1.
		/// </summary>
		byte colour1 = 0;

		/// <summary>
		/// The index of colour 2.
		/// </summary>
		byte colour2 = 0;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsFillEventArgs class.
		/// </summary>
		/// <param name="x">the x coordinate of pixel (x,y)</param>
		/// <param name="y">the y coordinate of pixel (x,y)</param>
		/// <param name="colour1">the index of colour 1</param>
		/// <param name="colour2">the index of colour 2</param>
		public OsFillEventArgs(int x, int y, byte colour1, byte colour2)
		{
			this.x = x;
			this.y = y;
			this.colour1 = colour1;
			this.colour2 = colour2;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the x coordinate of pixel (x,y).
		/// </summary>
		public int X
		{
			get {
				return x;
			}
			set {
				x = value;
			}
		}

		/// <summary>
		/// Gets or sets the y coordinate of pixel (x,y).
		/// </summary>
		public int Y
		{
			get {
				return y;
			}
			set {
				y = value;
			}
		}

		/// <summary>
		/// Gets or sets the index of colour 1.
		/// </summary>
		public byte Colour1
		{
			get {
				return colour1;
			}
			set {
				colour1 = value;
			}
		}

		/// <summary>
		/// Gets or sets the index of colour 2.
		/// </summary>
		public byte Colour2
		{
			get {
				return colour2;
			}
			set {
				colour2 = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsSetColour event.
	/// </summary>
	public delegate void OsSetColourEventHandler(OsSetColourEventArgs e);

	/// <summary>
	/// Provides data for the OsSetColour event.
	/// </summary>
	public class OsSetColourEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The colour in the graphics bitmap's palette.
		/// </summary>
		int colour = 0;

		/// <summary>
		/// The index in the interpreter's table of colours.
		/// </summary>
		int index = 0;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsSetColourEventArgs class.
		/// </summary>
		/// <param name="colour">
		/// the colour in the graphics bitmap's palette
		/// </param>
		/// <param name="index">
		/// the index in the interpreter's table of colours
		/// </param>
		public OsSetColourEventArgs(int colour, int index)
		{
			this.colour = colour;
			this.index = index;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the colour in the graphics bitmap's palette.
		/// </summary>
		public int Colour
		{
			get {
				return colour;
			}
			set {
				colour = value;
			}
		}

		/// <summary>
		/// Gets or sets the index in the interpreter's table of colours.
		/// </summary>
		public int Index
		{
			get {
				return index;
			}
			set {
				index = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a OsShowBitmap event.
	/// </summary>
	public delegate void OsShowBitmapEventHandler(OsShowBitmapEventArgs e);

	/// <summary>
	/// Provides data for the OsShowBitmap event.
	/// </summary>
	public class OsShowBitmapEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The bitmap's number.
		/// </summary>
		int number = 0;

		/// <summary>
		/// The bitmap's x offset.
		/// </summary>
		int x = 0;

		/// <summary>
		/// The bitmap's y offset.
		/// </summary>
		int y = 0;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the OsShowBitmapEventArgs class.
		/// </summary>
		/// <param name="number">the bitmap's number</param>
		/// <param name="x">the bitmap's x offset</param>
		/// <param name="y">the bitmap's y offset</param>
		public OsShowBitmapEventArgs(int number, int x, int y)
		{
			this.number = number;
			this.x = x;
			this.y = y;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the bitmap's number.
		/// </summary>
		public int Number
		{
			get {
				return number;
			}
			set {
				number = value;
			}
		}

		/// <summary>
		/// Gets or sets the bitmap's x offset.
		/// </summary>
		public int X
		{
			get {
				return x;
			}
			set {
				x = value;
			}
		}

		/// <summary>
		/// Gets or sets the bitmap's y offset.
		/// </summary>
		public int Y
		{
			get {
				return y;
			}
			set {
				y = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a GameFileError event.
	/// </summary>
	public delegate void GameFileErrorEventHandler(GameFileErrorEventArgs e);

	/// <summary>
	/// Provides data for the GameFileError event.
	/// </summary>
	public class GameFileErrorEventArgs : EventArgs
	{
		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the GameFileErrorEventArgs class.
		/// </summary>
		public GameFileErrorEventArgs() { }
	}

	/// <summary>
	/// Represents the method that handles a InputFinished event.
	/// </summary>
	public delegate void InputFinishedEventHandler(InputFinishedEventArgs e);

	/// <summary>
	/// Provides data for the InputFinished event.
	/// </summary>
	public class InputFinishedEventArgs : EventArgs
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The input line.
		/// </summary>
		string input = null;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the InputFinishedEventArgs class.
		/// </summary>
		/// <param name="input">the input line</param>
		public InputFinishedEventArgs(string input)
		{
			this.input = input;
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets or sets the input line.
		/// </summary>
		public string Input
		{
			get {
				return input;
			}
			set {
				input = value;
			}
		}
	}
}