diff --git a/binaries/data/mods/public/gui/common/setup.xml b/binaries/data/mods/public/gui/common/setup.xml
index 5fb2bc6eb7..2c95dd8691 100644
--- a/binaries/data/mods/public/gui/common/setup.xml
+++ b/binaries/data/mods/public/gui/common/setup.xml
@@ -140,6 +140,17 @@
 				textcolor="0 0 0"
 		/>
 		
+		<tooltip 	name="snToolTipBottom"
+				anchor="bottom"
+				buffer_zone="4"
+				delay="500"
+				font="tahoma12"
+				maxwidth="300"
+				offset="-4 -4"
+				sprite="bkWhiteBorderBlack"
+				textcolor="0 0 0"
+		/>
+		
 		<!--
 		==========================================
 		- SETUP - COLORS
diff --git a/binaries/data/mods/public/gui/session_new/input.js b/binaries/data/mods/public/gui/session_new/input.js
index 6a6712c1b1..529d189098 100644
--- a/binaries/data/mods/public/gui/session_new/input.js
+++ b/binaries/data/mods/public/gui/session_new/input.js
@@ -1,16 +1,18 @@
 const SDL_BUTTON_LEFT = 1;
 const SDL_BUTTON_MIDDLE = 2;
 const SDL_BUTTON_RIGHT = 3;
+const SDLK_RSHIFT = 303;
+const SDLK_LSHIFT = 304;
 // TODO: these constants should be defined somewhere else instead, in
 // case any other code wants to use them too
 
-
 var INPUT_NORMAL = 0;
 var INPUT_SELECTING = 1;
 var INPUT_BANDBOXING = 2;
 var INPUT_BUILDING_PLACEMENT = 3;
 var INPUT_BUILDING_CLICK = 4;
 var INPUT_BUILDING_DRAG = 5;
+var INPUT_BATCHTRAINING = 6;
 
 var inputState = INPUT_NORMAL;
 
@@ -21,6 +23,11 @@ var placementEntity;
 
 var mouseX = 0;
 var mouseY = 0;
+var specialKeyStates = {};
+specialKeyStates[SDLK_RSHIFT] = 0;
+specialKeyStates[SDLK_LSHIFT] = 0;
+// (TODO: maybe we should fix the hotkey system to be usable in this situation,
+// rather than hardcoding Shift into this code?)
 
 function updateCursor()
 {
@@ -117,8 +124,6 @@ Selection methods: (not all currently implemented)
 
 */
 
-// TODO: it'd probably be nice to have a better state-machine system
-
 var dragStart; // used for remembering mouse coordinates at start of drag operations
 
 function tryPlaceBuilding()
@@ -156,7 +161,8 @@ function tryPlaceBuilding()
 
 function handleInputBeforeGui(ev)
 {
-	// Capture mouse position so we can use it for displaying cursors
+	// Capture mouse position so we can use it for displaying cursors,
+	// and key states
 	switch (ev.type)
 	{
 	case "mousebuttonup":
@@ -165,6 +171,14 @@ function handleInputBeforeGui(ev)
 		mouseX = ev.x;
 		mouseY = ev.y;
 		break;
+	case "keydown":
+		if (ev.keysym.sym in specialKeyStates)
+			specialKeyStates[ev.keysym.sym] = 1;
+		break;
+	case "keyup":
+		if (ev.keysym.sym in specialKeyStates)
+			specialKeyStates[ev.keysym.sym] = 0;
+		break;
 	}
 
 	// State-machine processing:
@@ -172,6 +186,9 @@ function handleInputBeforeGui(ev)
 	// (This is for states which should override the normal GUI processing - events will
 	// be processed here before being passed on, and propagation will stop if this function
 	// returns true)
+	// 
+	// TODO: it'd probably be nice to have a better state-machine system, with guaranteed
+	// entry/exit functions, since this is a bit broken now
 
 	switch (inputState)
 	{
@@ -321,6 +338,18 @@ function handleInputBeforeGui(ev)
 			break;
 		}
 		break;
+
+	case INPUT_BATCHTRAINING:
+		switch (ev.type)
+		{
+		case "keyup":
+			if (ev.keysym.sym == SDLK_RSHIFT || ev.keysym.sym == SDLK_LSHIFT)
+			{
+				flushTrainingQueueBatch();
+				inputState = INPUT_NORMAL;
+			}
+			break;
+		}
 	}
 
 	return false;
@@ -459,9 +488,72 @@ function handleInputAfterGui(ev)
 	return false;
 }
 
-function testBuild(ent)
+// Called by GUI when user clicks construction button
+function startBuildingPlacement(buildEntType)
 {
-	placementEntity = ent;
+	placementEntity = buildEntType;
 	placementAngle = defaultPlacementAngle;
 	inputState = INPUT_BUILDING_PLACEMENT;
 }
