--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/AbstractWarFoundryLoader.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,695 @@
+// This file (AbstractWarFoundryLoader.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using IBBoard.Collections;
+using IBBoard.IO;
+using IBBoard.Logging;
+using IBBoard.WarFoundry.API.Factories;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API
+{
+	/// <summary>
+	/// The base abstract implementation of a WarFoundry file loader
+	/// </summary>
+	public abstract class AbstractWarFoundryLoader
+	{
+		private ICollection<DirectoryInfo> directories;
+		private ICollection<INativeWarFoundryFactory> factories;
+		private ICollection<INonNativeWarFoundryFactory> nonNativeFactories;
+		private Dictionary<IWarFoundryFactory, SimpleSet<IWarFoundryObject>> loadedObjects;
+
+		public delegate void FileLoadingCompleteDelegate(List<FileLoadFailure> failures);
+
+		public event MethodInvoker FileLoadingStarted;
+
+		public event FileLoadingCompleteDelegate FileLoadingFinished;
+
+		protected AbstractWarFoundryLoader()
+		{
+			directories = new List<DirectoryInfo>();
+			factories = new List<INativeWarFoundryFactory>();
+			nonNativeFactories = new List<INonNativeWarFoundryFactory>();
+			loadedObjects = new Dictionary<IWarFoundryFactory,SimpleSet<IWarFoundryObject>>();
+		}
+		
+		/// <summary>
+		/// Adds a directory to the collection of directories that will be searched for WarFoundry data files.
+		/// </summary>
+		/// <param name="directory">
+		/// The <see cref="DirectoryInfo"/> to add to the list for searching for data files
+		/// </param>
+		public void AddLoadDirectory(DirectoryInfo directory)
+		{
+			if (!directories.Contains(directory))
+			{
+				directories.Add(directory);
+			}
+		}
+		
+		/// <summary>
+		/// Removes a directory from the collection of directories that will be searched for WarFoundry data files.
+		/// </summary>
+		/// <param name="directory">
+		/// A <see cref="DirectoryInfo"/>
+		/// </param>
+		public void RemoveLoadDirectory(DirectoryInfo directory)
+		{
+			if (directories.Contains(directory))
+			{
+				directories.Remove(directory);
+			}
+		}
+		
+		/// <summary>
+		/// Registers a <see cref="INativeWarFoundryFactory"/> as a factory that can parse native data files.
+		/// </summary>
+		/// <param name="factory">
+		/// The <see cref="INativeWarFoundryFactory"/> to register to parse native data files.
+		/// </param>
+		public virtual void RegisterFactory(INativeWarFoundryFactory factory)
+		{
+			if (!factories.Contains(factory))
+			{
+				factories.Add(factory);
+			}
+		}
+		
+		/// <summary>
+		/// Unregisters a <see cref="INativeWarFoundryFactory"/> so that it will no longer be used to try to parse native data files.
+		/// </summary>
+		/// <param name="factory">
+		/// The <see cref="INativeWarFoundryFactory"/> to remove from the collection of factories that are used to try to parse native data files.
+		/// </param>
+		public virtual void UnregisterFactory(INativeWarFoundryFactory factory)
+		{
+			if (factories.Contains(factory))
+			{
+				factories.Remove(factory);
+			}
+		}
+		
+		/// <summary>
+		/// Registers a <see cref="INonNativeWarFoundryFactory"/> so that it will be used to try to parse non-native data files from other applications.
+		/// </summary>
+		/// <param name="factory">
+		/// The <see cref="INonNativeWarFoundryFactory"/> to register to parse non-native data files.
+		/// </param>
+		public virtual void RegisterNonNativeFactory(INonNativeWarFoundryFactory factory)
+		{
+			if (!nonNativeFactories.Contains(factory))
+			{
+				nonNativeFactories.Add(factory);
+			}
+		}
+		
+		/// <summary>
+		/// Unregisters a <see cref="INonNativeWarFoundryFactory"/> so that it will no longer be used to try to parse non-native data files from other applications.
+		/// </summary>
+		/// <param name="factory">
+		/// The <see cref="INonNativeWarFoundryFactory"/> to remove from the collection of factories that are used to try to parse non-native data files.
+		/// </param>
+		public virtual void UnregisterNonNativeFactory(INonNativeWarFoundryFactory factory)
+		{
+			if (nonNativeFactories.Contains(factory))
+			{
+				nonNativeFactories.Remove(factory);
+			}
+		}
+		
+		/// <summary>
+		/// Loads all of the data files in the registered directories.
+		/// </summary>
+		/// <returns>
+		/// A <see cref="List"/> of <see cref="FileLoadFailure"/> for files that failed to load
+		/// </returns>
+		public List<FileLoadFailure> LoadFiles()
+		{
+			PrepareForFileLoad();
+			Dictionary<FileInfo, IWarFoundryFactory> loadableRaces = new Dictionary<FileInfo, IWarFoundryFactory>();
+			Dictionary<FileInfo, IWarFoundryFactory> loadableGameSystems = new Dictionary<FileInfo, IWarFoundryFactory>();
+			List<FileLoadFailure> failedLoads = FillLoadableFiles(loadableRaces, loadableGameSystems);
+			failedLoads.AddRange(LoadGameSystems(loadableGameSystems));
+			failedLoads.AddRange(LoadRaces(loadableRaces));
+			OnFileLoadingFinished(failedLoads);
+			FinishFileLoad();
+			return failedLoads;
+		}
+
+		private void OnFileLoadingFinished(List<FileLoadFailure> failures)
+		{
+			if (FileLoadingFinished != null)
+			{
+				FileLoadingFinished(failures);
+			}
+		}
+
+		protected virtual void PrepareForFileLoad()
+		{
+			//Do nothing special
+		}
+
+		protected virtual void FinishFileLoad()
+		{
+			//Do nothing special
+		}
+
+		private List<FileLoadFailure> FillLoadableFiles(Dictionary<FileInfo, IWarFoundryFactory> loadableRaces, Dictionary<FileInfo, IWarFoundryFactory> loadableGameSystems)
+		{			
+			List<FileLoadFailure> fails = new List<FileLoadFailure>();
+			
+			foreach (DirectoryInfo directory in directories)
+			{
+				directory.Refresh();
+
+				if (directory.Exists)
+				{
+					List<FileLoadFailure> directoryFails = FillLoadableFilesForDirectory(loadableRaces, loadableGameSystems, directory);
+					fails.AddRange(directoryFails);
+				}
+				else
+				{
+					LogNotifier.WarnFormat(GetType(), "Load for {0} failed because directory didn't exist", directory.FullName);
+				}
+			}
+			
+			return fails;
+		}
+
+		private List<FileLoadFailure> FillLoadableFilesForDirectory(Dictionary<FileInfo, IWarFoundryFactory> loadableRaces, Dictionary<FileInfo, IWarFoundryFactory> loadableGameSystems, DirectoryInfo directory)
+		{
+			List<FileLoadFailure> fails = new List<FileLoadFailure>();
+			LogNotifier.Debug(GetType(), "Load from " + directory.FullName);
+		
+			foreach (FileInfo file in directory.GetFiles())
+			{
+				IWarFoundryFactory factory = GetGameSystemLoadingFactoryForFile(file);
+				
+				if (factory != null)
+				{
+					loadableGameSystems.Add(file, factory);
+				}
+				else
+				{
+					factory = GetRaceLoadingFactoryForFile(file);
+	
+					if (factory != null)
+					{
+						loadableRaces.Add(file, factory);
+					}
+					else
+					{
+						FileLoadFailure failure = new FileLoadFailure(file, "File not handled as a Race or Game System definition: {0}", "FileNotHandled");
+						fails.Add(failure);
+						LogNotifier.Info(GetType(), failure.Message);
+					}
+				}
+			}
+			
+			foreach (DirectoryInfo subdir in directory.GetDirectories())
+			{
+				fails.AddRange(FillLoadableFilesForDirectory(loadableRaces, loadableGameSystems, subdir));
+			}
+
+			return fails;
+		}
+
+		private IWarFoundryFactory GetGameSystemLoadingFactoryForFile(FileInfo file)
+		{
+			IWarFoundryFactory loadingFactory = null;
+			
+			foreach (INonNativeWarFoundryFactory factory in nonNativeFactories)
+			{
+				if (factory.CanHandleFileAsGameSystem(file))
+				{
+					loadingFactory = factory;
+					break;
+				}
+			}
+
+			if (loadingFactory == null)
+			{
+				foreach (INativeWarFoundryFactory factory in factories)
+				{
+					if (factory.CanHandleFileAsGameSystem(file))
+					{
+						loadingFactory = factory;
+						break;
+					}
+				}
+			}
+
+			return loadingFactory;
+		}
+
+		private IWarFoundryFactory GetRaceLoadingFactoryForFile(FileInfo file)
+		{
+			IWarFoundryFactory loadingFactory = null;
+			
+			foreach (INonNativeWarFoundryFactory factory in nonNativeFactories)
+			{
+				if (factory.CanHandleFileAsRace(file))
+				{
+					loadingFactory = factory;
+					break;
+				}
+			}
+
+			if (loadingFactory == null)
+			{
+				foreach (INativeWarFoundryFactory factory in factories)
+				{
+					if (factory.CanHandleFileAsRace(file))
+					{
+						loadingFactory = factory;
+						break;
+					}
+				}
+			}
+
+			return loadingFactory;
+		}
+
+		private List<FileLoadFailure> LoadGameSystems(Dictionary<FileInfo, IWarFoundryFactory> gameSystemFiles)
+		{
+			List<FileLoadFailure> fails = new List<FileLoadFailure>();
+
+			
+			foreach (FileInfo file in gameSystemFiles.Keys)
+			{
+				FileLoadFailure failure = null;
+				
+				try
+				{
+					bool loaded = LoadObject(file, gameSystemFiles[file]);
+	
+					if (!loaded)
+					{
+						failure = new FileLoadFailure(file, "FileLoadFailed", "Failed to load {0} as GameSystem using {1}");
+					}
+				}
+				catch (Exception ex)
+				{
+					failure = new FileLoadFailure(file, null, ex.Message, null, ex);
+				}
+						
+				if (failure != null)
+				{
+					fails.Add(failure);
+					LogNotifier.Warn(GetType(), failure.Message, failure.Exception);
+				}
+			}
+			
+			return fails;
+		}
+
+		private List<FileLoadFailure> LoadRaces(Dictionary<FileInfo, IWarFoundryFactory> raceFiles)
+		{
+			List<FileLoadFailure> fails = new List<FileLoadFailure>();
+			
+			foreach (FileInfo file in raceFiles.Keys)
+			{
+				FileLoadFailure failure = null;
+				
+				try
+				{
+					bool loaded = LoadObject(file, raceFiles[file]);
+	
+					if (!loaded)
+					{
+						failure = new FileLoadFailure(file, "FileLoadFailed", "Failed to load {0} as Race using {1}");
+					}
+				}
+				catch (Exception ex)
+				{
+					failure = new FileLoadFailure(file, null, ex.Message, null, ex);
+				}
+						
+				if (failure != null)
+				{
+					fails.Add(failure);
+					LogNotifier.Warn(GetType(), failure.Message, failure.Exception);
+				}
+			}
+			
+			return fails;
+		}
+
+		private bool LoadObject(FileInfo file, IWarFoundryFactory factory)
+		{
+			LogNotifier.DebugFormat(GetType(), "Loading {0} using {1}", file.FullName, factory.GetType().Name);
+			factory.RaceLoaded+= StoreRace;
+			factory.GameSystemLoaded+= StoreGameSystem;
+			ICollection<IWarFoundryObject> objects = factory.CreateObjectsFromFile(file);
+			return objects.Count > 0;
+		}
+		
+		
+		/// <summary>
+		/// Loads a single file through the registered WarFoundryFactories, if a factory exists that supports the file format.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> for the file to attempt to load
+		/// </param>
+		/// <returns>
+		/// An ICollection of IWarFoundryObjects loaded from <code>file</code>
+		/// </returns>
+		public ICollection<IWarFoundryObject> LoadFile(FileInfo file)
+		{
+			ICollection<IWarFoundryObject> objs = null;
+			IWarFoundryFactory loadFactory = null;
+			
+			try
+			{
+				objs = LoadFileWithNonNativeFactories(file, out loadFactory);
+				
+				if (objs == null)
+				{
+					objs = LoadFileWithNativeFactories(file, out loadFactory);
+				}
+			}
+			catch (InvalidFileException ex)
+			{
+				LogNotifier.Error(GetType(), file.FullName + " failed to load", ex);
+			}
+				
+			if (objs != null)
+			{
+				AddLoadedObjects(objs, loadFactory);
+			}
+			else
+			{
+				objs = new List<IWarFoundryObject>();
+			}
+
+			return objs;
+		}
+
+		private ICollection<IWarFoundryObject> LoadFileWithNonNativeFactories(FileInfo file, out IWarFoundryFactory loadFactory)
+		{
+			ICollection<IWarFoundryObject> objs = null;
+			loadFactory = null;
+			
+			if (nonNativeFactories.Count > 0)
+			{
+				LogNotifier.Debug(GetType(), "Attempting to load " + file.FullName + " as a non-native file");
+				
+				foreach (INonNativeWarFoundryFactory factory in nonNativeFactories)
+				{
+					bool canLoad = factory.CanHandleFileFormat(file);
+					LogNotifier.Debug(GetType(), "Load using " + factory.GetType().FullName + "? " + (canLoad ? "yes" : "no"));
+					
+					if (canLoad)
+					{
+						objs = factory.CreateObjectsFromFile(file);
+						
+						if (objs != null)
+						{
+							loadFactory = factory;
+							break;
+						}
+					}			         
+				}
+			}
+			
+			return objs;
+		}
+
+		private ICollection<IWarFoundryObject> LoadFileWithNativeFactories(FileInfo file, out IWarFoundryFactory loadFactory)
+		{
+			ICollection<IWarFoundryObject> objs = null;
+			loadFactory = null;
+			
+			if (factories.Count > 0)
+			{
+				LogNotifier.Debug(GetType(), "Attempting to load " + file.FullName + " as native file");
+						
+				foreach (INativeWarFoundryFactory factory in factories)
+				{
+					if (factory.CanHandleFileFormat(file))
+					{
+						objs = factory.CreateObjectsFromFile(file);
+						
+						if (objs != null)
+						{
+							loadFactory = factory;
+							break;
+						}
+					}
+				}
+			}
+			
+			return objs;
+		}
+
+		private void AddLoadedObjects(ICollection<IWarFoundryObject> loadedObjs, IWarFoundryFactory factory)
+		{
+			SimpleSet<IWarFoundryObject> objs;
+			loadedObjects.TryGetValue(factory, out objs);
+			
+			if (objs == null)
+			{
+				objs = new SimpleSet<IWarFoundryObject>();
+				loadedObjects.Add(factory, objs);
+			}
+				
+			objs.AddRange(loadedObjs);
+			StoreObjects(loadedObjs);
+		}
+
+		private void StoreObjects(ICollection<IWarFoundryObject> loadedObjects)
+		{
+			foreach (IWarFoundryObject loadedObject in loadedObjects)
+			{
+				if (loadedObject is GameSystem)
+				{
+					StoreGameSystem((GameSystem)loadedObject);
+				}
+				else if (loadedObject is Race)
+				{
+					StoreRace((Race)loadedObject);
+				}
+			}
+		}
+
+		protected void StoreGameSystem(GameSystem system)
+		{
+			GameSystem existingSystem = GetExistingSystemForSystem(system);
+			
+			if (existingSystem != null)
+			{				
+				if (!system.Equals(existingSystem))
+				{
+					//TODO: Raise an event to say we got a different duplicate
+					//We can't just fail, because failing is for completely unhandled files, not for objects in a file
+				}
+			}
+			else
+			{
+				DoStoreGameSystem(system);
+			}
+		}
+		
+		/// <summary>
+		/// Gets a game system that has already been loaded that duplicates the supplied game system's ID, if one exists.
+		/// </summary>
+		/// <param name="system">
+		/// The <see cref="GameSystem"/> to find pre-existing duplicates of
+		/// </param>
+		/// <returns>
+		/// <code>null</code> if no existing duplicate exists, else the duplicate <see cref="GameSystem"/>
+		/// </returns>
+		protected abstract GameSystem GetExistingSystemForSystem(GameSystem system);
+		
+		/// <summary>
+		/// Stores a GameSystem in the loader's relevant storage structure
+		/// </summary>
+		/// <param name="system">
+		/// The loaded <see cref="GameSystem"/> to store
+		/// </param>
+		protected abstract void DoStoreGameSystem(GameSystem system);
+
+		protected void StoreRace(Race race)
+		{
+			if (race.GameSystem == null)
+			{
+				throw new InvalidOperationException("Race cannot have null game system. Game system should be loaded before race.");
+			}
+			
+			DoStoreRace(race);
+		}
+		
+		/// <summary>
+		/// Performs the implementation specific storage of a race
+		/// </summary>
+		/// <param name="race">
+		/// The <see cref="Race"/> to store
+		/// </param>
+		protected abstract void DoStoreRace(Race race);
+		
+		/// <summary>
+		/// Gets all <see cref="GameSystem"/>s that are currently available, determined by those that can be loaded with the current <see cref="IWarFoundryFactory"/>s. 
+		/// </summary>
+		/// <returns>
+		/// An array of <see cref="GameSystem"/>s that are currently available.
+		/// </returns>
+		public abstract GameSystem[] GetGameSystems();
+
+		/// <summary>
+		/// Gets a single <see cref="GameSystem"/> with a given ID. 
+		/// </summary>
+		/// <param name="systemID">
+		/// The ID of the <see cref="GameSystem"/> to get, as a <see cref="System.String"/>.
+		/// </param>
+		/// <returns>
+		/// The <see cref="GameSystem"/> with the given ID, or <code>null</code> if one doesn't exist.
+		/// </returns>
+		public abstract GameSystem GetGameSystem(string systemID);
+
+		/// <summary>
+		/// Removes a loaded <see cref="GameSystem"/>. Used when a GameSystem fails to complete loading
+		/// </summary>
+		/// <param name="system">The GameSystem to remove</param>
+		protected internal abstract void RemoveGameSystem(GameSystem system);
+
+		/// <summary>
+		/// Gets an array of the races for the specified <see cref="GameSystem"/>.
+		/// </summary>
+		/// <param name="system">
+		/// The <see cref="GameSystem"/> to get the available races for.
+		/// </param>
+		/// <returns>
+		/// An array of <see cref="Race"/>s for the <see cref="GameSystem"/>
+		/// </returns>
+		public abstract Race[] GetRaces(GameSystem system);
+
+		/// <summary>
+		/// Gets a single race for a given <see cref="GameSystem"/> by ID of the race.
+		/// </summary>
+		/// <param name="system">
+		/// The <see cref="GameSystem"/> that the race is part of.
+		/// </param>
+		/// <param name="raceID">
+		/// A <see cref="System.String"/> ID for the race to load.
+		/// </param>
+		/// <returns>
+		/// A <see cref="Race"/> with the specified ID from the <see cref="GameSystem"/>, or <code>null</code> if one doesn't exist.
+		/// </returns>
+		public abstract Race GetRace(GameSystem system, string raceID);
+
+		/// <summary>
+		/// Gets a single race for a given <see cref="GameSystem"/> by the race's ID and sub-race ID.
+		/// </summary>
+		/// <param name="system">
+		/// The <see cref="GameSystem"/> that the race is part of.
+		/// </param>
+		/// <param name="raceID">
+		/// The <see cref="System.String"/> ID for the race to load.
+		/// </param>
+		/// <param name="raceSubID">
+		/// A <see cref="System.String"/>
+		/// </param>
+		/// <returns>
+		/// A <see cref="Race"/>
+		/// </returns>
+		public abstract Race GetRace(GameSystem system, string raceID, string raceSubID);
+
+		protected internal abstract void RemoveRace(Race race);
+
+		/// <summary>
+		/// Gets the IDs of all of the game systems currently available.
+		/// </summary>
+		/// <returns>
+		/// An array of <see cref="System.String"/>s representing the IDs of the game systems.
+		/// </returns>
+		public virtual string[] GetGameSystemIDs()
+		{
+			GameSystem[] systems = GetGameSystems();
+			return GetWarFoundryObjectIDs(systems);
+		}
+
+		protected string[] GetWarFoundryObjectIDs(WarFoundryObject[] objs)
+		{
+			int objCount = objs.Length;
+			string[] keys = new string[objCount];
+
+			for (int i = 0; i < objCount; i++)
+			{
+				keys[i] = objs[i].ID;
+			}
+
+			return keys;
+		}
+		
+		/// <summary>
+		/// Gets the IDs of all of the races of a specified game system.
+		/// </summary>
+		/// <param name="system">
+		/// The <see cref="GameSystem"/> to get the available races for.
+		/// </param>
+		/// <returns>
+		/// An array of <see cref="System.String"/>s representing the IDs of the races of the specified game system.
+		/// </returns>
+		public virtual string[] GetSystemRaceIDs(GameSystem system)
+		{
+			Race[] races = GetRaces(system);
+			return GetWarFoundryObjectIDs(races);
+		}
+
+		public Army LoadArmy(FileInfo file)
+		{
+			IWarFoundryFactory factory = GetArmyLoadingFactoryForFile(file);			
+			Army loadedArmy = null;
+			
+			if (factory != null)
+			{
+				ICollection<IWarFoundryObject> objs = factory.CreateObjectsFromFile(file);
+								
+				if (objs.Count == 1)
+				{
+					foreach (IWarFoundryObject systemCount in objs)
+					{
+						if (systemCount is Army)
+						{
+							loadedArmy = (Army)systemCount;
+						}
+					}
+				}
+			}
+			
+			return loadedArmy;
+		}
+
+		private IWarFoundryFactory GetArmyLoadingFactoryForFile(FileInfo file)
+		{
+			IWarFoundryFactory loadingFactory = null;
+			
+			foreach (INonNativeWarFoundryFactory factory in nonNativeFactories)
+			{
+				if (factory.CanHandleFileAsArmy(file))
+				{
+					loadingFactory = factory;
+					break;
+				}
+			}
+
+			if (loadingFactory == null)
+			{
+				foreach (INativeWarFoundryFactory factory in factories)
+				{
+					if (factory.CanHandleFileAsArmy(file))
+					{
+						loadingFactory = factory;
+						break;
+					}
+				}
+			}
+
+			return loadingFactory;
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/AbstractReplaceUnitEquipmentCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,74 @@
+// This file (AbstractReplaceUnitEquipmentCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// An abstract implementation of the core method for replacing one equipment item with another
+	/// </summary>
+	public abstract class AbstractReplaceUnitEquipmentCommand : Command
+	{
+		private SetUnitEquipmentNumericAmountCommand removeOldCommand;
+		private AbstractSetUnitEquipmentAmountCommand addNewCommand;
+
+		public AbstractReplaceUnitEquipmentCommand(Unit unit, UnitEquipmentItem oldItem, AbstractSetUnitEquipmentAmountCommand addNewEquipmentCommand)
+		{
+			//We can get away with a numeric amount here even if it is a ratio item because we're setting it to 0
+			removeOldCommand = new SetUnitEquipmentNumericAmountCommand(unit, oldItem, 0);
+			addNewCommand = addNewEquipmentCommand;
+		}
+
+		public override bool CanExecute()
+		{
+			return removeOldCommand.CanExecute() && addNewCommand.CanExecute();
+		}
+
+		public override string Description
+		{
+			get
+			{
+				return Translation.GetTranslation("replaceUnitEquipmentCommandDescription", "replace {0} with {1} for {2}", removeOldCommand.EquipItem.Name, addNewCommand.EquipItem.Name, removeOldCommand.Unit.Name);
+			}
+		}
+
+		public override string UndoDescription
+		{
+			get
+			{
+				return Translation.GetTranslation("replaceUnitEquipmentCommandUndoDescription", "replace {0} with {1} for {2}", addNewCommand.EquipItem.Name, removeOldCommand.EquipItem.Name, removeOldCommand.Unit.Name);
+			}
+		}
+
+		public override bool Execute()
+		{
+			this.Redo();
+			return true;
+		}
+
+		public override void Redo()
+		{
+			removeOldCommand.Redo();
+			addNewCommand.Redo();
+		}
+
+		public override void Undo()
+		{
+			addNewCommand.Undo();
+			removeOldCommand.Undo();
+		}
+
+		public override string Name
+		{
+			get
+			{
+				return "Replace required equipment";
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/AbstractSetUnitEquipmentAmountCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,120 @@
+//  This file (AbstractSetUnitEquipmentAmountCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+using IBBoard.WarFoundry.API.Util;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// Abstract parent class for commands that set the amount of an equipment item a unit has to a fixed numeric or ratio value
+	/// </summary>
+	public abstract class AbstractSetUnitEquipmentAmountCommand : Command
+	{
+		private Unit unit;
+		private UnitEquipmentItem equip;
+		private double oldAmount;
+		private bool oldAmountWasRatio;
+
+		public AbstractSetUnitEquipmentAmountCommand(Unit unit, UnitEquipmentItem item)
+		{
+			this.unit = unit;
+			equip = item;
+			oldAmount = UnitEquipmentUtil.GetEquipmentAmount(unit, equip);
+			oldAmountWasRatio = UnitEquipmentUtil.GetEquipmentAmountIsRatio(unit, equip);
+		}
+
+		public override bool CanExecute()
+		{
+			return (unit != null && equip != null);
+		}
+
+		public override string Description
+		{
+			get
+			{
+				return Translation.GetTranslation("setEquipmentAmountCommandDescription", "set {0} amount for {1} to {2}", equip.Name, unit.Name, GetNewAmountString());
+			}
+		}
+
+		/// <summary>
+		/// Gets the string representation for the new amount of the equipment item to take
+		/// </summary>
+		/// <returns>
+		/// the string representation for the new amount of the equipment item to take
+		/// </returns>
+		protected abstract string GetNewAmountString();
+
+		public override string UndoDescription
+		{
+			get
+			{
+				return Translation.GetTranslation("setEquipmentAmountCommandUndoDescription", "set {0} amount for {1} to {2}", equip.Name, unit.Name, GetOldAmountString());
+			}
+		}
+
+		/// <summary>
+		/// Gets the string representation for the old amount of the equipment item to take
+		/// </summary>
+		/// <returns>
+		/// the string representation for the old amount of the equipment item to take
+		/// </returns>
+		protected string GetOldAmountString()
+		{
+			return oldAmountWasRatio ? GetRatioAmountString(oldAmount, UnitEquipmentRatioSelection.CalculateNumberTaken(Unit, EquipItem, oldAmount)) : GetNumberAmountString((int)oldAmount);
+		}
+
+		protected string GetNumberAmountString(int number)
+		{
+			return Translation.GetTranslation("equipmentAmountNumber", "{0}", number);
+		}
+
+		protected string GetRatioAmountString(double amount, int number)
+		{
+			string amountString;
+			
+			if (amount == 100)
+			{
+				amountString = Translation.GetTranslation("equipmentAmountAll", "all ({1})", amount, number);
+			}
+			else
+			{
+				amountString = Translation.GetTranslation("equipmentAmountPercentage", "{0}% ({1})", amount, number);
+			}
+			
+			return amountString;
+		}
+
+		public override bool Execute()
+		{
+			this.Redo();
+			return true;
+		}
+
+		public override void Undo()
+		{
+			if (oldAmountWasRatio)
+			{
+				unit.SetEquipmentRatio(equip, oldAmount);
+			}
+			else
+			{
+				unit.SetEquipmentAmount(equip, (int)oldAmount);
+			}
+		}
+
+		public UnitEquipmentItem EquipItem
+		{
+			get { return equip; }
+		}
+
+		public Unit Unit
+		{
+			get { return unit; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/CreateAndAddUnitCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,72 @@
+// This file (CreateAndAddUnitCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	public class CreateAndAddUnitCommand : Command
+	{
+		private UnitType addedUnitType;
+		private ArmyCategory armyCat;
+		private Unit addedUnit;
+
+		public CreateAndAddUnitCommand(UnitType toAdd, ArmyCategory armyCatTo)
+		{
+			addedUnitType = toAdd;
+			armyCat = armyCatTo;
+		}
+
+		public override bool CanExecute()
+		{
+			return (addedUnitType != null && armyCat != null);
+		}
+
+		public override string Description
+		{
+			get
+			{
+				return Translation.GetTranslation("createAndAddUnitCommandDescription", "add unit of {0} to the army", addedUnitType.Name);
+			}
+		}
+
+		public override string UndoDescription
+		{
+			get
+			{
+				return Translation.GetTranslation("createAndAddUnitCommandUndoDescription", "remove unit of {0} from army", addedUnitType.Name);
+			}
+		}
+
+		public override bool Execute()
+		{
+			addedUnit = new Unit(addedUnitType, armyCat);
+			this.Redo();
+			return true;
+		}
+
+		public override void Redo()
+		{
+			armyCat.AddUnit(addedUnit);
+		}
+
+		public override void Undo()
+		{
+			armyCat.RemoveUnit(addedUnit);
+		}
+
+		public override string Name
+		{
+			get { return "Add new unit"; }
+		}
+
+		public Unit Unit
+		{
+			get { return addedUnit; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/RemoveUnitCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,68 @@
+// This file (RemoveUnitCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// Summary description for RemoveUnitCommand.
+	/// </summary>
+	public class RemoveUnitCommand : Command
+	{
+		private Unit unit;
+		private ArmyCategory cat;
+
+		public RemoveUnitCommand(Unit toRemove)
+		{
+			unit = toRemove;
+			cat = unit.Category;
+		}
+
+		public override bool CanExecute()
+		{
+			return (unit != null);
+		}
+
+		public override string Description
+		{
+			get
+			{
+				return Translation.GetTranslation("removeUnitCommandDescription", "remove {0} from the army", unit.Name);
+			}
+		}
+
+		public override string UndoDescription
+		{
+			get
+			{
+				return Translation.GetTranslation("removeUnitCommandUndoDescription", "re-add {0} to the army", unit.Name);
+			}
+		}
+
+		public override bool Execute()
+		{
+			this.Redo();
+			return true;
+		}
+
+		public override void Redo()
+		{
+			cat.RemoveUnit(unit);
+		}
+
+		public override void Undo()
+		{
+			cat.AddUnit(unit);
+		}
+
+		public override string Name
+		{
+			get { return "Remove unit"; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/ReplaceUnitEquipmentWithNumericAmountItemCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,21 @@
+//  This file (ReplaceUnitEquipmentWithNumericAmountItemCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+// 
+
+using System;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// A concrete implementation of an equipment replacing command that replaces a given equipment item with a different item that has an absolute numeric amount.
+	/// </summary>
+	public class ReplaceUnitEquipmentWithNumericAmountItemCommand : AbstractReplaceUnitEquipmentCommand
+	{	
+		public ReplaceUnitEquipmentWithNumericAmountItemCommand(Unit unit, UnitEquipmentItem oldItem, UnitEquipmentItem newItem, int newItemAmount) : base(unit, oldItem, new SetUnitEquipmentNumericAmountCommand(unit, newItem, newItemAmount))
+		{
+			//Do nothing special
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/ReplaceUnitEquipmentWithRatioAmountItemCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,21 @@
+//  This file (ReplaceUnitEquipmentWithRatioAmountItemCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+// 
+
+using System;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// A concrete implementation of an equipment replacing command that replaces a given equipment item with a different item that has a ratio/percentage amount.
+	/// </summary>
+	public class ReplaceUnitEquipmentWithRatioAmountItemCommand : AbstractReplaceUnitEquipmentCommand
+	{	
+		public ReplaceUnitEquipmentWithRatioAmountItemCommand(Unit unit, UnitEquipmentItem oldItem, UnitEquipmentItem newItem, double newItemRatio) : base(unit, oldItem, new SetUnitEquipmentRatioAmountCommand(unit, newItem, newItemRatio))
+		{
+			//Do nothing special
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/SetNameCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,69 @@
+// This file (SetNameCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// Summary description for SetNameCommand.
+	/// </summary>
+	public class SetNameCommand : Command
+	{
+		private WarFoundryObject obj;
+		private string newName, oldName;
+
+		public SetNameCommand(WarFoundryObject toRename, string name)
+		{
+			obj = toRename;
+			newName = name;
+			oldName = obj.Name;
+		}
+
+		public override bool CanExecute()
+		{
+			return (obj != null && newName != null && newName != "");
+		}
+
+		public override string Description
+		{
+			get
+			{
+				return Translation.GetTranslation("setUnitNameCommandDescription", "rename \"{0}\" to \"{1}\"", oldName, newName);
+			}
+		}
+
+		public override string UndoDescription
+		{
+			get
+			{
+				return Translation.GetTranslation("setUnitNameCommandUndoDescription", "rename \"{0}\" to \"{1}\"", newName, oldName);
+			}
+		}
+
+		public override bool Execute()
+		{
+			this.Redo();
+			return true;
+		}
+
+		public override void Redo()
+		{
+			obj.Name = newName;
+		}
+
+		public override void Undo()
+		{
+			obj.Name = oldName;
+		}
+
+		public override string Name
+		{
+			get { return "Rename item"; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/SetUnitEquipmentNumericAmountCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,39 @@
+// This file (SetUnitEquipmentNumericAmountCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// Summary description for SetUnitEquipmentNumericAmountCommand.
+	/// </summary>
+	public class SetUnitEquipmentNumericAmountCommand : AbstractSetUnitEquipmentAmountCommand
+	{
+		private int newAmount;
+		
+		public SetUnitEquipmentNumericAmountCommand(Unit unit, UnitEquipmentItem item, int amount) : base(unit, item)
+		{
+			newAmount = amount;
+		}
+
+		protected override string GetNewAmountString ()
+		{
+			return GetNumberAmountString(newAmount);
+		}
+		
+		public override void Redo()
+		{
+			Unit.SetEquipmentAmount(EquipItem, newAmount);
+		}
+
+		public override string Name
+		{
+			get { return "Set equipment amount"; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/SetUnitEquipmentRatioAmountCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,39 @@
+// This file (SetUnitEquipmentRatioAmountCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// Summary description for SetUnitEquipmentRatioAmountCommand.
+	/// </summary>
+	public class SetUnitEquipmentRatioAmountCommand : AbstractSetUnitEquipmentAmountCommand
+	{
+		private double newAmount;
+		
+		public SetUnitEquipmentRatioAmountCommand(Unit unit, UnitEquipmentItem item, double amount) : base(unit, item)
+		{
+			newAmount = amount;
+		}
+
+		protected override string GetNewAmountString ()
+		{
+			return GetRatioAmountString(newAmount, UnitEquipmentRatioSelection.CalculateNumberTaken(Unit, EquipItem, newAmount));
+		}
+
+		public override void Redo()
+		{
+			Unit.SetEquipmentRatio(EquipItem, newAmount);
+		}
+
+		public override string Name
+		{
+			get { return "Set equipment ratio"; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Commands/SetUnitSizeCommand.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,69 @@
+// This file (SetUnitSizeCommand.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.Commands;
+using IBBoard.Lang;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Commands
+{
+	/// <summary>
+	/// Summary description for SetNameCommand.
+	/// </summary>
+	public class SetUnitSizeCommand : Command
+	{
+		private Unit unit;
+		private int newSize, oldSize;
+
+		public SetUnitSizeCommand(Unit toResize, int size)
+		{
+			unit = toResize;
+			newSize = size;
+			oldSize = unit.Size;
+		}
+
+		public override bool CanExecute()
+		{
+			return (unit != null && newSize > 0 && oldSize > 0);
+		}
+
+		public override string Description
+		{
+			get
+			{
+				return Translation.GetTranslation("setUnitSizeCommandDescription", "set size of {0} to {1}", unit.Name, newSize);
+			}
+		}
+
+		public override string UndoDescription
+		{
+			get
+			{
+				return Translation.GetTranslation("setUnitSizeCommandUndoDescription", "set size of {0} to {1}", unit.Name, oldSize);
+			}
+		}
+
+		public override bool Execute()
+		{
+			this.Redo();
+			return true;
+		}
+
+		public override void Redo()
+		{
+			unit.Size = newSize;
+		}
+
+		public override void Undo()
+		{
+			unit.Size = oldSize;
+		}
+
+		public override string Name
+		{
+			get { return "Change unit size"; }
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/DefaultWarFoundryLoader.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,304 @@
+// This file (DefaultWarFoundryLoader.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API
+{
+	/// <summary>
+	/// The default implementation of a <see cref="AbstractWarFoundryLoader"/>
+	/// </summary>
+	public class DefaultWarFoundryLoader : AbstractWarFoundryLoader
+	{
+		private Dictionary<string, GameSystem> systemsTable;
+		private Dictionary<string, Dictionary<string, Dictionary<string, Race>>> racesTable; //Keys are: System, Race, SubRace
+		private bool loaded = false;
+		private bool loading = false;
+
+		public DefaultWarFoundryLoader()
+		{
+			systemsTable = new Dictionary<string,GameSystem>();
+			racesTable = new Dictionary<string,Dictionary<string,Dictionary<string,Race>>>();
+		}
+
+		protected override void PrepareForFileLoad()
+		{
+			loading = true;
+			systemsTable.Clear();
+			racesTable.Clear();
+		}
+
+		protected override void FinishFileLoad()
+		{
+			loaded = true;
+			loading = false;
+		}
+
+		protected override GameSystem GetExistingSystemForSystem(GameSystem system)
+		{
+			return DictionaryUtils.GetValue(systemsTable, system.ID.ToLower());
+		}
+
+		protected override void DoStoreGameSystem(GameSystem system)
+		{
+			systemsTable[system.ID.ToLower()] = system;
+		}
+
+		protected override void DoStoreRace(Race race)
+		{
+			Dictionary<string, Dictionary<string, Race>> systemRaces;
+			
+			string systemID = race.GameSystem.ID.ToLower();
+			racesTable.TryGetValue(systemID, out systemRaces);
+			
+			if (systemRaces == null)
+			{
+				systemRaces = new Dictionary<string,Dictionary<string,Race>>();
+				racesTable.Add(systemID, systemRaces);
+			}
+			
+			Dictionary<string, Race> subRaces;
+			systemRaces.TryGetValue(race.ID.ToLower(), out subRaces);
+			
+			if (subRaces == null)
+			{
+				subRaces = new Dictionary<string,Race>();
+				systemRaces.Add(race.ID.ToLower(), subRaces);
+			}
+			
+			string subID = race.SubID.ToLower();
+
+			if (subRaces.ContainsKey(subID))
+			{
+				Race existingRace = subRaces[subID];
+				
+				if (!race.Equals(existingRace))
+				{
+					//TODO: Raise an event to say we got a different duplicate
+					//We can't just fail, because failing is for completely unhandled files, not for objects in a file
+				}
+			}
+			else
+			{
+				subRaces.Add(race.SubID.ToLower(), race);
+			}
+		}
+
+		public override GameSystem[] GetGameSystems()
+		{
+			if (!loaded && !loading)
+			{
+				LoadFiles();
+			}
+			
+			return DictionaryUtils.ToArray<string, GameSystem>(systemsTable);
+		}
+
+		public override GameSystem GetGameSystem(string systemID)
+		{
+			if (!loaded && !loading)
+			{
+				LoadFiles();
+			}
+			
+			GameSystem system;
+			systemsTable.TryGetValue(systemID.ToLower(), out system);
+			return system;
+		}
+
+		protected internal override void RemoveGameSystem(GameSystem system)
+		{
+			systemsTable.Remove(system.ID.ToLower());
+		}
+
+		public override Race[] GetRaces(GameSystem system)
+		{
+			return GetRaces(system.ID);
+		}
+
+		/// <summary>
+		/// Gets an array of the races for a game system by ID.
+		/// </summary>
+		/// <param name="systemID">
+		/// The <see cref="System.String"/> ID of the game system to get races for
+		/// </param>
+		/// <returns>
+		/// An array of <see cref="Race"/>s for the specified game system
+		/// </returns>
+		public Race[] GetRaces(string systemID)
+		{
+			if (!loaded && !loading)
+			{
+				LoadFiles();
+			}
+			
+			systemID = systemID.ToLower();
+			Dictionary<string, Dictionary<string, Race>> system;
+			racesTable.TryGetValue(systemID, out system);
+			
+			if (system == null)
+			{
+				return new Race[0];
+			}
+
+			int count = 0;
+
+			foreach (Dictionary<string, Race> racesDict in system.Values)
+			{
+				count += racesDict.Count;
+			}
+
+			Race[] races = new Race[count];
+			int i = 0;
+
+			foreach (string raceID in system.Keys)
+			{
+				foreach (string raceSubId in system[raceID].Keys)
+				{
+					races[i++] = GetRace(systemID, raceID, raceSubId);
+				}
+			}
+
+			return races;
+		}
+
+		public override Race GetRace(GameSystem system, string raceID)
+		{
+			return GetRace(system.ID, raceID);
+		}
+
+		/// <summary>
+		/// Gets a single race for a given game system by ID of the game system and race.
+		/// </summary>
+		/// <param name="systemID">
+		/// The <see cref="System.String"/> ID of the game system that the race is part of.
+		/// </param>
+		/// <param name="raceID">
+		/// The <see cref="System.String"/> ID for the race to load.
+		/// </param>
+		/// <returns>
+		/// A <see cref="Race"/> with the specified ID from the game system with the specified ID, or <code>null</code> if there is no race or game system with those IDs.
+		/// </returns>
+		public Race GetRace(string systemID, string raceID)
+		{
+			return GetRace(systemID, raceID, "");
+		}
+
+		public override Race GetRace(GameSystem system, string raceID, string raceSubID)
+		{
+			return GetRace(system.ID, raceID, raceSubID);
+		}
+
+		/// <summary>
+		/// Gets a single race for a given game system by the game system's ID and the race's ID and sub-race ID.
+		/// </summary>
+		/// <param name="systemID">
+		/// The <see cref="System.String"/> ID of the game system that the race is part of.
+		/// </param>
+		/// <param name="raceID">
+		/// The <see cref="System.String"/> ID for the race to load.
+		/// </param>
+		/// <param name="raceSubID">
+		/// A <see cref="System.String"/>
+		/// </param>
+		/// <returns>
+		/// A <see cref="Race"/>
+		/// </returns>
+		public Race GetRace(string systemID, string raceID, string raceSubID)
+		{
+			if (!loaded && !loading)
+			{
+				LoadFiles();
+			}
+			
+			Race race = null;
+			
+			Dictionary<string, Race> subraces = GetRaceTable(systemID, raceID);
+
+			if (subraces != null)
+			{
+				subraces.TryGetValue(raceSubID.ToLower(), out race);
+			}
+			
+			return race;
+		}
+
+		private Dictionary<string, Race> GetRaceTable(string systemID, string raceID)
+		{
+			Dictionary<string, Dictionary<string, Race>> races;
+			racesTable.TryGetValue(systemID.ToLower(), out races);
+			Dictionary<string, Race> subraces = null;
+
+			if (races != null)
+			{
+				races.TryGetValue(raceID.ToLower(), out subraces);
+			}
+
+			return subraces;
+		}
+
+		protected internal override void RemoveRace(Race race)
+		{
+			Dictionary<string, Race> subraces = GetRaceTable(race.GameSystem.ID, race.ID);
+
+			if (subraces != null)
+			{
+				subraces.Remove(race.SubID.ToLower());
+			}
+		}
+
+		public override string[] GetGameSystemIDs()
+		{
+			if (!loaded && !loading)
+			{
+				LoadFiles();
+			}
+
+			return DictionaryUtils.ToKeyArray(systemsTable);
+		}
+
+		public override string[] GetSystemRaceIDs(GameSystem system)
+		{
+			return GetSystemRaceIDs(system.ID);
+		}
+
+		/// <summary>
+		/// Gets the IDs of all of the races of a specified game system.
+		/// </summary>
+		/// <param name="systemID">
+		/// The <see cref="System.String"/> ID of the game system to get the available races for.
+		/// </param>
+		/// <returns>
+		/// An array of <see cref="System.String"/>s representing the IDs of the races of the specified game system.
+		/// </returns>
+		public string[] GetSystemRaceIDs(string systemID)
+		{
+			if (!loaded && !loading)
+			{
+				LoadFiles();
+			}
+
+			Dictionary<string, Dictionary<string, Race>> races = racesTable[systemID.ToLower()];
+
+			if (races == null)
+			{
+				return new string[0];
+			}
+			else
+			{
+				string[] keys = new string[races.Keys.Count];
+				int i = 0;
+
+				foreach (string key in races.Keys)
+				{
+					keys[i++] = key;
+				}
+
+				return keys;
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Delegates.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,23 @@
+// This file (Delegates.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API
+{
+	public delegate void ObjectChangedDelegate(WarFoundryObject oldValue, WarFoundryObject newValue);
+	public delegate void ArmyChangedDelegate(Army oldValue, Army newValue);
+	public delegate void GameSystemChangedDelegate(GameSystem oldValue, GameSystem newValue);
+	public delegate void ObjectAddDelegate(WarFoundryObject val);
+	public delegate void ObjectRemoveDelegate(WarFoundryObject val);	
+	public delegate void UnitAddDelegate(Unit val);
+	public delegate void UnitRemoveDelegate(Unit val);
+	public delegate void ObjectUpdatedDelegate(WarFoundryObject val, string updatedValName);
+	public delegate void DoubleValChangedDelegate(WarFoundryObject obj, double oldValue, double newValue);
+	public delegate void FloatValChangedDelegate(WarFoundryObject obj, float oldValue, float newValue);
+	public delegate void StringValChangedDelegate(WarFoundryObject obj, string oldValue, string newValue);
+	public delegate void IntValChangedDelegate(WarFoundryObject obj, int oldValue, int newValue);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Exporters/IWarFoundryExporter.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,26 @@
+// This file (IWarFoundryExporter.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Exporters
+{
+	/// <summary>
+	/// An interface to be implemented by classes that export WarFoundry armies to other formats than "saved armies" (e.g. HTML)
+	/// </summary>
+	public interface IWarFoundryExporter
+	{
+		/// <summary>
+		/// Exports the army to the specified path
+		/// </summary>
+		/// <param name="army">
+		/// The <see cref="Army"/> to export
+		/// </param>
+		/// <param name="path">
+		/// The file path to export to
+		/// </param>
+		void ExportArmy(Army army, string path);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Exporters/WarFoundryHtmlExporter.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,396 @@
+// This file (WarFoundryHtmlExporter.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Xml.Schema;
+using IBBoard.Lang;
+using IBBoard.Xml;
+using IBBoard.WarFoundry.API.Objects;
+using IBBoard.WarFoundry.API.Util;
+
+namespace IBBoard.WarFoundry.API.Exporters
+{
+	/// <summary>
+	/// Custom exporter that exports an army as a basic HTML file
+	/// </summary>
+	public class WarFoundryHtmlExporter : IWarFoundryExporter
+	{
+		private static WarFoundryHtmlExporter exporter;
+		private delegate string GetStatCellTextDelegate(Stat stat);
+		
+		public static WarFoundryHtmlExporter GetDefault()
+		{
+			if (exporter == null)
+			{
+				exporter = new WarFoundryHtmlExporter();
+			}
+			
+			return exporter;
+		}
+		
+		private WarFoundryHtmlExporter()
+		{
+			//Hide constructor
+		}
+		
+		public void ExportArmy(Army army, string path)
+		{
+			XmlDocument doc = new XmlDocument();
+			CustomXmlResolver resolver = new CustomXmlResolver();
+			resolver.AddMapping("-//W3C//DTD XHTML 1.0 Strict//EN", new Uri("file://" + IBBoard.Constants.ExecutablePath + "/schemas/xhtml1-strict.dtd"));
+			doc.XmlResolver = resolver;
+			doc.AppendChild(doc.CreateDocumentType("html", "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", null));
+			XmlElement html = doc.CreateElement("html");
+			doc.AppendChild(html);
+			XmlElement head = doc.CreateElement("head");
+			html.AppendChild(head);
+			XmlElement title = doc.CreateElement("title");
+			title.InnerXml = army.Name;
+			head.AppendChild(title);
+			XmlElement metaCharset = doc.CreateElement("meta");
+			metaCharset.SetAttribute("http-equiv", "Content-Type");
+			metaCharset.SetAttribute("content", "text/html;charset=UTF-8");
+			head.AppendChild(metaCharset);
+			XmlElement style = doc.CreateElement("style");
+			style.InnerText = "table, th, td { border: 1px solid #000; border-spacing: 0; border-collapse: collapse; margin: 0 }\n"
+				+"table table { width: 100%; border-width: 0; margin: -2px }\n"
+				+"table table td { border-width:0 1px }";
+			head.AppendChild(style);
+			XmlElement body = doc.CreateElement("body");
+			html.AppendChild(body);
+			XmlElement header = doc.CreateElement("h1");
+			header.InnerText = Translation.GetTranslation("armyHtmlOutputBodyHeader", "{0} - {1}pts", army.Name, army.Points);
+			body.AppendChild(header);
+			
+			foreach (XmlElement table in CreateTables(army, doc))
+			{
+				if (!IsTableOnlyHeader(table))
+				{
+					body.AppendChild(table);
+				}
+			}
+			
+			StreamWriter writer = new StreamWriter(path, false);
+			
+			try
+			{
+				writer.Write(doc.OuterXml);
+			}
+			finally
+			{
+				writer.Close();
+			}
+		}
+
+		private bool IsTableOnlyHeader(XmlElement table)
+		{
+			return table.ChildNodes.Count == 1;
+		}
+		
+		private XmlElement[] CreateTables(Army army, XmlDocument doc)
+		{
+			Dictionary<string, XmlElement> tables = new Dictionary<string, XmlElement>();
+			
+			foreach (SystemStats statSets in army.GameSystem.SystemStats)
+			{
+				tables[statSets.ID] = CreateTable(statSets, doc);
+			}
+			
+			foreach (Unit unit in army.GetUnits())
+			{
+				CreateUnitRow(unit, tables[GetFirstStatType(unit)]);
+			}
+			
+			return DictionaryUtils.ToArray(tables);
+		}
+
+		private static string GetFirstStatType(Unit unit)
+		{
+			string[] unitStatIDs = unit.UnitStatsArrayIDs;
+			return GetFirstStatType(unitStatIDs);
+		}
+		
+		public static string GetFirstStatType(string[] unitStatIDs)
+		{
+			return unitStatIDs[0];
+		}
+		
+		private XmlElement CreateTable(SystemStats stats, XmlDocument doc)
+		{
+			XmlElement table = doc.CreateElement("table");
+			XmlElement headerRow = doc.CreateElement("tr");
+			table.AppendChild(headerRow);
+			XmlElement name = doc.CreateElement("th");
+			name.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitName", "name");
+			headerRow.AppendChild(name);
+			
+			XmlElement unitTypeName = doc.CreateElement("th");
+			unitTypeName.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitTypeName", "type name");
+			headerRow.AppendChild(unitTypeName);
+			
+			foreach (StatSlot stat in stats.StatSlots)
+			{
+				XmlElement statHeader = doc.CreateElement("th");
+				statHeader.InnerText = stat.Name;
+				headerRow.AppendChild(statHeader);
+			}
+			
+			XmlElement notes = doc.CreateElement("th");
+			notes.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitNotes", "name");;
+			headerRow.AppendChild(notes);
+			
+			XmlElement points = doc.CreateElement("th");
+			points.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitPoints", "name");;
+			headerRow.AppendChild(points);
+			
+			return table;
+		}
+		
+		private XmlElement CreateUnitRow(Unit unit, XmlElement tableElem)
+		{
+			XmlDocument doc = tableElem.OwnerDocument;
+			XmlElement row = doc.CreateElement("tr");
+			tableElem.AppendChild(row);
+			Stat[][] memberStats = unit.UnitStatsArraysWithName;
+			string[] statTypeIDs = unit.UnitStatsArrayIDs;
+			string defaultStatType = GetFirstStatType(statTypeIDs);
+			int statRowCount = 0;
+			bool hasOther = false;
+			
+			foreach (string statTypeID in statTypeIDs)
+			{
+				if (statTypeID.Equals(defaultStatType))
+				{
+					statRowCount++;
+				}
+				else if (!hasOther)
+				{
+					statRowCount++;
+					hasOther = true;
+				}
+			}
+			
+			XmlElement name = doc.CreateElement("td");
+			name.InnerText = unit.Name;
+			SetRowSpan(name, statRowCount);
+			row.AppendChild(name);
+			CreateStatsBlock(row, memberStats, statTypeIDs);
+
+			StringBuilder sb = new StringBuilder();
+			UnitEquipmentItem[] unitEquipment = unit.GetEquipment();
+			
+			if (unitEquipment.Length > 0)
+			{
+				bool addSeparator = false;
+				
+				foreach (UnitEquipmentItem equip in unitEquipment)
+				{
+					if (!addSeparator)
+					{
+						addSeparator = true;
+					}
+					else
+					{
+						sb.Append(", ");
+					}
+
+					string amountString;
+					double amount = UnitEquipmentUtil.GetEquipmentAmount(unit, equip);
+
+					if (UnitEquipmentUtil.GetEquipmentAmountIsRatio(unit, equip))
+					{
+
+						if (amount == 100)
+						{
+							amountString = GetEquipmentAmountAllTranslation(unit);
+						}
+						else
+						{
+							int number = UnitEquipmentUtil.GetEquipmentAmountTaken(unit, equip);
+							amountString = GetEquipmentAmountRatioTranslation(amount, number);
+						}
+					}
+					else
+					{
+						if (amount == -1)
+						{
+							amountString = GetEquipmentAmountAllTranslation(unit);
+						}
+						else
+						{
+							amountString = GetEquipmentAmountNumberTranslation((int)amount);
+						}
+					}
+
+					sb.Append(Translation.GetTranslation("armyHtmlExportEquipAmountRatio", "{0} for {1}", equip.Name, amountString));
+				}
+				
+				sb.Append(". ");
+			}
+			
+			ICollection<Ability> abilities = unit.Abilities;
+			
+			if (abilities.Count > 0)
+			{
+				bool addSeparator = false;
+				
+				foreach (Ability ability in abilities)
+				{
+					if (!addSeparator)
+					{
+						addSeparator = true;
+					}
+					else
+					{
+						sb.Append(", ");
+					}
+					
+					sb.Append(ability.Name);
+				}
+				
+				sb.Append(". ");
+			}
+			
+			XmlElement notes = doc.CreateElement("td");
+			notes.InnerText = sb.ToString();
+			SetRowSpan(notes, statRowCount);
+			row.AppendChild(notes);
+			
+			XmlElement points = doc.CreateElement("td");
+			points.InnerText = unit.Points.ToString();
+			SetRowSpan(points, statRowCount);
+			row.AppendChild(points);
+			
+			return row;
+		}
+		
+		private static void SetRowSpan(XmlElement xmlElement, int statRowCount)
+		{
+			if (statRowCount > 1)
+			{
+				xmlElement.SetAttribute("rowspan", statRowCount.ToString());
+			}
+		}
+		
+		private void CreateStatsBlock(XmlElement unitRow, Stat[][] memberStats, string[] statTypeIDs)
+		{
+			XmlDocument doc = unitRow.OwnerDocument;
+			string defaultStatType = GetFirstStatType(statTypeIDs);
+			
+			Stat[] defaultStatLine = memberStats[0];
+			int defaultStatLineCount = defaultStatLine.Length;
+			AddStatCell(defaultStatLine[0].SlotValueString, unitRow);
+			
+			for (int i = 1; i < defaultStatLineCount; i++)
+			{
+				string statText = GetDefaultStatCellText(defaultStatLine[i]);
+				AddStatCell(statText, unitRow);
+			}
+			
+			int statCount = statTypeIDs.Length;
+			
+			if (statCount > 1)
+			{
+				XmlElement unitTable = (XmlElement)unitRow.ParentNode;
+				Dictionary<string, XmlElement> statParents = CreateStatsParentElements(statTypeIDs, unitTable);
+				
+				for (int i = 1; i < statCount; i++)
+				{
+					Stat[] statLine = memberStats[i];
+					string statTypeID = statTypeIDs[i];
+					XmlElement tableElement = DictionaryUtils.GetValue(statParents, statTypeID);
+					int statLineCount = statLine.Length;
+					XmlElement statRow = doc.CreateElement("tr");
+					tableElement.AppendChild(statRow);
+					GetStatCellTextDelegate statCellTextDelegate = (statTypeID.Equals(defaultStatType) ? new GetStatCellTextDelegate(GetDefaultStatCellText) : new GetStatCellTextDelegate(GetOtherStatCellText));
+					AddStatCell(statLine[0].SlotValueString, statRow);
+				
+					for (int j = 1; j < statLineCount; j++)
+					{
+						string statText = statCellTextDelegate(statLine[j]);
+						AddStatCell(statText, statRow);
+					}
+				}
+				
+				if (statParents.Count > 1)
+				{
+					AddOtherUnitStatTables(statParents, unitTable, defaultStatLineCount);
+				}
+			}
+		}
+		
+		private static void AddOtherUnitStatTables(Dictionary<string, XmlElement> statParents, XmlElement unitTable, int defaultStatLineCount)
+		{
+			XmlDocument doc = unitTable.OwnerDocument;
+			XmlElement otherStatsRow = doc.CreateElement("tr");
+			unitTable.AppendChild(otherStatsRow);
+			XmlElement otherStatsCell = doc.CreateElement("td");
+			otherStatsCell.SetAttribute("colspan", defaultStatLineCount.ToString());
+			otherStatsRow.AppendChild(otherStatsCell);
+			
+			foreach (XmlElement tableElem in statParents.Values)
+			{
+				if (tableElem != unitTable)
+				{
+					otherStatsCell.AppendChild(tableElem);
+				}
+			}
+		}
+
+		private Dictionary<string, XmlElement> CreateStatsParentElements(string[] statTypeIDs, XmlElement parentTable)
+		{
+			Dictionary<string, XmlElement> statParents = new Dictionary<string, XmlElement>();
+			XmlDocument doc = parentTable.OwnerDocument;
+			string defaultStatTypeID = GetFirstStatType(statTypeIDs);
+			statParents[defaultStatTypeID] = parentTable;
+			
+			foreach (string statTypeID in statTypeIDs)
+			{
+				if (!statParents.ContainsKey(statTypeID))
+				{
+					XmlElement tableElement = doc.CreateElement("table");
+					statParents[statTypeID] = tableElement;
+				}
+			}
+			
+			return statParents;
+		}
+
+		private string GetDefaultStatCellText(Stat stat)
+		{
+			return Translation.GetTranslation("armyHtmlExportDefaultStatCellText", "{0}", stat.SlotValueString, stat.ParentSlotName);
+		}
+
+		private string GetOtherStatCellText(Stat stat)
+		{
+			return Translation.GetTranslation("armyHtmlExportOtherStatCellText", "{1}: {0}", stat.SlotValueString, stat.ParentSlotName);
+		}
+		
+		private static void AddStatCell(string statValue, XmlElement row)
+		{
+			XmlElement statCell = row.OwnerDocument.CreateElement("td");
+			statCell.InnerText = statValue;
+			row.AppendChild(statCell);
+		}
+		
+		private string GetEquipmentAmountRatioTranslation (double amount, int number)
+		{
+			return Translation.GetTranslation ("armyHtmlExportEquipAmountPercentage", "{0}% ({1})", amount, number);
+		}
+		
+		private string GetEquipmentAmountNumberTranslation(int amount)
+		{
+			return Translation.GetTranslation("armyHtmlExportEquipAmountNumber", "{0}", amount);
+		}
+		
+		private string GetEquipmentAmountAllTranslation(Unit unit)
+		{
+			return Translation.GetTranslation("armyHtmlExportEquipAmountAll", "all ({1})", 100, unit.Size);
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/AbstractNativeWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,194 @@
+// This file (AbstractNativeWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.IO;
+using System.Xml;
+using System.Xml.Schema;
+using System.Collections.Generic;
+using System.Text;
+using IBBoard;
+using IBBoard.IO;
+using IBBoard.Lang;
+using IBBoard.Logging;
+using IBBoard.Xml;
+using IBBoard.WarFoundry.API.Objects;
+using ICSharpCode.SharpZipLib.Zip;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	/// <summary>
+	/// Base abstract class for all factories that load native WarFoundry data.
+	/// </summary>
+	public abstract class AbstractNativeWarFoundryFactory : AbstractWarFoundryFactory<ZipFile>, INativeWarFoundryFactory
+	{				
+		protected AbstractNativeWarFoundryFactory()
+		{
+			//Do nothing - just make the constructor non-public
+		}
+				
+		protected override ZipFile GetFileAsSupportedType (FileInfo file)
+		{
+			ZipFile zip = null;
+			
+			try
+			{
+				zip = new ZipFile(file.FullName);
+			}
+			catch(ZipException)
+			{
+				//Silently dispose as per spec for the method
+			}
+			catch (IOException)
+			{
+				//Silently dispose as per spec for the method
+			}
+			
+			return zip;
+		}
+		
+		protected override bool CheckCanHandleFileFormat (ZipFile file)
+		{	
+			return CheckCanHandleFileAsGameSystem(file) || CheckCanHandleFileAsRace(file) || CheckCanHandleFileAsArmy(file); 
+		}
+		
+		protected override bool CheckCanHandleFileAsGameSystem(ZipFile file)
+		{
+			return CheckCanFindSystemFileContent(file);
+		}
+		
+		protected abstract bool CheckCanFindSystemFileContent(ZipFile file);
+		
+		protected override bool CheckCanHandleFileAsRace(ZipFile file)
+		{
+			return CheckCanFindRaceFileContent(file);
+		}
+		
+		protected abstract bool CheckCanFindRaceFileContent(ZipFile file);
+		
+		protected override bool CheckCanHandleFileAsArmy(ZipFile file)
+		{
+			return CheckCanFindArmyFileContent(file);
+		}
+		
+		protected abstract bool CheckCanFindArmyFileContent(ZipFile file);
+		
+		protected override ICollection<IWarFoundryObject> DoCreateObjectsFromFile (ZipFile file)
+		{
+			ICollection<IWarFoundryObject> objects = new List<IWarFoundryObject>();
+
+			try
+			{
+				if (CheckCanFindSystemFileContent(file))
+				{
+					foreach (GameSystem system in CreateGameSystemsFromFile(file))
+					{
+						OnGameSystemLoaded(system);
+						objects.Add(system);
+					}
+				}
+				
+				if (CheckCanFindRaceFileContent(file))
+				{
+					foreach(Race race in CreateRacesFromFile(file))
+					{
+						OnRaceLoaded(race);
+						objects.Add(race);
+					}
+				}
+				
+				if (CheckCanFindArmyFileContent(file))
+				{
+					foreach (Army army in CreateArmiesFromFile(file))
+					{
+						OnArmyLoaded(army);
+						objects.Add(army);
+					}
+				}
+			}
+			finally
+			{
+				file.Close();
+			}
+			
+			return objects;
+		}
+		
+		protected ICollection<Army> CreateArmiesFromFile(ZipFile file)
+		{
+			ICollection<ZipEntry> dataStreams = GetArmyZipEntries(file);
+			ICollection<Army> armies = new List<Army>();
+
+			foreach (ZipEntry entry in dataStreams)
+			{
+				using (Stream dataStream = file.GetInputStream(entry))
+				{
+				armies.Add(CreateArmyFromStream(file, dataStream));
+				}
+			}
+			
+			return armies;
+		}
+		
+		protected abstract ICollection<ZipEntry> GetArmyZipEntries(ZipFile file);
+		protected abstract Army CreateArmyFromStream(ZipFile file, Stream dataStream);
+		
+		protected ICollection<Race> CreateRacesFromFile(ZipFile file)
+		{
+			ICollection<ZipEntry> dataStreams = GetRaceZipEntries(file);
+			ICollection<Race> races = new List<Race>();
+
+			foreach (ZipEntry entry in dataStreams)
+			{					
+				using (Stream dataStream = file.GetInputStream(entry))
+				{
+					races.Add(CreateRaceFromStream(file, dataStream));
+				}
+			}
+			
+			return races;
+		}
+		
+		protected abstract ICollection<ZipEntry> GetRaceZipEntries(ZipFile file);
+		protected abstract Race CreateRaceFromStream(ZipFile file, Stream dataStream);
+		
+		protected ICollection<GameSystem> CreateGameSystemsFromFile(ZipFile file)
+		{
+			ICollection<ZipEntry> dataStreams = GetGameSystemZipEntries(file);
+			ICollection<GameSystem> systems = new List<GameSystem>();
+
+			foreach (ZipEntry entry in dataStreams)
+			{
+				using (Stream dataStream = file.GetInputStream(entry))
+				{
+					systems.Add(CreateGameSystemFromStream(file, dataStream));
+				}
+			}
+			
+			return systems;
+		}
+		
+		protected abstract ICollection<ZipEntry> GetGameSystemZipEntries(ZipFile file);
+		protected abstract GameSystem CreateGameSystemFromStream(ZipFile file, Stream dataStream);
+		
+		public override bool Equals (object o)
+		{
+			if (o == this)
+			{
+				return true;
+			}
+			else if (o == null || !(this.GetType().Equals(o.GetType())))
+			{
+				return false;
+			}
+			
+			return true;
+		}
+		
+		public override int GetHashCode ()
+		{
+			return GetType().FullName.GetHashCode();
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/AbstractNonNativeFileExtensionWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,85 @@
+// This file (AbstractNonNativeFileExtensionWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using IBBoard.Logging;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories
+{	
+	public abstract class AbstractNonNativeFileExtensionWarFoundryFactory : AbstractNonNativeWarFoundryFactory<FileInfo>
+	{
+		protected abstract string ArmyFileExtension { get; }
+		protected abstract string RaceFileExtension { get; }
+		protected abstract string GameSystemFileExtension { get; }
+		
+		protected override bool CheckCanHandleFileFormat (FileInfo file)
+		{
+			return CheckCanHandleFileAsArmy(file) || CheckCanHandleFileAsRace(file) || CheckCanHandleFileAsGameSystem(file);
+		}
+		
+		protected override bool CheckCanHandleFileAsArmy(FileInfo file)
+		{
+			return ArmyFileExtension!=null && file.Name.ToLower().EndsWith(ArmyFileExtension);
+		}
+		
+		protected override bool CheckCanHandleFileAsRace(FileInfo file)
+		{
+			return RaceFileExtension!=null && file.Name.ToLower().EndsWith(RaceFileExtension);
+		}
+		
+		protected override bool CheckCanHandleFileAsGameSystem(FileInfo file)
+		{
+			return GameSystemFileExtension!=null && file.Name.ToLower().EndsWith(GameSystemFileExtension);
+		}
+		
+		protected override FileInfo GetFileAsSupportedType (FileInfo file)
+		{
+			return file;
+		}		
+		
+		protected abstract Army CreateArmyFromFile(FileInfo file);
+		protected abstract Race CreateRaceFromFile(FileInfo file);
+		protected abstract GameSystem CreateGameSystemFromFile(FileInfo file);
+		
+		protected override ICollection<IWarFoundryObject> DoCreateObjectsFromFile (FileInfo file)
+		{
+			IWarFoundryObject obj = null;
+			
+			if (CheckCanHandleFileAsGameSystem(file))
+			{
+				GameSystem gameSystem = CreateGameSystemFromFile (file);
+				OnGameSystemLoaded(gameSystem);
+				obj = gameSystem;
+			}
+			else if (CheckCanHandleFileAsRace(file))
+			{
+				Race race = CreateRaceFromFile (file);
+				OnRaceLoaded(race);
+				obj = race;
+			}
+			else if (CheckCanHandleFileAsArmy(file))
+			{
+				Army army = CreateArmyFromFile (file);
+				OnArmyLoaded(army);
+				obj = army;
+			}
+			else
+			{
+				LogNotifier.Warn(GetType(), "Failed trying to create from "+file.FullName+" - not a Race, Army or GameSystem");
+			}
+			
+			ICollection<IWarFoundryObject> objects = new List<IWarFoundryObject>();
+			
+			if (obj != null)
+			{
+				objects.Add(obj);
+			}
+			
+			return objects;
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/AbstractNonNativeWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,15 @@
+// This file (AbstractNonNativeWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.IO;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	public abstract class AbstractNonNativeWarFoundryFactory<FILE_TYPE> : AbstractWarFoundryFactory<FILE_TYPE>, INonNativeWarFoundryFactory
+	{
+		public abstract string NonNativeDataType { get;	}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/AbstractWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,181 @@
+// This file (AbstractWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	public abstract class AbstractWarFoundryFactory<FILE_TYPE> : IWarFoundryFactory
+	{		
+		public event SingleArgMethodInvoker<GameSystem> GameSystemLoaded;
+		
+		public event SingleArgMethodInvoker<Race> RaceLoaded;
+		
+		public event SingleArgMethodInvoker<Army> ArmyLoaded;
+		
+		public virtual void CompleteLoading(IWarFoundryStagedLoadObject obj)
+		{
+			//Pretend we've fully loaded, as this will probably be standard for non-native factories and some native factories
+			obj.SetAsFullyLoaded();
+		}
+
+		public bool CanHandleFileFormat (FileInfo file)
+		{
+			FILE_TYPE typedFile = GetFileAsSupportedType(file);
+			bool canHandle = typedFile != null && CheckCanHandleFileFormat(typedFile);
+
+			if (typedFile != null)
+			{
+				CleanUpFileAsSupportedType(typedFile);
+			}
+
+			return canHandle;
+		}
+
+		public bool CanHandleFileAsRace(FileInfo file)
+		{
+			FILE_TYPE typedFile = GetFileAsSupportedType(file);
+			bool canHandle = typedFile != null && CheckCanHandleFileAsRace(typedFile);
+
+			if (typedFile != null)
+			{
+				CleanUpFileAsSupportedType(typedFile);
+			}
+
+			return canHandle;
+		}
+
+		public bool CanHandleFileAsGameSystem(FileInfo file)
+		{
+			FILE_TYPE typedFile = GetFileAsSupportedType(file);
+			bool canHandle = typedFile != null && CheckCanHandleFileAsGameSystem(typedFile);
+
+			if (typedFile != null)
+			{
+				CleanUpFileAsSupportedType(typedFile);
+			}
+
+			return canHandle;
+		}
+
+		public bool CanHandleFileAsArmy(FileInfo file)
+		{
+			FILE_TYPE typedFile = GetFileAsSupportedType(file);
+			bool canHandle = typedFile != null && CheckCanHandleFileAsArmy(typedFile);
+
+			if (typedFile != null)
+			{
+				CleanUpFileAsSupportedType(typedFile);
+			}
+
+			return canHandle;
+		}
+
+		protected virtual void CleanUpFileAsSupportedType(FILE_TYPE typedFile)
+		{
+			//Do nothing by default
+		}
+		
+		/// <summary>
+		/// Converts the <see cref="FileInfo"/> object in to the appropriate type for this class so that it can perform its checks. If no conversion is required (the test can be performed on a <see cref="FileInfo"/> object) the object should be returned with no modification. 
+		/// If the file is not of supported type the <code>null</code> should be returned.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> to get the supported source object from.
+		/// </param>
+		/// <returns>
+		/// An object of type <see cref="FILE_TYPE"/> that has been converted from the input <see cref="FileInfo"/> object, or <code>null</code> if the conversion cannot be made.
+		/// </returns>
+		protected abstract FILE_TYPE GetFileAsSupportedType(FileInfo file);
+		
+		/// <summary>
+		/// Checks whether the factory thinks it can load data from the file in its paramaterised type.
+		/// </summary>
+		/// <param name="file">
+		/// An object of the converted <see cref="FILE_TYPE"/> to check support for
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the factory thinks it can support the file, else <code>false</code>
+		/// </returns>
+		protected abstract bool CheckCanHandleFileFormat(FILE_TYPE file);
+
+		/// <summary>
+		/// Checks whether the factory thinks it can load data from the file in its paramaterised type as a Race object.
+		/// </summary>
+		/// <param name="file">
+		/// An object of the converted <see cref="FILE_TYPE"/> to check support for
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the factory thinks it can support the file as a Race, else <code>false</code>
+		/// </returns>
+		protected abstract bool CheckCanHandleFileAsRace(FILE_TYPE file);
+
+		/// <summary>
+		/// Checks whether the factory thinks it can load data from the file in its paramaterised type as a GameSystem object.
+		/// </summary>
+		/// <param name="file">
+		/// An object of the converted <see cref="FILE_TYPE"/> to check support for
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the factory thinks it can support the file as a GameSystem, else <code>false</code>
+		/// </returns>
+		protected abstract bool CheckCanHandleFileAsGameSystem(FILE_TYPE file);
+
+		/// <summary>
+		/// Checks whether the factory thinks it can load data from the file in its paramaterised type as an Army object.
+		/// </summary>
+		/// <param name="file">
+		/// An object of the converted <see cref="FILE_TYPE"/> to check support for
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the factory thinks it can support the file as a Army, else <code>false</code>
+		/// </returns>
+		protected abstract bool CheckCanHandleFileAsArmy(FILE_TYPE file);
+		
+		
+		public ICollection<IWarFoundryObject> CreateObjectsFromFile(FileInfo file)
+		{
+			return DoCreateObjectsFromFile(GetFileAsSupportedType(file));
+		}
+		
+		/// <summary>
+		/// Reads the data from the supplied converted <see cref="FILE_TYPE"/> object and returns it as a collection of loadable objects.
+		/// In addition, the method fires the appropriate XxxLoaded event for each object created for asynchronous use.
+		/// </summary>
+		/// <param name="file">
+		/// An object of the converted <see cref="FILE_TYPE"/> for the file to load data from
+		/// </param>
+		/// <returns>
+		/// A <see cref="ICollection`1"/> of <see cref="IWarFoundryObject"/>s that were loaded from the file object
+		/// </returns>
+		protected abstract ICollection<IWarFoundryObject> DoCreateObjectsFromFile(FILE_TYPE file);
+		
+		protected void OnGameSystemLoaded(GameSystem system)
+		{
+			if (GameSystemLoaded != null)
+			{
+				GameSystemLoaded(system);
+			}
+		}
+		
+		protected void OnRaceLoaded(Race race)
+		{
+			if (RaceLoaded != null)
+			{
+				RaceLoaded(race);
+			}
+		}
+		
+		protected void OnArmyLoaded(Army army)
+		{
+			if (ArmyLoaded != null)
+			{
+				ArmyLoaded(army);
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/DummyWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,59 @@
+//  This file (DummyWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2010 IBBoard
+// 
+//  The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using IBBoard.WarFoundry.API.Factories;
+using IBBoard.WarFoundry.API.Objects;
+using System.IO;
+using System.Collections.Generic;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	///<summary>
+	///A dummy factory for use with <see cref="WarFoundryStagedLoadingObject"/>s that implements the bare minimum of the methods but won't load anything
+	///</summary>
+	public class DummyWarFoundryFactory : IWarFoundryFactory
+	{
+		public event SingleArgMethodInvoker<GameSystem> GameSystemLoaded;
+
+		public event SingleArgMethodInvoker<Race> RaceLoaded;
+
+		public event SingleArgMethodInvoker<Army> ArmyLoaded;
+		
+		public DummyWarFoundryFactory()
+		{
+			//Public constructor
+		}
+
+		public void CompleteLoading(IWarFoundryStagedLoadObject obj)
+		{
+			obj.SetAsFullyLoaded();
+		}
+
+		public bool CanHandleFileFormat(FileInfo file)
+		{
+			return false;
+		}
+
+		public bool CanHandleFileAsRace(FileInfo file)
+		{
+			return false;
+		}
+
+		public bool CanHandleFileAsGameSystem(FileInfo file)
+		{
+			return false;
+		}
+
+		public bool CanHandleFileAsArmy(FileInfo file)
+		{
+			return false;
+		}
+
+		public ICollection<IWarFoundryObject> CreateObjectsFromFile(FileInfo file)
+		{
+			return new List<IWarFoundryObject>();
+		}
+	}
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/INativeWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,13 @@
+// This file (INativeWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	public interface INativeWarFoundryFactory : IWarFoundryFactory
+	{
+		//Marker interface
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/INonNativeWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,13 @@
+// This file (INonNativeWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	public interface INonNativeWarFoundryFactory : IWarFoundryFactory
+	{
+		string NonNativeDataType { get; } 
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/IWarFoundryFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,86 @@
+// This file (IWarFoundryFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	public interface IWarFoundryFactory
+	{		
+		event SingleArgMethodInvoker<GameSystem> GameSystemLoaded;
+		
+		event SingleArgMethodInvoker<Race> RaceLoaded;
+		
+		event SingleArgMethodInvoker<Army> ArmyLoaded;
+		
+		/// <summary>
+		/// Completes the loading of an object if it is loaded in stages.
+		/// </summary>
+		/// <param name="obj">
+		/// The <see cref="IWarFoundryStagedLoadObject"/> that should be fully loaded.
+		/// </param>
+		void CompleteLoading(IWarFoundryStagedLoadObject obj);
+		
+		/// <summary>
+		/// Checks if the factory thinks it can handle the supplied file. Checks can be performed on file extension or some basic check of file content, or some other method.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> for the file to check support for.
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the file appears to be supported for loading by this factory, else returns <code>false</code>
+		/// </returns>
+		bool CanHandleFileFormat(FileInfo file);
+
+		/// <summary>
+		/// Checks if the factory thinks it can handle the supplied file as a Race. Checks can be performed on file extension or some basic check of file content, or some other method.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> for the file to check support for as a file containing Race information.
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the file appears to be supported for loading by this factory as a Race, else returns <code>false</code>
+		/// </returns>
+		bool CanHandleFileAsRace(FileInfo file);
+
+		/// <summary>
+		/// Checks if the factory thinks it can handle the supplied file as a GameSystem. Checks can be performed on file extension or some basic check of file content, or some other method.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> for the file to check support for as a file containing GameSystem information.
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the file appears to be supported for loading by this factory as a GameSystem, else returns <code>false</code>
+		/// </returns>
+		bool CanHandleFileAsGameSystem(FileInfo file);
+
+		/// <summary>
+		/// Checks if the factory thinks it can handle the supplied file as a Army. Checks can be performed on file extension or some basic check of file content, or some other method.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> for the file to check support for as a file containing Army information.
+		/// </param>
+		/// <returns>
+		/// <code>true</code> if the file appears to be supported for loading by this factory as a Army, else returns <code>false</code>
+		/// </returns>
+		bool CanHandleFileAsArmy(FileInfo file);
+		
+		/// <summary>
+		/// Reads the data from the supplied file and returns it as a collection of loadable objects. In addition, it fires the appropriate XxxLoaded event
+		/// for each object loaded for asynchronous use.
+		/// 
+		/// May throw a <see cref=" IBBoard.IO.InvalidFileException"/> if the file is supported by the Factory but the content is invalid.
+		/// </summary>
+		/// <param name="file">
+		/// A <see cref="FileInfo"/> for the file to load data from
+		/// </param>
+		/// <returns>
+		/// A <see cref="ICollection`1"/> of <see cref="IWarFoundryObject"/>s that were loaded from the file
+		/// </returns>
+		ICollection<IWarFoundryObject> CreateObjectsFromFile(FileInfo file);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/RequiredDataMissingException.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,19 @@
+// This file (RequiredDataMissingException.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+
+namespace IBBoard.WarFoundry.API.Factories
+{
+	/// <summary>
+	/// An exception that is thrown when a file cannot be loaded because one of the data files that it depends on has
+	/// not been loaded. Normally occurs when loading an army file without having the correct game system or race.
+	/// </summary>	
+	public class RequiredDataMissingException : Exception
+	{
+		public RequiredDataMissingException(String file, String missingObjectType, String requiredValue) : base(String.Format("Could not find data for {1} object with ID {2} required by {0}", file, missingObjectType, requiredValue))
+		{
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/Xml/AbstractStagedLoadedSubFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,33 @@
+//  This file (AbstractStagedLoadedSubFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Xml;
+using IBBoard.Xml;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories.Xml
+{
+	public class AbstractStagedLoadedSubFactory
+	{
+		protected WarFoundryXmlFactory mainFactory;
+		
+		protected AbstractStagedLoadedSubFactory(WarFoundryXmlFactory factory)
+		{
+			mainFactory = factory;
+		}
+		
+		protected Category CreateCategoryFromElement(XmlElement elem)
+		{
+			string id = elem.GetAttribute("id");
+			string name = elem.GetAttribute("name");
+			Category cat = new Category(id, name);
+			cat.MaximumPercentage = XmlTools.GetIntValueFromAttribute(elem, "maxPercentage");
+			cat.MinimumPercentage = XmlTools.GetIntValueFromAttribute(elem, "minPercentage");
+			cat.MaximumPoints = XmlTools.GetIntValueFromAttribute(elem, "maxPoints");
+			cat.MinimumPoints = XmlTools.GetIntValueFromAttribute(elem, "minPoints");
+			return cat;
+		}	
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/Xml/WarFoundryXmlArmyFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,23 @@
+//  This file (WarFoundryXmlArmyFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Xml;
+using IBBoard.Xml;
+using ICSharpCode.SharpZipLib.Zip;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories.Xml
+{
+	/// <summary>
+	/// A sub-factory for loading WarFoundry Army XML files
+	/// </summary>
+	public class WarFoundryXmlArmyFactory
+	{			
+		public Army CreateArmyFromElement(ZipFile file, XmlElement elem)
+		{
+			return new WarFoundryXmlArmyParser(file, elem).GetArmy();
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/Xml/WarFoundryXmlArmyParser.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,131 @@
+//  This file (WarFoundryXmlArmyParser.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using System.Xml;
+using IBBoard.IO;
+using IBBoard.Xml;
+using ICSharpCode.SharpZipLib.Zip;
+using IBBoard.WarFoundry.API.Objects;
+
+namespace IBBoard.WarFoundry.API.Factories.Xml
+{
+	public class WarFoundryXmlArmyParser
+	{
+		private ZipFile file;
+		private XmlElement elem;
+		private Army army;
+		private Dictionary<String, Unit> units;
+		
+		public WarFoundryXmlArmyParser(ZipFile file, XmlElement elem)
+		{
+			this.file = file;
+			this.elem = elem;
+		}
+
+		public Army GetArmy()
+		{
+			if (army == null)
+			{
+				ParseArmy();
+			}
+
+			return army;
+		}
+
+		private void ParseArmy()
+		{
+			string name = elem.GetAttribute("name");
+			string systemID = elem.GetAttribute("system");
+			GameSystem system = WarFoundryLoader.GetDefault().GetGameSystem(systemID);
+			
+			if (system == null)
+			{
+				throw new RequiredDataMissingException(file.Name, "Game System", systemID);
+			}
+			
+			string raceID = elem.GetAttribute("race");
+			Race race = WarFoundryLoader.GetDefault().GetRace(system, raceID);
+			
+			if (race == null)
+			{
+				throw new RequiredDataMissingException(file.Name, "Race", raceID);
+			}
+			
+			int points = XmlTools.GetIntValueFromAttribute(elem, "maxPoints");			
+			army = new Army(race, name, points, file);
+			LoadUnits();
+		}
+
+		private void LoadUnits()
+		{
+			units = new Dictionary<string, Unit>();
+
+			foreach (XmlElement unitElem in WarFoundryXmlFactoryUtils.SelectNodes(elem, "/army:army/army:units/army:unit"))
+			{
+				string id = unitElem.GetAttribute("id");
+
+				if (!units.ContainsKey(id))
+				{
+					string unitTypeId = unitElem.GetAttribute("unitType");
+					UnitType unitType = army.Race.GetUnitType(unitTypeId);
+
+					if (unitType == null)
+					{
+						throw new RequiredDataMissingException(file.Name, "Unit Type", unitTypeId);
+					}
+					
+					string name = unitElem.GetAttribute("unitName");
+					int size = XmlTools.GetIntValueFromAttribute(unitElem, "size");
+					
+					string catID = unitElem.GetAttribute("category");
+					Category cat = army.Race.GetCategory(catID);
+					
+					if (cat == null)
+					{
+						cat = unitType.MainCategory;
+					}
+
+					Unit unit = new Unit(id, name, size, unitType, army.GetCategory(cat));
+					army.AddUnit(unit, cat);
+					units.Add(id, unit);
+
+					LoadUnitEquipment(unitElem, unit);
+				}
+				else
+				{
+					throw new InvalidFileException("Duplicate unit ID found in army file: "+id);
+				}
+			}
+		}
+
+		private void LoadUnitEquipment(XmlElement unitElem, Unit unit)
+		{
+			foreach (XmlElement elem in WarFoundryXmlFactoryUtils.SelectNodes(unitElem, "army:equipment/army:equipItem"))
+			{
+				string equipID = elem.GetAttribute("id");
+				UnitEquipmentItem item = unit.UnitType.GetEquipmentItem(equipID);
+	
+				if (item == null)
+				{
+					throw new RequiredDataMissingException(file.Name, "Equipment Item", equipID);
+				}
+
+				double amount = XmlTools.GetDoubleValueFromAttribute(elem, "amount");
+				string equipTypeString = elem.GetAttribute("amountType");
+
+				if (equipTypeString == "ratio")
+				{
+					unit.SetEquipmentRatio(item, amount);
+				}
+				else
+				{
+					//amount should be a whole number, so do type-cast rounding
+					unit.SetEquipmentAmount(item, (int) amount);
+				}
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/Xml/WarFoundryXmlElementName.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,67 @@
+// This file (WarFoundryXmlElementName.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.Collections.Generic;
+using IBBoard.Xml;
+
+namespace IBBoard.WarFoundry.API.Factories.Xml
+{
+	/// <summary>
+	/// An enumeration class for valid WarFoundry XML elements, designed to imitate Java's extensible complex object enumerations. 
+	/// </summary>
+	public class WarFoundryXmlElementName : IXmlElementName, IExtendedEnum<string>
+	{
+		public static WarFoundryXmlElementName SYSTEM_ELEMENT = new WarFoundryXmlElementName("SYSTEM_ELEMENT", "system");
+		public static WarFoundryXmlElementName ARMY_ELEMENT = new WarFoundryXmlElementName("ARMY_ELEMENT", "army");
+		public static WarFoundryXmlElementName RACE_ELEMENT = new WarFoundryXmlElementName("RACE_ELEMENT", "race");
+        public static WarFoundryXmlElementName ARMY_DEFAULTNAME_ELEMENT = new WarFoundryXmlElementName("ARMY_DEFAULTNAME_ELEMENT", "defaultName");
+		public static WarFoundryXmlElementName CATEGORIES_ELEMENT = new WarFoundryXmlElementName("CATEGORIES_ELEMENT", "categories");
+		public static WarFoundryXmlElementName CATEGORY_ELEMENT = new WarFoundryXmlElementName("CATEGORY_ELEMENT", "cat");
+		public static WarFoundryXmlElementName UNITTYPES_ELEMENT = new WarFoundryXmlElementName("UNITTYPES_ELEMENT", "units");
+		public static WarFoundryXmlElementName UNITTYPE_ELEMENT = new WarFoundryXmlElementName("UNITTYPE_ELEMENT", "unit");
+		public static WarFoundryXmlElementName RACE_EQUIPMENT_ITEMS_ELEMENT = new WarFoundryXmlElementName("RACE_EQUIPMENT_ITEMS_ELEMENT", "equipment");
+		public static WarFoundryXmlElementName RACE_EQUIPMENT_ITEM_ELEMENT = new WarFoundryXmlElementName("RACE_EQUIPMENT_ITEMS_ELEMENT", "equipmentItem");
+		
+		private static ICollection<WarFoundryXmlElementName> enumValues;
+		private string name;
+		private string val;
+		
+		private WarFoundryXmlElementName(string elemName, string elemVal)
+		{
+			name = elemName;
+			val = elemVal;
+		}
+		
+		public string Name
+		{
+			get {
+				return name;
+			}
+		}
+		
+		public string Value
+		{
+			get {
+				return val;
+			}
+		}
+		
+		/// <summary>
+		/// Gets an ICollection of the values so that they can be looped over like a standard enumeration.
+		/// </summary>
+		/// <returns>
+		/// A <see cref="ICollection`1"/> of all of the static 'enumeration' values of the class.
+		/// </returns>
+		public static ICollection<WarFoundryXmlElementName> GetEnumValues()
+		{
+			if (enumValues == null)
+			{
+				enumValues = new WarFoundryXmlElementName[]{SYSTEM_ELEMENT, ARMY_ELEMENT, RACE_ELEMENT, CATEGORIES_ELEMENT, CATEGORY_ELEMENT, UNITTYPES_ELEMENT, UNITTYPE_ELEMENT};
+			}
+			
+			return enumValues;
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/Xml/WarFoundryXmlFactory.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,191 @@
+// This file (WarFoundryXmlFactory.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard.
+//
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.IO;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.XPath;
+using System.Collections.Generic;
+using System.Text;
+using IBBoard;
+using IBBoard.IO;
+using IBBoard.Lang;
+using IBBoard.Logging;
+using IBBoard.Xml;
+using IBBoard.WarFoundry.API.Requirements;
+using IBBoard.WarFoundry.API.Objects;
+using ICSharpCode.SharpZipLib.Zip;
+using System.Text.RegularExpressions;
+
+namespace IBBoard.WarFoundry.API.Factories.Xml
+{
+	/// <summary>
+	/// The WarFoundryXmlFactory loads WarFoundry classes from the native "XML in a zip" file format. Files are validated using the schema for the file type, so structurally invalid files should be identified at initial load.
+	/// </summary>
+	public class WarFoundryXmlFactory : AbstractNativeWarFoundryFactory
+	{
+		private static WarFoundryXmlFactory factory;
+		private WarFoundryXmlGameSystemFactory gameSystemFactory;
+		private WarFoundryXmlRaceFactory raceFactory;
+		private WarFoundryXmlArmyFactory armyFactory;
+
+		public static WarFoundryXmlFactory GetFactory()
+		{
+			if (factory == null)
+			{
+				factory = new WarFoundryXmlFactory();
+			}
+			
+			return factory;
+		}
+		
+		private WarFoundryXmlFactory() : base()
+		{
+			gameSystemFactory = new WarFoundryXmlGameSystemFactory(this);
+			raceFactory = new WarFoundryXmlRaceFactory(this);
+			armyFactory = new WarFoundryXmlArmyFactory();
+		}
+		
+		public WarFoundryXmlGameSystemFactory GetSystemFactory()
+		{
+			return gameSystemFactory;
+		}
+		
+		public WarFoundryXmlRaceFactory GetRaceFactory()
+		{
+			return raceFactory;
+		}
+		
+		public WarFoundryXmlArmyFactory GetArmyFactory()
+		{
+			return armyFactory;
+		}
+		
+		protected override bool CheckCanFindArmyFileContent(ZipFile file)
+		{
+			return FindEntries(file, "*.armyx").Count > 0;
+		}
+		
+		protected override bool CheckCanFindSystemFileContent(ZipFile file)
+		{
+			return FindEntries(file, "*.systemx").Count > 0;
+		}
+		
+		protected override bool CheckCanFindRaceFileContent(ZipFile file)
+		{
+			return FindEntries(file, "*.racex").Count > 0;
+		}
+		
+		protected override ICollection<ZipEntry> GetArmyZipEntries(ZipFile file)
+		{
+			return FindEntries(file, "*.armyx");
+		}
+		
+		private ICollection<ZipEntry> FindEntries(ZipFile file, string wildcardPattern)
+		{
+			Regex re = new Regex("^" + Regex.Escape(wildcardPattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$", RegexOptions.IgnoreCase | RegexOptions.Singleline);
+			ICollection<ZipEntry> entries = new List<ZipEntry>();
+				
+			foreach (ZipEntry entry in file)
+			{
+				if (re.IsMatch(entry.Name))
+				{
+					entries.Add(entry);
+				}
+			}
+			
+			return entries;
+		}
+		
+		protected override Army CreateArmyFromStream (ZipFile file, Stream dataStream)
+		{
+			XmlElement elem = GetRootElementFromStream(dataStream, WarFoundryXmlElementName.ARMY_ELEMENT);
+			return armyFactory.CreateArmyFromElement(file, elem);
+		}
+		
+		private XmlElement GetRootElementFromStream(Stream stream, WarFoundryXmlElementName elementName)
+		{
+			XmlDocument doc = WarFoundryXmlFactoryUtils.CreateXmlDocumentFromStream(stream);
+
+			XmlElement elem = (XmlElement)doc.LastChild;
+			
+			if (!elem.LocalName.Equals(elementName.Value))
+			{
+				throw new InvalidFileException(String.Format("Root element of XML was not valid. Expected {0} but got {1}", elementName.Value, elem.Name));
+			}
+			
+			return elem;
+		}
+
+		protected override ICollection<ZipEntry> GetGameSystemZipEntries(ZipFile file)
+		{
+			return FindEntries(file, "*.systemx");
+		}
+		
+		protected override GameSystem CreateGameSystemFromStream (ZipFile file, Stream dataStream)
+		{
+			XmlElement elem = GetRootElementFromStream(dataStream, WarFoundryXmlElementName.SYSTEM_ELEMENT);
+			LogNotifier.Debug(GetType(), "Create GameSystem");
+			return gameSystemFactory.CreateSystemFromElement(file, elem);
+		}
+		
+		protected override ICollection<ZipEntry> GetRaceZipEntries(ZipFile file)
+		{
+			return FindEntries(file, "*.racex");
+		}
+		
+		protected override Race CreateRaceFromStream (ZipFile file, Stream dataStream)
+		{
+			XmlElement elem = GetRootElementFromStream(dataStream, WarFoundryXmlElementName.RACE_ELEMENT);
+			LogNotifier.Debug(GetType(), "Create Race");
+			return raceFactory.CreateRaceFromElement(file, elem);
+		}
+
+		protected override void CleanUpFileAsSupportedType(ZipFile typedFile)
+		{
+			typedFile.Close();
+		}
+
+		public override void CompleteLoading(IWarFoundryStagedLoadObject obj)
+		{			
+			LogNotifier.DebugFormat(GetType(), "Complete loading of {0} with ID {1}", obj.GetType().Name, obj.ID);
+
+			if (obj is GameSystem)
+			{
+				CompleteLoadingGameSystem((GameSystem) obj);
+			}
+			else if (obj is Race)
+			{
+				CompleteLoadingRace((Race) obj);
+			}
+		}
+
+		private void CompleteLoadingRace(Race race)
+		{
+			try
+			{
+				raceFactory.CompleteLoading(race);
+			}
+			catch (InvalidFileException ex)
+			{
+				WarFoundryLoader.GetDefault().RemoveRace(race);
+				throw;
+			}
+		}
+
+		private void CompleteLoadingGameSystem(GameSystem system)
+		{
+			try
+			{
+				gameSystemFactory.CompleteLoading(system);
+			}
+			catch (InvalidFileException ex)
+			{
+				WarFoundryLoader.GetDefault().RemoveGameSystem(system);
+				throw;
+			}
+		}
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/API/Factories/Xml/WarFoundryXmlFactoryUtils.cs	Sun Apr 03 18:50:32 2011 +0000
@@ -0,0 +1,149 @@
+//  This file (WarFoundryXmlFactoryUtils.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2009 IBBoard
+// 
+// The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license.
+
+using System;
+using System.IO;
+using System.Xml;
+using System.Xml.Schema;
+using IBBoard.WarFoundry.API.Objects;
+using IBBoard.IO;
+
+namespace IBBoard.WarFoundry.API.Factories.Xml
+{
+	/// <summary>
+	/// A collection of useful utility methods for loading WarFoundry data from XML files
+	/// </summary>
+	public class WarFoundryXmlFactoryUtils
+	{
+		public static readonly string NS_BASE = "http://ibboard.co.uk/warfoundry/";
+		private static XmlReaderSettings settings;
+		private static XmlNamespaceManager nsManager;
+		
+		public static XmlNodeList SelectNodes(XmlNode element, string xpathQuery)
+		{
+			return element.SelectNodes(xpathQuery, GetNamespaceManager());
+		}
+		
+		public static XmlNode SelectSingleNode(XmlNode element, string xpathQuery)
+		{
+			return element.SelectSingleNode(xpathQuery, GetNamespaceManager());
+		}
+		
+		public static XmlElement SelectSingleElement(XmlNode element, string xpathQuery)
+		{
+			XmlNode node = SelectSingleNode(element, xpathQuery);
+			return (node is XmlElement) ? (XmlElement) node : null;
+		}
+				
+		public static XmlNamespaceManager GetNamespaceManager()
+		{
+			if (nsManager == null)
+			{
+				nsManager = new XmlNamespaceManager(new NameTable());
+				nsManager.AddNamespace("core", NS_BASE + "core");
+				nsManager.AddNamespace("cat", NS_BASE + "cats");
+				nsManager.AddNamespace("race", NS_BASE + "race");
+				nsManager.AddNamespace("system", NS_BASE + "system");
+				nsManager.AddNamespace("army", NS_BASE + "army");
+			}
+			
+			return nsManager;
+		}
+		
+		/// <summary>
+		/// Lazy-getter for XML reader settings. May throw a <see cref="InvalidDataException"/> if there is a problem with the translation schema.
+		/// </summary>
+		/// <returns>
+		/// A <see cref="XmlReaderSettings"/> with the default values for validating the translation document against the translation schema
+		/// </returns>
+		public static XmlReaderSettings GetReaderSettings()
+		{
+			if (settings == null)
+			{
+				settings = new XmlReaderSettings();
+				settings.ValidationType = ValidationType.Schema;
+				//settings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings;
+				settings.ProhibitDtd = true;
+				settings.ValidationEventHandler+= new ValidationEventHandler(ValidationEventMethod);
+				XmlSchemaSet cache = new XmlSchemaSet();
+				string path =  IBBoard.Constants.ExecutablePath + "/schemas/";
+				AddSchemaToCache(cache, NS_BASE + "core", path + "warfoundry-core.xsd");
+				AddSchemaToCache(cache, NS_BASE + "cats", path + "warfoundry-cats.xsd");
+				AddSchemaToCache(cache, NS_BASE + "race", path + "race.xsd");
+				AddSchemaToCache(cache, NS_BASE + "system", path + "system.xsd");
+				AddSchemaToCache(cache, NS_BASE + "army", path + "army.xsd");
+				settings.Schemas.Add(cache);
+				settings.Schemas.CompilationSettings.EnableUpaCheck = false;
+			}
+			
+			return settings;
+		}
+		
+		private static void ValidationEventMethod(object sender, ValidationEventArgs e)
+		{
+			if (e.Severity == XmlSeverityType.Error)
+			{
+				throw new InvalidFileException("Problem validating against schema for WarFoundry data: " + e.Message, e.Exception);
+			}
+			else
+			{
+				//TODO: Fire some kind of warning event
+			}
+		}
+		
+		private static void AddSchemaToCache(XmlSchemaSet cache, string xmlNamespace, string schemaLocation)
+		{
+			try
+			{
+				cache.Add(xmlNamespace, schemaLocation);
+			}
+			catch (IOException ex)
+			{
+				//TODO: Warn on schema failure
+			}
+			catch (XmlSchemaException ex)
+			{
+				//TODO: Warn on schema failure
+			}
+			catch (XmlException ex)
+			{
+				//TODO: Warn on schema failure
+			}
+		}
+		
+		public static XmlDocument CreateXmlDocumentFromStream(Stream stream)
+		{
+			XmlDocument doc = new XmlDocument();
+			XmlReader reader = XmlReader.Create(stream, GetReaderSettings());
+			
+			try
+			{
+				doc.Load(reader);
+			}
+			//Don't catch XMLSchemaExceptions - let them get thrown out
+			finally
+			{
+				reader.Close();
+			}
+
+			return doc;
+		}
+		
+		public static bool CanCompleteLoading(IWarFoundryStagedLoadObject obj)
+		{
+			bool canLoad = true;			
+			
+			if (obj.IsFullyLoaded)
+			{
+				canLoad = false;
+			}
+			else if (obj.IsLoading)
+			{
+				canLoad = false;
+			}
+			
+			return canLoad;
+		}
+	}
+}