+
+// Batch training:
+// When the user shift-clicks, we set these variables and switch to INPUT_BATCHTRAINING
+// When the user releases shift, or clicks on a different training button, we create the batched units
+var batchTrainingEntity;
+var batchTrainingType;
+var batchTrainingCount;
+const batchIncrementSize = 5;
+
+function flushTrainingQueueBatch()
+{
+	Engine.PostNetworkCommand({"type": "train", "entity": batchTrainingEntity, "template": batchTrainingType, "count": batchTrainingCount});
+}
+
+// Called by GUI when user clicks training button
+function addToTrainingQueue(entity, trainEntType)
+{
+	if (specialKeyStates[SDLK_RSHIFT] || specialKeyStates[SDLK_LSHIFT])
+	{
+		if (inputState == INPUT_BATCHTRAINING)
+		{
+			// If we're already creating a batch of this unit, then just extend it
+			if (batchTrainingEntity == entity && batchTrainingType == trainEntType)
+			{
+				batchTrainingCount += batchIncrementSize;
+				return;
+			}
+			// Otherwise start a new one
+			else
+			{
+				flushTrainingQueueBatch();
+				// fall through to create the new batch
+			}
+		}
+		inputState = INPUT_BATCHTRAINING;
+		batchTrainingEntity = entity;
+		batchTrainingType = trainEntType;
+		batchTrainingCount = batchIncrementSize;
+	}
+	else
+	{
+		// Non-batched - just create a single entity
+		Engine.PostNetworkCommand({"type": "train", "entity": entity, "template": trainEntType, "count": 1});
+	}
+}
+
+// Returns the number of units that will be present in a batch if the user clicks
+// the training button with shift down
+function getTrainingQueueBatchStatus(entity, trainEntType)
+{
+	if (inputState == INPUT_BATCHTRAINING && batchTrainingEntity == entity && batchTrainingType == trainEntType)
+		return [batchTrainingCount, batchIncrementSize];
+	else
+		return [0, batchIncrementSize];
+}
+
+// Called by GUI when user clicks production queue item
+function removeFromTrainingQueue(entity, id)
+{
+	Engine.PostNetworkCommand({"type": "stop-train", "entity": entity, "id": id});
+}
+
diff --git a/binaries/data/mods/public/gui/session_new/session.js b/binaries/data/mods/public/gui/session_new/session.js
index 2a1f771d7a..df4fceb493 100644
--- a/binaries/data/mods/public/gui/session_new/session.js
+++ b/binaries/data/mods/public/gui/session_new/session.js
@@ -92,12 +92,97 @@ function damageTypesToText(dmg)
 	return dmg.hack + " Hack\n" + dmg.pierce + " Pierce\n" + dmg.crush + " Crush";
 }
 
-var g_unitConstructionButtons = 0; // the number currently visible
+// The number of currently visible buttons (used to optimise showing/hiding)
+var g_unitPanelButtons = { "Construction": 0, "Training": 0, "Queue": 0 };
 
 // The unitSomethingPanel objects, which are displayed in a stack at the bottom of the screen,
 // ordered with *lowest* first
 var g_unitPanels = ["Stance", "Formation", "Construction", "Research", "Training", "Queue"];
 
+// Helper function for updateUnitDisplay
+function setupUnitPanel(guiName, usedPanels, unitEntState, items, callback)
+{
+	usedPanels[guiName] = 1;
+	var i = 0;
+	for each (var item in items)
+	{
+		var entType;
+		if (guiName == "Queue")
+			entType = item.template;
+		else
+			entType = item;
+
+		var button = getGUIObjectByName("unit"+guiName+"Button["+i+"]");
+		var icon = getGUIObjectByName("unit"+guiName+"Icon["+i+"]");
+
+		var template = Engine.GuiInterfaceCall("GetTemplateData", entType);
+
+		var name;
+		if (template.name.specific && template.name.generic)
+			name = template.name.specific + " (" + template.name.generic + ")";
+		else
+			name = template.name.specific || template.name.generic || "???";
+
+		var tooltip;
+		if (guiName == "Queue")
+		{
+			var progress = Math.round(item.progress*100) + "%";
+			tooltip = name + " - " + progress;
+
+			getGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = (item.count > 1 ? item.count : "");
+			getGUIObjectByName("unit"+guiName+"Progress["+i+"]").caption = (item.progress ? progress : "");
+		}
+		else
+		{
+			tooltip = "[font=trebuchet14b]" + name + "[/font]";
+
+			if (template.cost)
+			{
+				var costs = [];
+				if (template.cost.food) costs.push("[font=tahoma10b]Food:[/font] " + template.cost.food);
+				if (template.cost.wood) costs.push("[font=tahoma10b]Wood:[/font] " + template.cost.wood);
+				if (template.cost.metal) costs.push("[font=tahoma10b]Metal:[/font] " + template.cost.metal);
+				if (template.cost.stone) costs.push("[font=tahoma10b]Stone:[/font] " + template.cost.stone);
+				if (costs.length)
+					tooltip += "\n" + costs.join(", ");
+			}
+
+			if (guiName == "Training")
+			{
+				var [batchSize, batchIncrement] = getTrainingQueueBatchStatus(unitEntState.id, entType);
+				tooltip += "\n[font=tahoma11]";
+				if (batchSize) tooltip += "Training [font=tahoma12]" + batchSize + "[font=tahoma11] units; ";
+				tooltip += "Shift-click to train [font=tahoma12]" + (batchSize+batchIncrement) + "[font=tahoma11] units[/font]";
+			}
+		}
+
+		button.hidden = false;
+		button.tooltip = tooltip;
+		button.onpress = (function(e) { return function() { callback(e) } })(item);
+			// (need nested functions to get the closure right)
+
+		icon.sprite = "snPortraitSheetHele"; // TODO
+		icon.cell_id = template.icon_cell;
+		++i;
+	}
+	var numButtons = i;
+	// Position the visible buttons
+	// (TODO: if there's lots, maybe they should be squeezed together to fit)
+	for (i = 0; i < numButtons; ++i)
+	{
+		var button = getGUIObjectByName("unit"+guiName+"Button["+i+"]");
+		var size = button.size;
+		size.left = 40*i;
+		size.right = 40*i + size.bottom;
+		button.size = size;
+	}
+
+	// Hide any buttons we're no longer using
+	for (i = numButtons; i < g_unitPanelButtons[guiName]; ++i)
+		getGUIObjectByName("unit"+guiName+"Button["+i+"]").hidden = true;
+	g_unitPanelButtons[guiName] = numButtons;
+}
+
 function updateUnitDisplay()
 {
 	var detailsPanel = getGUIObjectByName("selectionDetails");
@@ -147,83 +232,41 @@ function updateUnitDisplay()
 		getGUIObjectByName("selectionDetailsGeneric").caption = template.name.generic;
 	}
 
+	getGUIObjectByName("selectionDetailsPlayer").caption = "Player " + entState.player; // TODO: get player name
+
 	getGUIObjectByName("selectionDetailsAttack").caption = damageTypesToText(entState.attack);
 	getGUIObjectByName("selectionDetailsArmour").caption = damageTypesToText(entState.armour);
 
 	var usedPanels = {};
 
-	if (entState.attack) // TODO - this should be based on some AI properties
+	// If the selection is friendly units, add the command panels
+	var player = Engine.GetPlayerID();
+	if (entState.player == player || g_DevSettings.controlAll)
 	{
-		//usedPanels["Stance"] = 1;
-		//usedPanels["Formation"] = 1;
-		// (These are disabled since they're not implemented yet)
-	}
-	else // TODO - this should be based on various other things
-	{
-		//usedPanels["Queue"] = 1;
-		//usedPanels["Training"] = 1;
-		//usedPanels["Research"] = 1;
-	}
-
-	// Set up the unit construction buttons
-	// (TODO: abstract this to apply to the other button panels)
-	if (entState.buildEntities && entState.buildEntities.length)
-	{
-		usedPanels["Construction"] = 1;
-		var i = 0;
-		for each (var build in entState.buildEntities)
+		if (entState.attack) // TODO - this should be based on some AI properties
 		{
-			var button = getGUIObjectByName("unitConstructionButton["+i+"]");
-			var icon = getGUIObjectByName("unitConstructionIcon["+i+"]");
-
-			var template = Engine.GuiInterfaceCall("GetTemplateData", build);
-
-			var name;
-			if (template.name.specific && template.name.generic)
-				name = template.name.specific + " (" + template.name.generic + ")";
-			else
-				name = template.name.specific || template.name.generic || "???";
-
-			var tooltip = "[font=trebuchet14b]" + name + "[/font]";
-
-			if (template.cost)
-			{
-				var costs = [];
-				if (template.cost.food) costs.push("[font=tahoma10b]Food:[/font] " + template.cost.food);
-				if (template.cost.wood) costs.push("[font=tahoma10b]Wood:[/font] " + template.cost.wood);
-				if (template.cost.metal) costs.push("[font=tahoma10b]Metal:[/font] " + template.cost.metal);
-				if (template.cost.stone) costs.push("[font=tahoma10b]Stone:[/font] " + template.cost.stone);
-				if (costs.length)
-					tooltip += "\n" + costs.join(", ");
-			}
-
-			button.hidden = false;
-			button.tooltip = tooltip;
-			button.onpress = (function(b) { return function() { testBuild(b) } })(build);
-				// (need nested functions to get the closure right)
-
-			icon.sprite = "snPortraitSheetHele";
-			icon.cell_id = template.icon_cell;
-			++i;
+			//usedPanels["Stance"] = 1;
+			//usedPanels["Formation"] = 1;
+			// (These are disabled since they're not implemented yet)
 		}
-		var numButtons = i;
-		// Position the visible buttons
-		// (TODO: if there's lots, maybe they should be squeezed together to fit)
-		for (i = 0; i < numButtons; ++i)
+		else // TODO - this should be based on various other things
 		{
-			var button = getGUIObjectByName("unitConstructionButton["+i+"]");
-			var size = button.size;
-			size.left = 40*i;
-			size.right = 40*i + size.bottom;
-			button.size = size;
+			//usedPanels["Research"] = 1;
 		}
 
-		// Hide any buttons we're no longer using
-		for (i = numButtons; i < g_unitConstructionButtons; ++i)
-			getGUIObjectByName("unitConstructionButton["+i+"]").hidden = true;
-		g_unitConstructionButtons = numButtons;
+		if (entState.buildEntities && entState.buildEntities.length)
+			setupUnitPanel("Construction", usedPanels, entState, entState.buildEntities, startBuildingPlacement);
+
+		if (entState.training && entState.training.entities.length)
+			setupUnitPanel("Training", usedPanels, entState, entState.training.entities,
+				function (trainEntType) { addToTrainingQueue(entState.id, trainEntType); } );
+
+		if (entState.training && entState.training.queue.length)
+			setupUnitPanel("Queue", usedPanels, entState, entState.training.queue,
+				function (item) { removeFromTrainingQueue(entState.id, item.id); } );
 	}
 
+	// Lay out all the used panels in a stack at the bottom of the screen
 	var offset = 0;
 	for each (var panelName in g_unitPanels)
 	{
diff --git a/binaries/data/mods/public/gui/session_new/session.xml b/binaries/data/mods/public/gui/session_new/session.xml
index 3144fbd37d..fb4a86e8d7 100644
--- a/binaries/data/mods/public/gui/session_new/session.xml
+++ b/binaries/data/mods/public/gui/session_new/session.xml
@@ -137,7 +137,7 @@
 			<object size="136 6 100% 100%">
 				<object size="0 0 100% 20" name="selectionDetailsSpecific" type="text" font="prospero18b"/>
 				<object size="0 20 100% 40" name="selectionDetailsGeneric" type="text" font="prospero16"/>
-				<object size="0 40 100% 60" name="selectionDetailsPlayer" type="text" font="prospero16" textcolor="blue">Wijitmaker</object>
+				<object size="0 40 100% 60" name="selectionDetailsPlayer" type="text" font="prospero16" textcolor="blue"/>
 			</object>
 
 			<!-- Attack stats -->
@@ -212,12 +212,18 @@
 			<object name="unitTrainingPanel"
 				style="goldPanelFrilly"
 				size="0 100%-56 100% 100%"
-				type="text"
+				type="image"
 			>
 				<object size="-5 -2 59 62" type="image" sprite="snIconSheetTab" tooltip_style="snToolTip"
 					 cell_id="2" tooltip="Training"/>
 
-				[training commands]
+				<object size="59 10 100% 47">
+					<repeat count="16">
+						<object name="unitTrainingButton[n]" hidden="true" style="iconButton" type="button" size="0 0 37 37">
+							<object name="unitTrainingIcon[n]" type="image" ghost="true" size="3 3 35 35"/>
+						</object>
+					</repeat>
+				</object>
 			</object>
 
 			<object name="unitQueuePanel"
@@ -228,7 +234,15 @@
 				<object size="-5 -2 59 62" type="image" sprite="snIconSheetTab" tooltip_style="snToolTip"
 					 cell_id="3" tooltip="Production queue"/>
 
-				[training/research queue]
+				<object size="59 10 100% 47">
+					<repeat count="16">
+						<object name="unitQueueButton[n]" hidden="true" style="iconButton" type="button" size="0 0 37 37">
+							<object name="unitQueueIcon[n]" ghost="true" type="image" size="3 3 35 35"/>
+							<object name="unitQueueCount[n]" ghost="true" style="iconButtonCount" type="text"/>
+							<object name="unitQueueProgress[n]" ghost="true" style="iconButtonProgress" type="text"/>
+						</object>
+					</repeat>
+				</object>
 			</object>
 
 		</object>
diff --git a/binaries/data/mods/public/gui/session_new/styles.xml b/binaries/data/mods/public/gui/session_new/styles.xml
index 38375b9a4e..b4ff938b67 100644
--- a/binaries/data/mods/public/gui/session_new/styles.xml
+++ b/binaries/data/mods/public/gui/session_new/styles.xml
@@ -38,10 +38,22 @@
 		sprite="snIconPortrait"
 		sprite_over="snIconPortraitOver"
 		sprite_disabled="snIconPortraitDisabled"
-		text_align="right"
+		tooltip_style="snToolTipBottom"
+	/>
+
+	<style name="iconButtonCount"
 		textcolor="255 255 255"
-		tooltip_style="snToolTip"
-		tooltip="(TBA)"
+		font="tahoma10"
+		text_align="right"
+		text_valign="top"
+		buffer_zone="4"
+	/>
+
+	<style name="iconButtonProgress"
+		textcolor="255 255 255"
+		font="tahoma14"
+		text_align="center"
+		text_valign="center"
 	/>
 
 	<style name="devCommandsText"
diff --git a/binaries/data/mods/public/simulation/components/GuiInterface.js b/binaries/data/mods/public/simulation/components/GuiInterface.js
index 445679c6a8..0ab028ff2b 100644
--- a/binaries/data/mods/public/simulation/components/GuiInterface.js
+++ b/binaries/data/mods/public/simulation/components/GuiInterface.js
@@ -39,7 +39,8 @@ GuiInterface.prototype.GetEntityState = function(player, ent)
 		return null;
 
 	var ret = {
-		"template": template,
+		"id": ent,
+		"template": template
 	}
 
 	var cmpPosition = Engine.QueryInterface(ent, IID_Position);
@@ -73,6 +74,15 @@ GuiInterface.prototype.GetEntityState = function(player, ent)
 		ret.buildEntities = cmpBuilder.GetEntitiesList();
 	}
 
+	var cmpTrainingQueue = Engine.QueryInterface(ent, IID_TrainingQueue);
+	if (cmpTrainingQueue)
+	{
+		ret.training = {
+			"entities": cmpTrainingQueue.GetEntitiesList(),
+			"queue": cmpTrainingQueue.GetQueue(),
+		};
+	}
+
 	var cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
 	if (cmpFoundation)
 	{
@@ -111,6 +121,9 @@ GuiInterface.prototype.GetTemplateData = function(player, name)
 	var cmpTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	var template = cmpTempMan.GetTemplate(name);
 
+	if (!template)
+		return null;
+
 	var ret = {};
 
 	if (template.Identity)
@@ -125,13 +138,10 @@ GuiInterface.prototype.GetTemplateData = function(player, name)
 	if (template.Cost)
 	{
 		ret.cost = {};
-		if (template.Cost.Resources)
-		{
-			if (template.Cost.Resources.food) ret.cost.food = +template.Cost.Resources.food;
-			if (template.Cost.Resources.wood) ret.cost.wood = +template.Cost.Resources.wood;
-			if (template.Cost.Resources.stone) ret.cost.stone = +template.Cost.Resources.stone;
-			if (template.Cost.Resources.metal) ret.cost.metal = +template.Cost.Resources.metal;
-		}
+		if (template.Cost.Resources.food) ret.cost.food = +template.Cost.Resources.food;
+		if (template.Cost.Resources.wood) ret.cost.wood = +template.Cost.Resources.wood;
+		if (template.Cost.Resources.stone) ret.cost.stone = +template.Cost.Resources.stone;
+		if (template.Cost.Resources.metal) ret.cost.metal = +template.Cost.Resources.metal;
 	}
 
 	return ret;
diff --git a/binaries/data/mods/public/simulation/components/Player.js b/binaries/data/mods/public/simulation/components/Player.js
index 9549c02b67..d4d41c7b4d 100644
--- a/binaries/data/mods/public/simulation/components/Player.js
+++ b/binaries/data/mods/public/simulation/components/Player.js
@@ -40,6 +40,12 @@ Player.prototype.AddResource = function(type, amount)
 	this.resourceCount[type] += (+amount);
 };
 
+Player.prototype.AddResources = function(amounts)
+{
+	for (var type in amounts)
+		this.resourceCount[type] += (+amounts[type]);
+};
+
 Player.prototype.TrySubtractResources = function(amounts)
 {
 	// Check we can afford it all
diff --git a/binaries/data/mods/public/simulation/components/Timer.js b/binaries/data/mods/public/simulation/components/Timer.js
index f3af92b487..da23a4fa3e 100644
--- a/binaries/data/mods/public/simulation/components/Timer.js
+++ b/binaries/data/mods/public/simulation/components/Timer.js
@@ -40,6 +40,11 @@ Timer.prototype.OnUpdate = function(msg)
 	}
 }
 
+/**
+ * Create a new timer, which will call the 'funcname' method with argument 'data'
+ * on the 'iid' component of the 'ent' entity, after at least 'time' milliseconds.
+ * Returns a non-zero id that can be passed to CancelTimer.
+ */
 Timer.prototype.SetTimeout = function(ent, iid, funcname, time, data)
 {
 	var id = ++this.id;
diff --git a/binaries/data/mods/public/simulation/components/TrainingQueue.js b/binaries/data/mods/public/simulation/components/TrainingQueue.js
new file mode 100644
index 0000000000..dce4fae74e
--- /dev/null
+++ b/binaries/data/mods/public/simulation/components/TrainingQueue.js
@@ -0,0 +1,212 @@
+var g_ProgressInterval = 1000;
+
+function TrainingQueue() {}
+
+TrainingQueue.prototype.Schema =
+	"<element name='Entities'>" +
+		"<attribute name='datatype'><value>tokens</value></attribute>" +
+		"<text/>" +
+	"</element>";
+
+TrainingQueue.prototype.Init = function()
+{
+    this.nextID = 1;
+
+	this.queue = [];
+	// Queue items are:
+	//   {
+	//     "id": 1,
+	//     "template": "units/example",
+	//     "count": 10,
+	//     "resources": { "wood": 100, ... },
+	//     "timeTotal": 15000, // msecs
+	//     "timeRemaining": 10000, // msecs
+	//   }
+	
+	this.timer = undefined; // g_ProgressInterval msec timer, active while the queue is non-empty
+};
+
+TrainingQueue.prototype.GetEntitiesList = function()
+{
+	var string = this.template.Entities._string;
+	
+	// Replace the "{civ}" codes with this entity's civ ID
+	var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+	if (cmpIdentity)
+		string = string.replace(/\{civ\}/g, cmpIdentity.GetCiv());
+	
+	return string.split(/\s+/);
+};
+
+TrainingQueue.prototype.AddBatch = function(player, templateName, count)
+{
+	// TODO: there should probably be a limit on the number of queued batches
+	// TODO: there should be a way for the GUI to determine whether it's going
+	// to be possible to add a batch (based on resource costs and length limits)
+
+	// Find the template data so we can determine the build costs
+	var cmpTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	var template = cmpTempMan.GetTemplate(templateName);
+	if (!template)
+		return;
+
+	var timeMult = count; // TODO: we want some kind of discount for larger batches
+	var costMult = count;
+
+	var time = timeMult * (template.Cost.BuildTime || 1);
+	var costs = {};
+	for each (var r in ["food", "wood", "stone", "metal"])
+	{
+		if (template.Cost.Resources[r])
+			costs[r] = Math.floor(costMult * template.Cost.Resources[r]);
+		else
+			costs[r] = 0;
+	}
+
+	// Find the player
+	var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+	var playerEnt = cmpPlayerMan.GetPlayerByID(player);
+	var cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
+
+	if (!cmpPlayer.TrySubtractResources(costs))
+	{
+		// TODO: report error to player (they ran out of resources)
+		return;
+	}
+
+	this.queue.push({
+		"id": this.nextID++,
+		"template": templateName,
+		"count": count,
+		"resources": costs,
+		"timeTotal": time*1000,
+		"timeRemaining": time*1000,
+	});
+
+	// If this is the first item in the queue, start the timer
+	if (!this.timer)
+	{
+ 		var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+		this.timer = cmpTimer.SetTimeout(this.entity, IID_TrainingQueue, "ProgressTimeout", g_ProgressInterval, {});
+	}
+};
+
+TrainingQueue.prototype.RemoveBatch = function(player, id)
+{
+	for (var i = 0; i < this.queue.length; ++i)
+	{
+		var item = this.queue[i];
+		if (item.id != id)
+			continue;
+
+		// Now we've found the item to remove
+
+		// Find the player
+		var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+		var playerEnt = cmpPlayerMan.GetPlayerByID(player);
+		var cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
+
+		// Refund the resource cost for this batch
+		cmpPlayer.AddResources(item.resources);
+
+		// Remove from the queue
+		// (We don't need to remove the timer - it'll expire if it discovers the queue is empty)
+		this.queue.splice(i, 1);
+		return;
+	}
+}
+
+TrainingQueue.prototype.GetQueue = function()
+{
+	var out = [];
+	for each (var item in this.queue)
+	{
+		out.push({
+			"id": item.id,
+			"template": item.template,
+			"count": item.count,
+			"progress": 1-(item.timeRemaining/item.timeTotal),
+		});
+	}
+	return out;
+};
+
+TrainingQueue.prototype.OnDestroy = function()
+{
+	// If the building is destroyed while it's got a large training queue,
+	// you lose all the resources invested in that queue. That'll teach you
+	// to be so reckless with your buildings.
+
+	if (this.timer)
+	{
+		var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+		cmpTimer.CancelTimer(this.timer);
+	}
+};
+
+
+TrainingQueue.prototype.SpawnUnits = function(templateName, count)
+{
+	var cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
+	var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+
+	for (var i = 0; i < count; ++i)
+	{
+		var ent = Engine.AddEntity(templateName);
+
+		var pos = cmpFootprint.PickSpawnPoint(ent);
+		if (pos.y < 0)
+		{
+			// Whoops, something went wrong (maybe there wasn't any space to spawn the unit).
+			// What should we do here?
+			// For now, just move the unit into the middle of the building where it'll probably get stuck
+			pos = cmpPosition.GetPosition();
+		}
+
+		var cmpNewPosition = Engine.QueryInterface(ent, IID_Position);
+		cmpNewPosition.JumpTo(pos.x, pos.z);
+		// TODO: what direction should they face in?
+
+		var cmpNewOwnership = Engine.QueryInterface(ent, IID_Ownership);
+		cmpNewOwnership.SetOwner(cmpOwnership.GetOwner());
+
+		// TODO: move to rally points
+	}
+};
+
+TrainingQueue.prototype.ProgressTimeout = function(data)
+{
+	// Allocate the 1000msecs to as many queue items as it takes
+	// until we've used up all the time (so that we work accurately
+	// with items that take fractions of a second)
+	var time = g_ProgressInterval;
+
+	while (time > 0 && this.queue.length)
+	{
+		var item = this.queue[0];
+		if (item.timeRemaining > time)
+		{
+			item.timeRemaining -= time;
+			break;
+		}
+
+		// This item is finished now
+		time -= item.timeRemaining;
+		this.SpawnUnits(item.template, item.count);
+		this.queue.shift();
+	}
+
+	// If the queue's empty, delete the timer, else repeat it
+	if (this.queue.length == 0)
+	{
+		this.timer = undefined;
+	}
+	else
+	{
+		var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+		this.timer = cmpTimer.SetTimeout(this.entity, IID_TrainingQueue, "ProgressTimeout", g_ProgressInterval, data);
+	}
+}
+
+Engine.RegisterComponentType(IID_TrainingQueue, "TrainingQueue", TrainingQueue);
diff --git a/binaries/data/mods/public/simulation/components/interfaces/TrainingQueue.js b/binaries/data/mods/public/simulation/components/interfaces/TrainingQueue.js
new file mode 100644
index 0000000000..b881970e8f
--- /dev/null
+++ b/binaries/data/mods/public/simulation/components/interfaces/TrainingQueue.js
@@ -0,0 +1 @@
+Engine.RegisterInterface("TrainingQueue");
diff --git a/binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js b/binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js
index 01c9476d97..8afe259556 100644
--- a/binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js
+++ b/binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js
@@ -5,6 +5,7 @@ Engine.LoadComponentScript("interfaces/Foundation.js");
 Engine.LoadComponentScript("interfaces/Health.js");
 Engine.LoadComponentScript("interfaces/ResourceGatherer.js");
 Engine.LoadComponentScript("interfaces/ResourceSupply.js");
+Engine.LoadComponentScript("interfaces/TrainingQueue.js");
 Engine.LoadComponentScript("GuiInterface.js");
 
 var cmp = ConstructComponent(SYSTEM_ENTITY, "GuiInterface");
@@ -56,6 +57,7 @@ AddMock(10, IID_Builder, {
 
 var state = cmp.GetEntityState(-1, 10);
 TS_ASSERT_UNEVAL_EQUALS(state, {
+	id: 10,
 	template: "example",
 	position: {x:1, y:2, z:3},
 	hitpoints: 50,
diff --git a/binaries/data/mods/public/simulation/helpers/Commands.js b/binaries/data/mods/public/simulation/helpers/Commands.js
index 57ecb5d15a..cbe0ff2c79 100644
--- a/binaries/data/mods/public/simulation/helpers/Commands.js
+++ b/binaries/data/mods/public/simulation/helpers/Commands.js
@@ -2,15 +2,17 @@ function ProcessCommand(player, cmd)
 {
 //	print("command: " + player + " " + uneval(cmd) + "\n");
 	
+	// TODO: all of this stuff needs to do checks for valid arguments
+	// (e.g. make sure players own the units they're trying to use)
+
 	switch (cmd.type)
 	{
 	case "walk":
 		for each (var ent in cmd.entities)
 		{
 			var ai = Engine.QueryInterface(ent, IID_UnitAI);
-			if (!ai)
-				continue;
-			ai.Walk(cmd.x, cmd.z);
+			if (ai)
+				ai.Walk(cmd.x, cmd.z);
 		}
 		break;
 
@@ -18,9 +20,8 @@ function ProcessCommand(player, cmd)
 		for each (var ent in cmd.entities)
 		{
 			var ai = Engine.QueryInterface(ent, IID_UnitAI);
-			if (!ai)
-				continue;
-			ai.Attack(cmd.target);
+			if (ai)
+				ai.Attack(cmd.target);
 		}
 		break;
 
@@ -29,9 +30,8 @@ function ProcessCommand(player, cmd)
 		for each (var ent in cmd.entities)
 		{
 			var ai = Engine.QueryInterface(ent, IID_UnitAI);
-			if (!ai)
-				continue;
-			ai.Repair(cmd.target);
+			if (ai)
+				ai.Repair(cmd.target);
 		}
 		break;
 
@@ -39,12 +39,23 @@ function ProcessCommand(player, cmd)
 		for each (var ent in cmd.entities)
 		{
 			var ai = Engine.QueryInterface(ent, IID_UnitAI);
-			if (!ai)
-				continue;
-			ai.Gather(cmd.target);
+			if (ai)
+				ai.Gather(cmd.target);
 		}
 		break;
 
+	case "train":
+		var queue = Engine.QueryInterface(cmd.entity, IID_TrainingQueue);
+		if (queue)
+			queue.AddBatch(player, cmd.template, +cmd.count);
+		break;
+
+	case "stop-train":
+		var queue = Engine.QueryInterface(cmd.entity, IID_TrainingQueue);
+		if (queue)
+			queue.RemoveBatch(player, cmd.id);
+		break;
+
 	case "construct":
 		/*
 		 * Construction process:
diff --git a/source/maths/Fixed.cpp b/source/maths/Fixed.cpp
index 767c499fad..0229d9b452 100644
--- a/source/maths/Fixed.cpp
+++ b/source/maths/Fixed.cpp
@@ -53,3 +53,19 @@ CFixed_23_8 atan2_approx(CFixed_23_8 y, CFixed_23_8 x)
 	else
 		return angle;
 }
+
+template<>
+CFixed_23_8 CFixed_23_8::Pi()
+{
+	return CFixed_23_8(804); // = pi * 256
+}
+
+void sincos_approx(CFixed_23_8 a, CFixed_23_8& sin_out, CFixed_23_8& cos_out)
+{
+	// XXX: mustn't use floating-point here - need a fixed-point emulation
+
+	// TODO: it's stupid doing sin/cos with 8-bit precision - we ought to have a CFixed_16_16 instead
+
+	sin_out = CFixed_23_8::FromDouble(sin(a.ToDouble()));
+	cos_out = CFixed_23_8::FromDouble(cos(a.ToDouble()));
+}
diff --git a/source/maths/Fixed.h b/source/maths/Fixed.h
index 5d65e6be40..2645e5f162 100644
--- a/source/maths/Fixed.h
+++ b/source/maths/Fixed.h
@@ -48,6 +48,9 @@ public:
 
 	CFixed() : value(0) { }
 
+	static CFixed Zero() { return CFixed(0); }
+	static CFixed Pi();
+
 	T GetInternalValue() const { return value; }
 	void SetInternalValue(T n) { value = n; }
 
@@ -165,4 +168,6 @@ typedef CFixed<i32, (i32)0x7fffffff, 32, 23, 8, 256> CFixed_23_8;
  */
 CFixed_23_8 atan2_approx(CFixed_23_8 y, CFixed_23_8 x);
 
+void sincos_approx(CFixed_23_8 a, CFixed_23_8& sin_out, CFixed_23_8& cos_out);
+
 #endif // INCLUDED_FIXED
diff --git a/source/maths/FixedVector2D.h b/source/maths/FixedVector2D.h
index 929f8382ed..8f2e23421a 100644
--- a/source/maths/FixedVector2D.h
+++ b/source/maths/FixedVector2D.h
@@ -71,6 +71,20 @@ public:
 		return *this;
 	}
 
+	/// Scalar multiplication by an integer
+	CFixedVector2D operator*(int n) const
+	{
+		return CFixedVector2D(X*n, Y*n);
+	}
+
+	/**
+	 * Multiply by a CFixed. Likely to overflow if both numbers are large,
+	 * so we use an ugly name instead of operator* to make it obvious.
+	 */
+	CFixedVector2D Multiply(fixed n) const
+	{
+		return CFixedVector2D(X.Multiply(n), Y.Multiply(n));
+	}
 
 	/**
 	 * Returns the length of the vector.
diff --git a/source/simulation2/components/CCmpFootprint.cpp b/source/simulation2/components/CCmpFootprint.cpp
index 0227f9e641..491822709e 100644
--- a/source/simulation2/components/CCmpFootprint.cpp
+++ b/source/simulation2/components/CCmpFootprint.cpp
@@ -20,7 +20,10 @@
 #include "simulation2/system/Component.h"
 #include "ICmpFootprint.h"
 
+#include "ICmpObstructionManager.h"
+#include "ICmpPosition.h"
 #include "simulation2/MessageTypes.h"
+#include "maths/FixedVector2D.h"
 
 class CCmpFootprint : public ICmpFootprint
 {
@@ -31,6 +34,8 @@ public:
 
 	DEFAULT_COMPONENT_ALLOCATOR(Footprint)
 
+	const CSimContext* m_Context;
+
 	EShape m_Shape;
 	CFixed_23_8 m_Size0; // width/radius
 	CFixed_23_8 m_Size1; // height/radius
@@ -53,8 +58,10 @@ public:
 			"</element>";
 	}
 
-	virtual void Init(const CSimContext& UNUSED(context), const CParamNode& paramNode)
+	virtual void Init(const CSimContext& context, const CParamNode& paramNode)
 	{
+		m_Context = &context;
+
 		if (paramNode.GetChild("Square").IsOk())
 		{
 			m_Shape = SQUARE;
@@ -96,6 +103,119 @@ public:
 		size1 = m_Size1;
 		height = m_Height;
 	}
+
+	virtual CFixedVector3D PickSpawnPoint(entity_id_t spawned)
+	{
+		CFixedVector3D error(CFixed_23_8::FromInt(-1), CFixed_23_8::FromInt(-1), CFixed_23_8::FromInt(-1));
+
+		CmpPtr<ICmpPosition> cmpPosition(*m_Context, GetEntityId());
+		if (cmpPosition.null() || !cmpPosition->IsInWorld())
+			return error;
+
+		CmpPtr<ICmpObstructionManager> cmpObstructionManager(*m_Context, SYSTEM_ENTITY);
+		if (cmpObstructionManager.null())
+			return error;
+
+		// Always approximate the spawned entity as a circle, so we're orientation-independent
+		CFixed_23_8 spawnedRadius;
+
+		CmpPtr<ICmpFootprint> cmpSpawnedFootprint(*m_Context, spawned);
+		if (!cmpSpawnedFootprint.null())
+		{
+			EShape shape;
+			CFixed_23_8 size0, size1, height;
+			cmpSpawnedFootprint->GetShape(shape, size0, size1, height);
+			if (shape == CIRCLE)
+				spawnedRadius = size0;
+			else
+				spawnedRadius = std::max(size0, size1); // safe overapproximation of the correct sqrt((size0/2)^2 + (size1/2)^2)
+		}
+		else
+		{
+			// No footprint - weird but let's just pretend it's a point
+			spawnedRadius = CFixed_23_8::FromInt(0);
+		}
+
+		// The spawn point should be far enough from this footprint to fit the unit, plus a little gap
+		CFixed_23_8 clearance = spawnedRadius + CFixed_23_8::FromInt(2);
+
+		CFixedVector3D initialPos = cmpPosition->GetPosition();
+		entity_angle_t initialAngle = cmpPosition->GetRotation().Y;
+
+		if (m_Shape == CIRCLE)
+		{
+			CFixed_23_8 radius = m_Size0 + clearance;
+
+			// Try equally-spaced points around the circle, starting from the front and expanding outwards in alternating directions
+			const ssize_t numPoints = 31;
+			for (ssize_t i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
+			{
+				entity_angle_t angle = initialAngle + (entity_angle_t::Pi()*2).Multiply(entity_angle_t::FromInt(i)/numPoints);
+
+				CFixed_23_8 s, c;
+				sincos_approx(angle, s, c);
+
+				CFixedVector3D pos (initialPos.X + s.Multiply(radius), CFixed_23_8::Zero(), initialPos.Z + c.Multiply(radius));
+
+				SkipTagObstructionFilter filter(spawned); // ignore collisions with the spawned entity
+				if (cmpObstructionManager->TestCircle(filter, pos.X, pos.Z, spawnedRadius))
+					return pos; // this position is okay, so return it
+			}
+		}
+		else
+		{
+			CFixed_23_8 s, c;
+			sincos_approx(initialAngle, s, c);
+
+			for (size_t edge = 0; edge < 4; ++edge)
+			{
+				// Try equally-spaced points along the edge, starting from the middle and expanding outwards in alternating directions
+				const ssize_t numPoints = 9;
+
+				// Compute the direction and length of the current edge
+				CFixedVector2D dir;
+				CFixed_23_8 sx, sy;
+				switch (edge)
+				{
+				case 0:
+					dir = CFixedVector2D(c, -s);
+					sx = m_Size0;
+					sy = m_Size1;
+					break;
+				case 1:
+					dir = CFixedVector2D(-s, -c);
+					sx = m_Size1;
+					sy = m_Size0;
+					break;
+				case 2:
+					dir = CFixedVector2D(s, c);
+					sx = m_Size1;
+					sy = m_Size0;
+					break;
+				case 3:
+					dir = CFixedVector2D(-c, s);
+					sx = m_Size0;
+					sy = m_Size1;
+					break;
+				}
+				CFixedVector2D center;
+				center.X = initialPos.X + (-dir.Y).Multiply(sy/2 + clearance);
+				center.Y = initialPos.Z + dir.X.Multiply(sy/2 + clearance);
+				dir = dir.Multiply((sx + clearance*2) / (numPoints-1));
+
+				for (ssize_t i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
+				{
+					CFixedVector2D pos (center + dir*i);
+
+					SkipTagObstructionFilter filter(spawned); // ignore collisions with the spawned entity
+					if (cmpObstructionManager->TestCircle(filter, pos.X, pos.Y, spawnedRadius))
+						return CFixedVector3D(pos.X, CFixed_23_8::Zero(), pos.Y); // this position is okay, so return it
+				}
+			}
+		}
+
+		return error;
+	}
 };
 
 REGISTER_COMPONENT_TYPE(Footprint)
diff --git a/source/simulation2/components/ICmpFootprint.cpp b/source/simulation2/components/ICmpFootprint.cpp
index 91640cbeb1..fe1daf9c6d 100644
--- a/source/simulation2/components/ICmpFootprint.cpp
+++ b/source/simulation2/components/ICmpFootprint.cpp
@@ -22,4 +22,5 @@
 #include "simulation2/system/InterfaceScripted.h"
 
 BEGIN_INTERFACE_WRAPPER(Footprint)
+DEFINE_INTERFACE_METHOD_1("PickSpawnPoint", CFixedVector3D, ICmpFootprint, PickSpawnPoint, entity_id_t)
 END_INTERFACE_WRAPPER(Footprint)
diff --git a/source/simulation2/components/ICmpFootprint.h b/source/simulation2/components/ICmpFootprint.h
index a3557290ed..7e9da520d8 100644
--- a/source/simulation2/components/ICmpFootprint.h
+++ b/source/simulation2/components/ICmpFootprint.h
@@ -21,6 +21,7 @@
 #include "simulation2/system/Interface.h"
 
 #include "simulation2/helpers/Position.h"
+#include "maths/FixedVector3D.h"
 
 /**
  * Footprints - an approximation of the entity's shape, used for collision detection and for
@@ -37,8 +38,24 @@ public:
 		SQUARE
 	};
 
+	/**
+	 * Return the shape of this footprint.
+	 * Shapes are horizontal circles or squares, extended vertically upwards to make cylinders or boxes.
+	 * @param[out] shape either CIRCLE or SQUARE
+	 * @param[out] size0 if CIRCLE then radius, else width (size in X axis)
+	 * @param[out] size1 if CIRCLE then radius, else depth (size in Z axis)
+	 * @param[out] height size in Y axis
+	 */
 	virtual void GetShape(EShape& shape, entity_pos_t& size0, entity_pos_t& size1, entity_pos_t& height) = 0;
 
+	/**
+	 * Pick a sensible position to place a newly-spawned entity near this footprint,
+	 * such that it won't be in an invalid (obstructed) location regardless of the spawned unit's
+	 * orientation.
+	 * @return the X and Z coordinates of the spawn point, with Y = 0; or the special value (-1, -1, -1) if there's no space
+	 */
+	virtual CFixedVector3D PickSpawnPoint(entity_id_t spawned) = 0;
+
 	DECLARE_INTERFACE_TYPE(Footprint)
 };
 
diff --git a/source/simulation2/components/ICmpObstructionManager.h b/source/simulation2/components/ICmpObstructionManager.h
index 99b0d5d25a..3c568f1901 100644
--- a/source/simulation2/components/ICmpObstructionManager.h
+++ b/source/simulation2/components/ICmpObstructionManager.h
@@ -92,7 +92,7 @@ public:
 	 * @param x1 X coordinate of line's second point
 	 * @param z1 Z coordinate of line's second point
 	 * @param r radius (half width) of line
-	 * @return true if there is a collision
+	 * @return false if there is a collision
 	 */
 	virtual bool TestLine(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r) = 0;
 
@@ -102,7 +102,7 @@ public:
 	 * @param x X coordinate of center
 	 * @param z Z coordinate of center
 	 * @param r radius of circle
-	 * @return true if there is a collision
+	 * @return false if there is a collision
 	 */
 	virtual bool TestCircle(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r) = 0;
 
@@ -114,7 +114,7 @@ public:
 	 * @param a angle of rotation (clockwise from +Z direction)
 	 * @param w width (size along X axis)
 	 * @param h height (size along Z axis)
-	 * @return true if there is a collision
+	 * @return false if there is a collision
 	 */
 	virtual bool TestSquare(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h) = 0;