diff --git a/binaries/data/mods/_test.sim/simulation/templates/unitobstruct.xml b/binaries/data/mods/_test.sim/simulation/templates/unitobstruct.xml
index 307a00620f..2ff4c456f0 100644
--- a/binaries/data/mods/_test.sim/simulation/templates/unitobstruct.xml
+++ b/binaries/data/mods/_test.sim/simulation/templates/unitobstruct.xml
@@ -16,5 +16,10 @@
     </Footprint>
     <Obstruction>
         <Unit radius="4"/>
+        <Active>true</Active>
+        <BlockMovement>true</BlockMovement>
+        <BlockPathfinding>false</BlockPathfinding>
+        <BlockFoundation>false</BlockFoundation>
+        <BlockConstruction>true</BlockConstruction>
     </Obstruction>
 </Entity>
diff --git a/binaries/data/mods/public/gui/session/input.js b/binaries/data/mods/public/gui/session/input.js
index 4b067d87b1..21579bc75f 100644
--- a/binaries/data/mods/public/gui/session/input.js
+++ b/binaries/data/mods/public/gui/session/input.js
@@ -313,6 +313,8 @@ function tryPlaceBuilding(queued)
 		"z": placementPosition.z,
 		"angle": placementAngle,
 		"entities": selection,
+		"autorepair": true,
+		"autocontinue": true,
 		"queued": queued
 	});
 	Engine.GuiInterfaceCall("PlaySound", { "name": "order_repair", "entity": selection[0] });
diff --git a/binaries/data/mods/public/simulation/ai/common-api/base.js b/binaries/data/mods/public/simulation/ai/common-api/base.js
index 8ca1f0f1f4..208e30218c 100644
--- a/binaries/data/mods/public/simulation/ai/common-api/base.js
+++ b/binaries/data/mods/public/simulation/ai/common-api/base.js
@@ -6,10 +6,48 @@ function BaseAI(settings)
 	// Make some properties non-enumerable, so they won't be serialised
 	Object.defineProperty(this, "_player", {value: settings.player, enumerable: false});
 	Object.defineProperty(this, "_templates", {value: settings.templates, enumerable: false});
+	Object.defineProperty(this, "_derivedTemplates", {value: {}, enumerable: false});
 
 	this._entityMetadata = {};
 }
 
+// Components that will be disabled in foundation entity templates.
+// (This is a bit yucky and fragile since it's the inverse of
+// CCmpTemplateManager::CopyFoundationSubset and only includes components
+// that our EntityTemplate class currently uses.)
+var g_FoundationForbiddenComponents = {
+	"TrainingQueue": 1,
+	"ResourceSupply": 1,
+	"ResourceDropsite": 1,
+	"GarrisonHolder": 1,
+};
+
+BaseAI.prototype.GetTemplate = function(name)
+{
+	if (this._templates[name])
+		return this._templates[name];
+
+	if (this._derivedTemplates[name])
+		return this._derivedTemplates[name];
+
+	// If this is a foundation template, construct it automatically
+	if (name.substr(0, 11) === "foundation|")
+	{
+		var base = this.GetTemplate(name.substr(11));
+
+		var foundation = {};
+		for (var key in base)
+			if (!g_FoundationForbiddenComponents[key])
+				foundation[key] = base[key];
+
+		this._derivedTemplates[name] = foundation;
+		return foundation;
+	}
+
+	error("Tried to retrieve invalid template '"+name+"'");
+	return null;
+};
+
 BaseAI.prototype.HandleMessage = function(state)
 {
 	if (!this._rawEntities)
@@ -22,6 +60,8 @@ BaseAI.prototype.HandleMessage = function(state)
 	this.playerData = state.players[this._player];
 	this.templates = this._templates;
 	this.timeElapsed = state.timeElapsed;
+	this.map = state.map;
+	this.passabilityClasses = state.passabilityClasses;
 
 	this.OnUpdate();
 
@@ -31,6 +71,8 @@ BaseAI.prototype.HandleMessage = function(state)
 	delete this.playerData;
 	delete this.templates;
 	delete this.timeElapsed;
+	delete this.map;
+	delete this.passabilityClasses;
 };
 
 BaseAI.prototype.ApplyEntitiesDelta = function(state)
@@ -48,10 +90,11 @@ BaseAI.prototype.ApplyEntitiesDelta = function(state)
 		}
 		else if (evt.type == "TrainingFinished")
 		{
-			for each (var ent in evt.msg.entities)
-			{
-				this._entityMetadata[ent] = evt.msg.metadata;
-			}
+			// Apply metadata stored in training queues, but only if they
+			// look like they were added by us
+			if (evt.msg.owner == this._player)
+				for each (var ent in evt.msg.entities)
+					this._entityMetadata[ent] = evt.msg.metadata;
 		}
 	}
 
diff --git a/binaries/data/mods/public/simulation/ai/common-api/entity.js b/binaries/data/mods/public/simulation/ai/common-api/entity.js
index f7918b0b6d..301e164e99 100644
--- a/binaries/data/mods/public/simulation/ai/common-api/entity.js
+++ b/binaries/data/mods/public/simulation/ai/common-api/entity.js
@@ -38,6 +38,26 @@ var EntityTemplate = Class({
 		return ret;
 	},
 
+	/**
+	 * Returns the radius of a circle surrounding this entity's
+	 * obstruction shape, or undefined if no obstruction.
+	 */
+	obstructionRadius: function() {
+		if (!this._template.Obstruction)
+			return undefined;
+
+		if (this._template.Obstruction.Static)
+		{
+			var w = +this._template.Obstruction.Static["@width"];
+			var h = +this._template.Obstruction.Static["@depth"];
+			return Math.sqrt(w*w + h*h) / 2;
+		}
+
+		if (this._template.Obstruction.Unit)
+			return +this._template.Obstruction.Unit["@radius"];
+
+		return 0; // this should never happen
+	},
 
 	maxHitpoints: function() { return this._template.Health.Max; },
 	isHealable: function() { return this._template.Health.Healable === "true"; },
@@ -103,12 +123,13 @@ var EntityTemplate = Class({
 });
 
 
+
 var Entity = Class({
 	_super: EntityTemplate,
 
 	_init: function(baseAI, entity)
 	{
-		this._super.call(this, baseAI._templates[entity.template]);
+		this._super.call(this, baseAI.GetTemplate(entity.template));
 
 		this._ai = baseAI;
 		this._templateName = entity.template;
@@ -134,7 +155,7 @@ var Entity = Class({
 	 */
 	getMetadata: function(id) {
 		var metadata = this._ai._entityMetadata[this.id()];
-		if (!metadata)
+		if (!metadata || !(id in metadata))
 			return undefined;
 		return metadata[id];
 	},
@@ -179,7 +200,11 @@ var Entity = Class({
 		return queue.length;
 	},
 
-	foundationProgress: function() { return this._entity.foundationProgress; },
+	foundationProgress: function() {
+		if (typeof this._entity.foundationProgress === "undefined")
+			return undefined;
+		return this._entity.foundationProgress;
+	},
 
 	owner: function() {
 		return this._entity.owner;
@@ -216,6 +241,11 @@ var Entity = Class({
 		return this;
 	},
 
+	repair: function(target) {
+		Engine.PostCommand({"type": "repair", "entities": [this.id()], "target": target.id(), "queued": false});
+		return this;
+	},
+
 	destroy: function() {
 		Engine.PostCommand({"type": "delete-entities", "entities": [this.id()]});
 		return this;
@@ -244,5 +274,23 @@ var Entity = Class({
 		});
 		return this;
 	},
+
+	construct: function(template, x, z, angle) {
+		// TODO: verify this unit can construct this, just for internal
+		// sanity-checking and error reporting
+
+		Engine.PostCommand({
+			"type": "construct",
+			"entities": [this.id()],
+			"template": template,
+			"x": x,
+			"z": z,
+			"angle": angle,
+			"autorepair": false,
+			"autocontinue": false,
+			"queued": false
+		});
+		return this;
+	},
 });
 
diff --git a/binaries/data/mods/public/simulation/ai/common-api/entitycollection.js b/binaries/data/mods/public/simulation/ai/common-api/entitycollection.js
index 9d38437aa0..7848b3472b 100644
--- a/binaries/data/mods/public/simulation/ai/common-api/entitycollection.js
+++ b/binaries/data/mods/public/simulation/ai/common-api/entitycollection.js
@@ -30,6 +30,31 @@ EntityCollection.prototype.toString = function()
 	return "[EntityCollection " + this.toEntityArray().join(" ") + "]";
 };
 
+/**
+ * Returns the (at most) n entities nearest to targetPos.
+ */
+EntityCollection.prototype.filterNearest = function(targetPos, n)
+{
+	// Compute the distance of each entity
+	var data = []; // [ [id, ent, distance], ... ]
+	for (var id in this._entities)
+	{
+		var ent = this._entities[id];
+		if (ent.position)
+			data.push([id, ent, VectorDistance(targetPos, ent.position)]);
+	}
+
+	// Sort by increasing distance
+	data.sort(function (a, b) { return (a[2] - b[2]); });
+
+	// Extract the first n
+	var ret = {};
+	for each (var val in data.slice(0, n))
+		ret[val[0]] = val[1];
+
+	return new EntityCollection(this._ai, ret);
+};
+
 EntityCollection.prototype.filter = function(callback, thisp)
 {
 	var ret = {};
diff --git a/binaries/data/mods/public/simulation/ai/testbot/economy.js b/binaries/data/mods/public/simulation/ai/testbot/economy.js
index 5693fa0f43..1a74503969 100644
--- a/binaries/data/mods/public/simulation/ai/testbot/economy.js
+++ b/binaries/data/mods/public/simulation/ai/testbot/economy.js
@@ -2,10 +2,64 @@ var EconomyManager = Class({
 
 	_init: function()
 	{
-		this.targetNumWorkers = 10; // minimum number of workers we want
+		this.targetNumWorkers = 30; // minimum number of workers we want
+		this.targetNumBuilders = 5; // number of workers we want working on construction
+
+		// (This is a stupid design where we just construct certain numbers
+		// of certain buildings in sequence)
+		this.targetBuildings = [
+			{
+				"template": "structures/{civ}_civil_centre",
+				"priority": 500,
+				"count": 1,
+			},
+			{
+				"template": "structures/{civ}_house",
+				"priority": 100,
+				"count": 5,
+			},
+			{
+				"template": "structures/{civ}_barracks",
+				"priority": 75,
+				"count": 1,
+			},
+			{
+				"template": "structures/{civ}_field",
+				"priority": 50,
+				"count": 5,
+			},
+		];
+
+		// Relative proportions of workers to assign to each resource type
+		this.gatherWeights = {
+			"food": 150,
+			"wood": 100,
+			"stone": 50,
+			"metal": 100,
+		};
 	},
 
-	update: function(gameState, planGroups)
+	buildMoreBuildings: function(gameState, planGroups)
+	{
+		// Limit ourselves to constructing one building at a time
+		if (gameState.findFoundations().length)
+			return;
+
+		for each (var building in this.targetBuildings)
+		{
+			var numBuildings = gameState.countEntitiesAndQueuedWithType(gameState.applyCiv(building.template));
+
+			// If we have too few, build another
+			if (numBuildings < building.count)
+			{
+				planGroups.economyConstruction.addPlan(building.priority,
+					new BuildingConstructionPlan(gameState, building.template)
+				);
+			}
+		}
+	},
+
+	trainMoreWorkers: function(gameState, planGroups)
 	{
 		// Count the workers in the world and in progress
 		var numWorkers = gameState.countEntitiesAndQueuedWithRole("worker");
@@ -16,27 +70,58 @@ var EconomyManager = Class({
 		{
 			planGroups.economyPersonnel.addPlan(100,
 				new UnitTrainingPlan(gameState,
-					"units/hele_support_female_citizen", 1, { "role": "worker" })
+					"units/{civ}_support_female_citizen", 1, { "role": "worker" })
 			);
 		}
+	},
+
+	pickMostNeededResource: function(gameState)
+	{
+		// Find what resource type we're most in need of
+		var numGatherers = {};
+		for (var type in this.gatherWeights)
+			numGatherers[type] = 0;
+
+		gameState.getOwnEntities().forEach(function(ent) {
+			if (ent.getMetadata("role") === "worker" && ent.getMetadata("subrole") === "gatherer")
+				numGatherers[ent.getMetadata("gather-type")] += 1;
+		});
+
+		var bestType = "food";
+		var bestTypeVal = Infinity; // num gatherers divided by weight
+		for (var type in this.gatherWeights)
+		{
+			var v = numGatherers[type] / this.gatherWeights[type];
+			if (v < bestTypeVal)
+			{
+				bestTypeVal = v;
+				bestType = type;
+			}
+		}
+
+		return bestType;
+	},
+
+	reassignIdleWorkers: function(gameState, planGroups)
+	{
+		var self = this;
 
 		// Search for idle workers, and tell them to gather resources
 		// Maybe just pick a random nearby resource type at first;
 		// later we could add some timer that redistributes workers based on
 		// resource demand.
 
-		var idleWorkers = gameState.entities.filter(function(ent) {
+		var idleWorkers = gameState.getOwnEntities().filter(function(ent) {
 			return (ent.getMetadata("role") === "worker" && ent.isIdle());
 		});
 
 		if (idleWorkers.length)
 		{
-			var resourceSupplies = gameState.findResourceSupplies(gameState);
+			var resourceSupplies = gameState.findResourceSupplies();
 
 			idleWorkers.forEach(function(ent) {
-				// Pick a resource type at random
-				// TODO: should limit to what this worker can gather
-				var type = Resources.prototype.types[Math.floor(Math.random()*Resources.prototype.types.length)];
+
+				var type = self.pickMostNeededResource(gameState);
 
 				// Make sure there's actually some of that type
 				// (We probably shouldn't pick impossible ones in the first place)
@@ -61,9 +146,66 @@ var EconomyManager = Class({
 
 				// Start gathering
 				if (closestEntity)
+				{
 					ent.gather(closestEntity);
+					ent.setMetadata("subrole", "gatherer");
+					ent.setMetadata("gather-type", type);
+				}
 			});
 		}
 	},
 
+	assignToFoundations: function(gameState, planGroups)
+	{
+		// If we have some foundations, and we don't have enough builder-workers,
+		// try reassigning some other workers who are nearby
+
+		var foundations = gameState.findFoundations();
+
+		// Check if nothing to build
+		if (!foundations.length)
+			return;
+
+		var workers = gameState.getOwnEntities().filter(function(ent) {
+			return (ent.getMetadata("role") === "worker");
+		});
+
+		var builderWorkers = workers.filter(function(ent) {
+			return (ent.getMetadata("subrole") === "builder");
+		});
+
+		// Check if enough builders
+		var extraNeeded = this.targetNumBuilders - builderWorkers.length;
+		if (extraNeeded <= 0)
+			return;
+
+		// Pick non-builders who are closest to the first foundation,
+		// and tell them to start building it
+
+		var target = foundations.toEntityArray()[0];
+
+		var nonBuilderWorkers = workers.filter(function(ent) {
+			return (ent.getMetadata("subrole") !== "builder");
+		});
+
+		var nearestNonBuilders = nonBuilderWorkers.filterNearest(target.position(), extraNeeded);
+
+		// Order each builder individually, not as a formation
+		nearestNonBuilders.forEach(function(ent) {
+			ent.repair(target);
+			ent.setMetadata("subrole", "builder");
+		});
+	},
+
+	update: function(gameState, planGroups)
+	{
+		this.buildMoreBuildings(gameState, planGroups);
+
+		this.trainMoreWorkers(gameState, planGroups);
+
+		this.reassignIdleWorkers(gameState, planGroups);
+
+		this.assignToFoundations(gameState, planGroups);
+	},
+
 });
diff --git a/binaries/data/mods/public/simulation/ai/testbot/gamestate.js b/binaries/data/mods/public/simulation/ai/testbot/gamestate.js
index a119f4df0b..a36af85119 100644
--- a/binaries/data/mods/public/simulation/ai/testbot/gamestate.js
+++ b/binaries/data/mods/public/simulation/ai/testbot/gamestate.js
@@ -4,12 +4,13 @@
  */
 var GameState = Class({
 
-	_init: function(timeElapsed, templates, entities, playerData)
+	_init: function(ai)
 	{
-		this.timeElapsed = timeElapsed;
-		this.templates = templates;
-		this.entities = entities;
-		this.playerData = playerData;
+		this.ai = ai;
+		this.timeElapsed = ai.timeElapsed;
+		this.templates = ai.templates;
+		this.entities = ai.entities;
+		this.playerData = ai.playerData;
 	},
 
 	getTimeElapsed: function()
@@ -24,22 +25,52 @@ var GameState = Class({
 		return new EntityTemplate(this.templates[type]);
 	},
 
+	applyCiv: function(str)
+	{
+		return str.replace(/\{civ\}/g, this.playerData.civ);
+	},
+
 	getResources: function()
 	{
 		return new Resources(this.playerData.resourceCounts);
 	},
 
+	getMap: function()
+	{
+		return this.ai.map;
+	},
+
+	getPassabilityClassMask: function(name)
+	{
+		if (!(name in this.ai.passabilityClasses))
+			error("Tried to use invalid passability class name '"+name+"'");
+		return this.ai.passabilityClasses[name];
+	},
+
 	getOwnEntities: function()
 	{
 		return this.entities.filter(function(ent) { return ent.isOwn(); });
 	},
 
-	countEntitiesAndQueuedWithType: function(type)
+	countEntitiesWithType: function(type)
 	{
 		var count = 0;
 		this.getOwnEntities().forEach(function(ent) {
+			var t = ent.templateName();
+			if (t == type)
+				++count;
+		});
+		return count;
+	},
 
-			if (ent.templateName() == type)
+	countEntitiesAndQueuedWithType: function(type)
+	{
+		var foundationType = "foundation|" + type;
+		var count = 0;
+		this.getOwnEntities().forEach(function(ent) {
+
+			var t = ent.templateName();
+			if (t == type || t == foundationType)
 				++count;
 
 			var queue = ent.trainingQueue();
@@ -99,7 +130,29 @@ var GameState = Class({
 		});
 	},
 
-	findResourceSupplies: function(gameState)
+	/**
+	 * Find units that are capable of constructing the given building type.
+	 */
+	findBuilders: function(template)
+	{
+		return this.getOwnEntities().filter(function(ent) {
+
+			var buildable = ent.buildableEntities();
+			if (!buildable || buildable.indexOf(template) == -1)
+				return false;
+
+			return true;
+		});
+	},
+
+	findFoundations: function(template)
+	{
+		return this.getOwnEntities().filter(function(ent) {
+			return (typeof ent.foundationProgress() !== "undefined");
+		});
+	},
+
+	findResourceSupplies: function()
 	{
 		var supplies = {};
 		this.entities.forEach(function(ent) {
@@ -122,5 +175,4 @@ var GameState = Class({
 		});
 		return supplies;
 	},
-
 });
diff --git a/binaries/data/mods/public/simulation/ai/testbot/military.js b/binaries/data/mods/public/simulation/ai/testbot/military.js
index 222de08084..d9f4c927db 100644
--- a/binaries/data/mods/public/simulation/ai/testbot/military.js
+++ b/binaries/data/mods/public/simulation/ai/testbot/military.js
@@ -12,9 +12,9 @@ var MilitaryAttackManager = Class({
 	{
 		this.targetSquadSize = 10;
 		this.squadTypes = [
-			"units/hele_infantry_spearman_b",
-			"units/hele_infantry_javelinist_b",
-			"units/hele_infantry_archer_b",
+			"units/{civ}_infantry_spearman_b",
+			"units/{civ}_infantry_javelinist_b",
+//			"units/{civ}_infantry_archer_b", // TODO: should only include this if hele
 		];
 	},
 
@@ -32,6 +32,9 @@ var MilitaryAttackManager = Class({
 		// Sort by increasing count
 		types.sort(function (a, b) { return a[1] - b[1]; });
 
+		// TODO: we shouldn't return units that we don't have any
+		// buildings capable of training
+
 		return types[0][0];
 	},
 
diff --git a/binaries/data/mods/public/simulation/ai/testbot/plan-building.js b/binaries/data/mods/public/simulation/ai/testbot/plan-building.js
new file mode 100644
index 0000000000..c1b8efd90c
--- /dev/null
+++ b/binaries/data/mods/public/simulation/ai/testbot/plan-building.js
@@ -0,0 +1,186 @@
+var BuildingConstructionPlan = Class({
+
+	_init: function(gameState, type)
+	{
+		this.type = gameState.applyCiv(type);
+
+		this.cost = new Resources(gameState.getTemplate(this.type).cost());
+	},
+
+	canExecute: function(gameState)
+	{
+		// TODO: verify numeric limits etc
+
+		var builders = gameState.findBuilders(this.type);
+
+		return (builders.length != 0);
+	},
+
+	execute: function(gameState)
+	{
+//		warn("Executing BuildingConstructionPlan "+uneval(this));
+
+		var builders = gameState.findBuilders(this.type).toEntityArray();
+
+		// We don't care which builder we assign, since they won't actually
+		// do the building themselves - all we care about is that there is
+		// some unit that can start the foundation
+
+		var pos = this.findGoodPosition(gameState);
+
+		builders[0].construct(this.type, pos.x, pos.z, pos.angle);
+	},
+
+	getCost: function()
+	{
+		return this.cost;
+	},
+
+	/**
+	 * Make each cell's 16-bit value at least one greater than each of its
+	 * neighbours' values. (If the grid is initialised with 0s and 65535s,
+	 * the result of each cell is its Manhattan distance to the nearest 0.)
+	 *
+	 * TODO: maybe this should be 8-bit (and clamp at 255)?
+	 */
+	expandInfluences: function(grid, w, h)
+	{
+		for (var y = 0; y < h; ++y)
+		{
+			var min = 65535;
+			for (var x = 0; x < w; ++x)
+			{
+				var g = grid[x + y*w];
+				if (g > min) grid[x + y*w] = min;
+				else if (g < min) min = g;
+				++min;
+			}
+
+			for (var x = w-2; x >= 0; --x)
+			{
+				var g = grid[x + y*w];
+				if (g > min) grid[x + y*w] = min;
+				else if (g < min) min = g;
+				++min;
+			}
+		}
+
+		for (var x = 0; x < w; ++x)
+		{
+			var min = 65535;
+			for (var y = 0; y < h; ++y)
+			{
+				var g = grid[x + y*w];
+				if (g > min) grid[x + y*w] = min;
+				else if (g < min) min = g;
+				++min;
+			}
+
+			for (var y = h-2; y >= 0; --y)
+			{
+				var g = grid[x + y*w];
+				if (g > min) grid[x + y*w] = min;
+				else if (g < min) min = g;
+				++min;
+			}
+		}
+	},
+
+	/**
+	 * Add a circular linear-falloff shape to a grid.
+	 */
+	addInfluence: function(grid, w, h, cx, cy, maxDist)
+	{
+		var x0 = Math.max(0, cx - maxDist);
+		var y0 = Math.max(0, cy - maxDist);
+		var x1 = Math.min(w, cx + maxDist);
+		var y1 = Math.min(h, cy + maxDist);
+		for (var y = y0; y < y1; ++y)
+		{
+			for (var x = x0; x < x1; ++x)
+			{
+				var dx = x - cx;
+				var dy = y - cy;
+				var r = Math.sqrt(dx*dx + dy*dy);
+				if (r < maxDist)
+					grid[x + y*w] += maxDist - r;
+			}
+		}
+	},
+
+	findGoodPosition: function(gameState)
+	{
+		var self = this;
+
+		var cellSize = 4; // size of each tile
+
+		// First, find all tiles that are far enough away from obstructions:
+
+		var map = gameState.getMap();
+
+		var obstructionMask = gameState.getPassabilityClassMask("foundationObstruction");
+		// Only accept valid land tiles (we don't handle docks yet)
+		obstructionMask |= gameState.getPassabilityClassMask("building-land");
+
+		var obstructionTiles = new Uint16Array(map.data.length);
+		for (var i = 0; i < map.data.length; ++i)
+			obstructionTiles[i] = (map.data[i] & obstructionMask) ? 0 : 65535;
+
+//		Engine.DumpImage("tiles0.png", obstructionTiles, map.width, map.height, 64);
+
+		this.expandInfluences(obstructionTiles, map.width, map.height);
+
+		// Compute each tile's closeness to friendly structures:
+
+		var friendlyTiles = new Uint16Array(map.data.length);
+
+		gameState.getOwnEntities().forEach(function(ent) {
+			if (ent.hasClass("Structure"))
+			{
+				var infl = 32;
+				if (ent.hasClass("CivCentre"))
+					infl *= 4;
+
+				var pos = ent.position();
+				var x = Math.round(pos[0] / cellSize);
+				var z = Math.round(pos[1] / cellSize);
+				self.addInfluence(friendlyTiles, map.width, map.height, x, z, infl);
+			}
+		});
+
+		// Find target building's approximate obstruction radius,
+		// and expand by a bit to make sure we're not too close
+		var template = gameState.getTemplate(this.type);
+		var radius = Math.ceil(template.obstructionRadius() / cellSize) + 2;
+
+		// Find the best non-obstructed tile
+		var bestIdx = 0;
+		var bestVal = -1;
+		for (var i = 0; i < map.data.length; ++i)
+		{
+			if (obstructionTiles[i] > radius)
+			{
+				var v = friendlyTiles[i];
+				if (v > bestVal)
+				{
+					bestVal = v;
+					bestIdx = i;
+				}
+			}
+		}
+		var x = ((bestIdx % map.width) + 0.5) * cellSize;
+		var z = (Math.floor(bestIdx / map.width) + 0.5) * cellSize;
+
+//		Engine.DumpImage("tiles1.png", obstructionTiles, map.width, map.height, 32);
+//		Engine.DumpImage("tiles2.png", friendlyTiles, map.width, map.height, 256);
+
+		// Randomise the angle a little, to look less artificial
+		var angle = Math.PI + (Math.random()*2-1) * Math.PI/24;
+
+		return {
+			"x": x,
+			"z": z,
+			"angle": angle
+		};
+	},
+});
diff --git a/binaries/data/mods/public/simulation/ai/testbot/plan-training.js b/binaries/data/mods/public/simulation/ai/testbot/plan-training.js
index b5a7b9c413..a9cb741748 100644
--- a/binaries/data/mods/public/simulation/ai/testbot/plan-training.js
+++ b/binaries/data/mods/public/simulation/ai/testbot/plan-training.js
@@ -2,11 +2,11 @@ var UnitTrainingPlan = Class({
 
 	_init: function(gameState, type, amount, metadata)
 	{
-		this.type = type;
+		this.type = gameState.applyCiv(type);
 		this.amount = amount;
 		this.metadata = metadata;
 
-		this.cost = new Resources(gameState.getTemplate(type).cost());
+		this.cost = new Resources(gameState.getTemplate(this.type).cost());
 		this.cost.multiply(amount); // (assume no batch discount)
 	},
 
diff --git a/binaries/data/mods/public/simulation/ai/testbot/plan.js b/binaries/data/mods/public/simulation/ai/testbot/plan.js
index 97f06c9c4b..6a49552df4 100644
--- a/binaries/data/mods/public/simulation/ai/testbot/plan.js
+++ b/binaries/data/mods/public/simulation/ai/testbot/plan.js
@@ -39,7 +39,7 @@ var PlanGroup = Class({
 		var plans = this.plans.filter(function(p) { return p.plan.canExecute(gameState); });
 
 		// Sort by decreasing priority
-		plans.sort(function(a, b) { return a.priority > b.priority; });
+		plans.sort(function(a, b) { return b.priority - a.priority; });
 
 		// Execute as many plans as we can afford
 		while (plans.length && this.escrow.canAfford(plans[0].plan.getCost()))
diff --git a/binaries/data/mods/public/simulation/ai/testbot/testbot.js b/binaries/data/mods/public/simulation/ai/testbot/testbot.js
index 600d821cf3..9502e3536f 100644
--- a/binaries/data/mods/public/simulation/ai/testbot/testbot.js
+++ b/binaries/data/mods/public/simulation/ai/testbot/testbot.js
@@ -25,8 +25,6 @@
 /*
  * Lots of things we should fix:
  *
- *  * Construct buildings (houses, farms, barracks)
- *  * Play as non-hele civs
  *  * Find entities with no assigned role, and give them something to do
  *  * Keep some units back for defence
  *  * Consistent terminology (type vs template etc)
@@ -50,6 +48,7 @@ function TestBotAI(settings)
 
 	this.planGroups = {
 		economyPersonnel: new PlanGroup(),
+		economyConstruction: new PlanGroup(),
 		militaryPersonnel: new PlanGroup(),
 	};
 }
@@ -99,7 +98,7 @@ TestBotAI.prototype.OnUpdate = function()
 	// Run the update every n turns, offset depending on player ID to balance the load
 	if ((this.turn + this.player) % 4 == 0)
 	{
-		var gameState = new GameState(this.timeElapsed, this.templates, this.entities, this.playerData);
+		var gameState = new GameState(this);
 
 		// Find the resources we have this turn that haven't already
 		// been allocated to an escrow account.
diff --git a/binaries/data/mods/public/simulation/components/AnimalAI.js b/binaries/data/mods/public/simulation/components/AnimalAI.js
index 33f4b27656..24c1778130 100644
--- a/binaries/data/mods/public/simulation/components/AnimalAI.js
+++ b/binaries/data/mods/public/simulation/components/AnimalAI.js
@@ -67,6 +67,13 @@ var AnimalFsmSpec = {
 			this.PlaySound("panic");
 		},
 
+		"LeaveFoundation": function(msg) {
+			// Run away from the foundation
+			this.MoveAwayFrom(msg.target, +this.template.FleeDistance);
+			this.SetNextState("FLEEING");
+			this.PlaySound("panic");
+		},
+
 		"ROAMING": {
 			"enter": function() {
 				// Walk in a random direction
@@ -134,6 +141,12 @@ var AnimalFsmSpec = {
 			// Do nothing, just let them kill us
 		},
 	
+		"LeaveFoundation": function(msg) {
+			// Walk away from the foundation
+			this.MoveAwayFrom(msg.target, 4);
+			this.SetNextState("FLEEING");
+		},
+
 		"ROAMING": {
 			"enter": function() {
 				// Walk in a random direction
@@ -174,6 +187,16 @@ var AnimalFsmSpec = {
 				this.SetNextState("ROAMING");
 			},
 		},
+
+		"FLEEING": {
+			"enter": function() {
+				this.SelectAnimation("walk", false, this.GetWalkSpeed());
+			},
+
+			"MoveCompleted": function() {
+				this.SetNextState("ROAMING");
+			},
+		},
 	},
 
 };
@@ -236,6 +259,11 @@ AnimalAI.prototype.TimerHandler = function(data, lateness)
 	AnimalFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
 };
 
+AnimalAI.prototype.LeaveFoundation = function(target)
+{
+	AnimalFsm.ProcessMessage(this, {"type": "LeaveFoundation", "target": target});
+};
+
 // Functions to be called by the FSM:
 
 AnimalAI.prototype.GetWalkSpeed = function()
diff --git a/binaries/data/mods/public/simulation/components/Foundation.js b/binaries/data/mods/public/simulation/components/Foundation.js
index deeb3e13e4..ce94059d29 100644
--- a/binaries/data/mods/public/simulation/components/Foundation.js
+++ b/binaries/data/mods/public/simulation/components/Foundation.js
@@ -5,6 +5,13 @@ Foundation.prototype.Schema =
 
 Foundation.prototype.Init = function()
 {
+	// Foundations are initially 'uncommitted' and do not block unit movement at all
+	// (to prevent players exploiting free foundations to confuse enemy units).
+	// The first builder to reach the uncommitted foundation will tell friendly units
+	// and animals to move out of the way, then will commit the foundation and enable
+	// its obstruction once there's nothing in the way.
+	this.committed = false;
+
 	this.buildProgress = 0.0; // 0 <= progress <= 1
 };
 
@@ -63,6 +70,46 @@ Foundation.prototype.Build = function(builderEnt, work)
 	if (this.buildProgress == 1.0)
 		return;
 
+	// Handle the initial 'committing' of the foundation
+	if (!this.committed)
+	{
+		var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
+		if (cmpObstruction)
+		{
+			// If there's any units in the way, ask them to move away
+			// and return early from this method.
+			// Otherwise enable this obstruction so it blocks any further
+			// units, and continue building.
+
+			var collisions = cmpObstruction.GetConstructionCollisions();
+			if (collisions.length)
+			{
+				for each (var ent in collisions)
+				{
+					var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+					if (cmpUnitAI)
+						cmpUnitAI.LeaveFoundation(this.entity);
+
+					var cmpAnimalAI = Engine.QueryInterface(ent, IID_AnimalAI);
+					if (cmpAnimalAI)
+						cmpAnimalAI.LeaveFoundation(this.entity);
+
+					// TODO: What if an obstruction has no UnitAI/AnimalAI?
+				}
+
+				// TODO: maybe we should tell the builder to use a special
+				// animation to indicate they're waiting for people to get
+				// out the way
+
+				return;
+			}
+
+			cmpObstruction.SetActive(true);
+		}
+
+		this.committed = true;
+	}
+
 	// Calculate the amount of progress that will be added (where 1.0 = completion)
 	var cmpCost = Engine.QueryInterface(this.entity, IID_Cost);
 	var amount = work / cmpCost.GetBuildTime();
diff --git a/binaries/data/mods/public/simulation/components/GuiInterface.js b/binaries/data/mods/public/simulation/components/GuiInterface.js
index 3fed57d5ca..8dfdc26e4d 100644
--- a/binaries/data/mods/public/simulation/components/GuiInterface.js
+++ b/binaries/data/mods/public/simulation/components/GuiInterface.js
@@ -412,7 +412,7 @@ GuiInterface.prototype.SetBuildingPlacementPreview = function(player, cmd)
 
 		// Check whether it's obstructed by other entities
 		var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
-		var colliding = (cmpObstruction && cmpObstruction.CheckCollisions());
+		var colliding = (cmpObstruction && cmpObstruction.CheckFoundationCollisions());
 
 		// Check whether it's in a visible region
 		var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
diff --git a/binaries/data/mods/public/simulation/components/TrainingQueue.js b/binaries/data/mods/public/simulation/components/TrainingQueue.js
index 91ca31b3b7..7a7c4842cf 100644
--- a/binaries/data/mods/public/simulation/components/TrainingQueue.js
+++ b/binaries/data/mods/public/simulation/components/TrainingQueue.js
@@ -253,7 +253,11 @@ TrainingQueue.prototype.SpawnUnits = function(templateName, count, metadata)
 		}
 	}
 
-	Engine.PostMessage(this.entity, MT_TrainingFinished, { "entities": ents, "metadata": metadata });
+	Engine.PostMessage(this.entity, MT_TrainingFinished, {
+		"entities": ents,
+		"owner": cmpOwnership.GetOwner(),
+		"metadata": metadata,
+	});
 };
 
 TrainingQueue.prototype.ProgressTimeout = function(data)
diff --git a/binaries/data/mods/public/simulation/components/UnitAI.js b/binaries/data/mods/public/simulation/components/UnitAI.js
index 96fe02f6b2..b6001c95f9 100644
--- a/binaries/data/mods/public/simulation/components/UnitAI.js
+++ b/binaries/data/mods/public/simulation/components/UnitAI.js
@@ -59,6 +59,13 @@ var UnitFsmSpec = {
 		this.SetNextState("FORMATIONMEMBER.WALKING");
 	},
 
+	// Special orders:
+	// (these will be overridden by various states)
+
+	"Order.LeaveFoundation": function(msg) {
+		// Default behaviour is to ignore the order since we're busy
+		this.FinishOrder();
+	},
 
 	// Individual orders:
 	// (these will switch the unit out of formation mode)
@@ -360,6 +367,25 @@ var UnitFsmSpec = {
 					Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
 				}
 			},
+
+			// Override the LeaveFoundation order since we're not doing
+			// anything more important
+			"Order.LeaveFoundation": function(msg) {
+				// Move a tile outside the building
+				var range = 4;
+				var ok = this.MoveToTargetRangeExplicit(this.order.data.target, range, range);
+				if (ok)
+				{
+					// We've started walking to the given point
+					this.SetNextState("INDIVIDUAL.WALKING");
+				}
+				else
+				{
+					// We are already at the target, or can't move at all
+					this.FinishOrder();
+				}
+			},
+
 		},
 
 		"WALKING": {
@@ -718,6 +744,9 @@ var UnitFsmSpec = {
 				if (msg.data.entity != this.order.data.target)
 					return; // ignore other buildings
 
+				// Save the current order's data in case we need it later
+				var oldAutocontinue = this.order.data.autocontinue;
+
 				// We finished building it.
 				// Switch to the next order (if any)
 				if (this.FinishOrder())
@@ -725,6 +754,11 @@ var UnitFsmSpec = {
 
 				// No remaining orders - pick a useful default behaviour
 
+				// If autocontinue explicitly disabled (e.g. by AI) then
+				// do nothing automatically
+				if (!oldAutocontinue)
+					return;
+
 				// If this building was e.g. a farm, we should start gathering from it
 				// if we are capable of doing so
 				if (this.CanGather(msg.data.newentity))
@@ -1226,6 +1260,12 @@ UnitAI.prototype.MoveToTargetRange = function(target, iid, type)
 	return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
 };
 
+UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max)
+{
+	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+	return cmpUnitMotion.MoveToTargetRange(target, min, max);
+};
+
 UnitAI.prototype.CheckTargetRange = function(target, iid, type)
 {
 	var cmpRanged = Engine.QueryInterface(this.entity, iid);
@@ -1322,6 +1362,7 @@ UnitAI.prototype.ComputeWalkingDistance = function()
 			break; // and continue the loop
 
 		case "WalkToTarget":
+		case "LeaveFoundation":
 		case "Attack":
 		case "Gather":
 		case "ReturnResource":
@@ -1370,6 +1411,15 @@ UnitAI.prototype.WalkToTarget = function(target, queued)
 	this.AddOrder("WalkToTarget", { "target": target }, queued);
 };
 
+UnitAI.prototype.LeaveFoundation = function(target)
+{
+	// TODO: we should verify this is a friendly foundation, otherwise
+	// there's no reason we should let them build here
+
+	var queued = true;
+	this.AddOrder("LeaveFoundation", { "target": target }, queued);
+};
+
 UnitAI.prototype.Attack = function(target, queued)
 {
 	if (!this.CanAttack(target))
diff --git a/binaries/data/mods/public/simulation/data/pathfinder.xml b/binaries/data/mods/public/simulation/data/pathfinder.xml
index cd2c17f325..bebef737d5 100644
--- a/binaries/data/mods/public/simulation/data/pathfinder.xml
+++ b/binaries/data/mods/public/simulation/data/pathfinder.xml
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Pathfinder>
+
   <PassabilityClasses>
+
+    <!-- Unit pathfinding classes: -->
     <default>
       <MaxWaterDepth>2</MaxWaterDepth>
       <MaxTerrainSlope>1.0</MaxTerrainSlope>
@@ -8,6 +11,12 @@
     <ship>
       <MinWaterDepth>1</MinWaterDepth>
     </ship>
+    <!-- Building construction classes: -->
+    <building-land>
+      <MaxWaterDepth>0</MaxWaterDepth>
+      <MaxTerrainSlope>1.0</MaxTerrainSlope>
+    </building-land>
+
   </PassabilityClasses>
   
   <!--
diff --git a/binaries/data/mods/public/simulation/helpers/Commands.js b/binaries/data/mods/public/simulation/helpers/Commands.js
index e4fe31ead1..d3c69e9d2d 100644
--- a/binaries/data/mods/public/simulation/helpers/Commands.js
+++ b/binaries/data/mods/public/simulation/helpers/Commands.js
@@ -65,6 +65,19 @@ function ProcessCommand(player, cmd)
 		break;
 
 	case "construct":
+		// Message structure:
+		// {
+		//   "type": "construct",
+		//   "entities": [...],
+		//   "template": "...",
+		//   "x": ...,
+		//   "z": ...,
+		//   "angle": ...,
+		//   "autorepair": true, // whether to automatically start constructing/repairing the new foundation
+		//   "autocontinue": true, // whether to automatically gather/build/etc after finishing this
+		//   "queued": true,
+		// }
+
 		/*
 		 * Construction process:
 		 *  . Take resources away immediately.
@@ -90,9 +103,10 @@ function ProcessCommand(player, cmd)
 
 		// Check whether it's obstructed by other entities
 		var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
-		if (cmpObstruction && cmpObstruction.CheckCollisions())
+		if (cmpObstruction && cmpObstruction.CheckFoundationCollisions())
 		{
 			// TODO: report error to player (the building site was obstructed)
+			print("Building site was obstructed\n");
 
 			// Remove the foundation because the construction was aborted
 			Engine.DestroyEntity(ent);
@@ -100,15 +114,22 @@ function ProcessCommand(player, cmd)
 			break;
 		}
 
+		/* TODO: the AI isn't smart enough to explore before building, so we'll
+		 * just disable the requirement that the location is visible. Should we
+		 * fix that, or let players build in fog too, or something?
+
 		// Check whether it's in a visible region
 		var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 		var visible = (cmpRangeManager.GetLosVisibility(ent, player) == "visible");
 		if (!visible)
 		{
 			// TODO: report error to player (the building site was not visible)
+			print("Building site was not visible\n");
+
 			Engine.DestroyEntity(ent);
 			break;
 		}
+		*/
 
 		var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 		var cmpBuildLimits = Engine.QueryInterface(playerEnt, IID_BuildLimits);
@@ -135,12 +156,15 @@ function ProcessCommand(player, cmd)
 		cmpFoundation.InitialiseConstruction(player, cmd.template);
 
 		// Tell the units to start building this new entity
-		ProcessCommand(player, {
-			"type": "repair",
-			"entities": cmd.entities,
-			"target": ent,
-			"queued": cmd.queued
-		});
+		if (cmd.autorepair)
+		{
+			ProcessCommand(player, {
+				"type": "repair",
+				"entities": cmd.entities,
+				"target": ent,
+				"queued": cmd.queued
+			});
+		}
 
 		break;
 	
diff --git a/binaries/data/mods/public/simulation/templates/template_gaia.xml b/binaries/data/mods/public/simulation/templates/template_gaia.xml
index 49b6fd1c86..8f0b1e4393 100644
--- a/binaries/data/mods/public/simulation/templates/template_gaia.xml
+++ b/binaries/data/mods/public/simulation/templates/template_gaia.xml
@@ -15,4 +15,11 @@
     <HeightOffset>5.0</HeightOffset>
   </StatusBars>
   <OverlayRenderer/>
+  <Obstruction>
+    <Active>true</Active>
+    <BlockMovement>true</BlockMovement>
+    <BlockPathfinding>true</BlockPathfinding>
+    <BlockFoundation>true</BlockFoundation>
+    <BlockConstruction>true</BlockConstruction>
+  </Obstruction>
 </Entity>
diff --git a/binaries/data/mods/public/simulation/templates/template_gaia_flora_bush.xml b/binaries/data/mods/public/simulation/templates/template_gaia_flora_bush.xml
index 33012b70f3..9ff9c6bdde 100644
--- a/binaries/data/mods/public/simulation/templates/template_gaia_flora_bush.xml
+++ b/binaries/data/mods/public/simulation/templates/template_gaia_flora_bush.xml
@@ -9,5 +9,7 @@
   </Footprint>
   <Obstruction>
     <Unit radius="1.0"/>
+    <BlockMovement>false</BlockMovement>
+    <BlockPathfinding>false</BlockPathfinding>
   </Obstruction>
 </Entity>
diff --git a/binaries/data/mods/public/simulation/templates/template_structure.xml b/binaries/data/mods/public/simulation/templates/template_structure.xml
index 403a827e62..788cbcf596 100644
--- a/binaries/data/mods/public/simulation/templates/template_structure.xml
+++ b/binaries/data/mods/public/simulation/templates/template_structure.xml
@@ -61,4 +61,11 @@
     <DefaultArrowCount>0</DefaultArrowCount>
     <GarrisonArrowMultiplier>0</GarrisonArrowMultiplier>
   </BuildingAI>
+  <Obstruction>
+    <Active>true</Active>
+    <BlockMovement>true</BlockMovement>
+    <BlockPathfinding>true</BlockPathfinding>
+    <BlockFoundation>true</BlockFoundation>
+    <BlockConstruction>true</BlockConstruction>
+  </Obstruction>
 </Entity>
diff --git a/binaries/data/mods/public/simulation/templates/template_structure_gaia_settlement.xml b/binaries/data/mods/public/simulation/templates/template_structure_gaia_settlement.xml
index 18558fa579..6c3c3aedab 100644
--- a/binaries/data/mods/public/simulation/templates/template_structure_gaia_settlement.xml
+++ b/binaries/data/mods/public/simulation/templates/template_structure_gaia_settlement.xml
@@ -17,6 +17,11 @@
   </Footprint>
   <Obstruction>
     <Static width="32.0" depth="32.0"/>
+    <Active>true</Active>
+    <BlockMovement>false</BlockMovement>
+    <BlockPathfinding>false</BlockPathfinding>
+    <BlockFoundation>true</BlockFoundation>
+    <BlockConstruction>true</BlockConstruction>
   </Obstruction>
   <Vision>
     <Range>0</Range>
diff --git a/binaries/data/mods/public/simulation/templates/template_structure_resource_field.xml b/binaries/data/mods/public/simulation/templates/template_structure_resource_field.xml
index 5168dc0ed1..cc827cb6a2 100644
--- a/binaries/data/mods/public/simulation/templates/template_structure_resource_field.xml
+++ b/binaries/data/mods/public/simulation/templates/template_structure_resource_field.xml
@@ -40,7 +40,9 @@
     <Height>2.0</Height>
   </Footprint>
   <Obstruction>
-    <Static width="12.0" depth="12.0"/>
+    <Static width="18.0" depth="18.0"/>
+    <BlockMovement>false</BlockMovement>
+    <BlockPathfinding>false</BlockPathfinding>
   </Obstruction>
   <Vision>
     <Range>28</Range>
diff --git a/binaries/data/mods/public/simulation/templates/template_unit.xml b/binaries/data/mods/public/simulation/templates/template_unit.xml
index bb46b76ae0..bfe383bd2f 100644
--- a/binaries/data/mods/public/simulation/templates/template_unit.xml
+++ b/binaries/data/mods/public/simulation/templates/template_unit.xml
@@ -77,6 +77,11 @@
   </Footprint>
   <Obstruction>
     <Unit radius="0.8"/>
+    <Active>true</Active>
+    <BlockMovement>true</BlockMovement>
+    <BlockPathfinding>false</BlockPathfinding>
+    <BlockFoundation>false</BlockFoundation>
+    <BlockConstruction>true</BlockConstruction>
   </Obstruction>
   <Vision>
     <Range>24</Range>
diff --git a/binaries/data/mods/public/simulation/templates/template_unit_fauna_fish.xml b/binaries/data/mods/public/simulation/templates/template_unit_fauna_fish.xml
index 5a8093d7ce..3b10a16dc8 100644
--- a/binaries/data/mods/public/simulation/templates/template_unit_fauna_fish.xml
+++ b/binaries/data/mods/public/simulation/templates/template_unit_fauna_fish.xml
@@ -10,10 +10,12 @@
   </Footprint>
   <Obstruction>
     <Unit radius="0.1"/>
+    <BlockMovement>false</BlockMovement>
+    <BlockPathfinding>false</BlockPathfinding>
   </Obstruction>
   <Position>
-	<Altitude>-4.0</Altitude>
-	<Floating>true</Floating>
+    <Altitude>-4.0</Altitude>
+    <Floating>true</Floating>
   </Position>
   <UnitMotion disable=""/>
   <AnimalAI disable=""/>
diff --git a/source/ps/Util.cpp b/source/ps/Util.cpp
index 1a1113fdfb..7106db418f 100644
--- a/source/ps/Util.cpp
+++ b/source/ps/Util.cpp
@@ -194,7 +194,7 @@ const wchar_t* ErrorString(int err)
 // write the specified texture to disk.
 // note: <t> cannot be made const because the image may have to be
 // transformed to write it out in the format determined by <fn>'s extension.
-static LibError tex_write(Tex* t, const VfsPath& filename)
+LibError tex_write(Tex* t, const VfsPath& filename)
 {
 	const std::wstring extension = fs::extension(filename);
 
diff --git a/source/ps/Util.h b/source/ps/Util.h
index 695594e754..fa0b6694f2 100644
--- a/source/ps/Util.h
+++ b/source/ps/Util.h
@@ -18,6 +18,10 @@
 #ifndef PS_UTIL_H
 #define PS_UTIL_H
 
+#include "lib/file/vfs/vfs_path.h"
+
+struct Tex;
+
 extern void WriteSystemInfo();
 
 extern const wchar_t* ErrorString(int err);
@@ -25,4 +29,6 @@ extern const wchar_t* ErrorString(int err);
 extern void WriteScreenshot(const std::wstring& extension);
 extern void WriteBigScreenshot(const std::wstring& extension, int tiles);
 
+extern LibError tex_write(Tex* t, const VfsPath& filename);
+
 #endif // PS_UTIL_H
diff --git a/source/scriptinterface/ScriptConversions.cpp b/source/scriptinterface/ScriptConversions.cpp
index 716497ba0c..9183a1b3b0 100644
--- a/source/scriptinterface/ScriptConversions.cpp
+++ b/source/scriptinterface/ScriptConversions.cpp
@@ -25,6 +25,10 @@
 
 #include "js/jsapi.h"
 
+#define signbit std::signbit
+#include "js/jstypedarray.h"
+#undef signbit
+
 #define FAIL(msg) STMT(JS_ReportError(cx, msg); return false)
 
 // Implicit type conversions often hide bugs, so warn about them
@@ -146,6 +150,11 @@ template<> jsval ScriptInterface::ToJSVal<i32>(JSContext* UNUSED(cx), const i32&
 	return INT_TO_JSVAL(val);
 }
 
+template<> jsval ScriptInterface::ToJSVal<u16>(JSContext* UNUSED(cx), const u16& val)
+{
+	return INT_TO_JSVAL(val);
+}
+
 template<> jsval ScriptInterface::ToJSVal<u32>(JSContext* cx, const u32& val)
 {
 	if (val <= JSVAL_INT_MAX)
@@ -225,7 +234,7 @@ template<typename T> static jsval ToJSVal_vector(JSContext* cx, const std::vecto
 template<typename T> static bool FromJSVal_vector(JSContext* cx, jsval v, std::vector<T>& out)
 {
 	JSObject* obj;
-	if (!JS_ValueToObject(cx, v, &obj) || obj == NULL || !JS_IsArrayObject(cx, obj))
+	if (!JS_ValueToObject(cx, v, &obj) || obj == NULL || !(JS_IsArrayObject(cx, obj) || js_IsTypedArray(obj)))
 		FAIL("Argument must be an array");
 	jsuint length;
 	if (!JS_GetArrayLength(cx, obj, &length))
diff --git a/source/simulation2/components/CCmpAIManager.cpp b/source/simulation2/components/CCmpAIManager.cpp
index b600f7dea4..c38e85ad46 100644
--- a/source/simulation2/components/CCmpAIManager.cpp
+++ b/source/simulation2/components/CCmpAIManager.cpp
@@ -20,12 +20,17 @@
 #include "simulation2/system/Component.h"
 #include "ICmpAIManager.h"
 
+#include "graphics/Terrain.h"
 #include "lib/timer.h"
+#include "lib/tex/tex.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
+#include "ps/Util.h"
 #include "simulation2/components/ICmpAIInterface.h"
 #include "simulation2/components/ICmpCommandQueue.h"
+#include "simulation2/components/ICmpObstructionManager.h"
 #include "simulation2/components/ICmpTemplateManager.h"
+#include "simulation2/helpers/Grid.h"
 #include "simulation2/serialization/DebugSerializer.h"
 #include "simulation2/serialization/StdDeserializer.h"
 #include "simulation2/serialization/StdSerializer.h"
@@ -73,6 +78,8 @@ private:
 
 			m_ScriptInterface.RegisterFunction<void, std::wstring, CAIPlayer::IncludeModule>("IncludeModule");
 			m_ScriptInterface.RegisterFunction<void, CScriptValRooted, CAIPlayer::PostCommand>("PostCommand");
+
+			m_ScriptInterface.RegisterFunction<void, std::wstring, std::vector<u32>, u32, u32, u32, CAIPlayer::DumpImage>("DumpImage");
 		}
 
 		~CAIPlayer()
@@ -95,6 +102,45 @@ private:
 			self->m_Commands.push_back(self->m_ScriptInterface.WriteStructuredClone(cmd.get()));
 		}
 
+		/**
+		 * Debug function for AI scripts to dump 2D array data (e.g. terrain tile weights).
+		 */
+		static void DumpImage(void* UNUSED(cbdata), std::wstring name, std::vector<u32> data, u32 w, u32 h, u32 max)
+		{
+			// TODO: this is totally not threadsafe.
+
+			VfsPath filename = L"screenshots/aidump/" + name;
+
+			if (data.size() != w*h)
+			{
+				debug_warn(L"DumpImage: data size doesn't match w*h");
+				return;
+			}
+
+			if (max == 0)
+			{
+				debug_warn(L"DumpImage: max must not be 0");
+				return;
+			}
+
+			const size_t bpp = 8;
+			int flags = TEX_BOTTOM_UP|TEX_GREY;
+
+			const size_t img_size = w * h * bpp/8;
+			const size_t hdr_size = tex_hdr_size(filename);
+			shared_ptr<u8> buf = io_Allocate(hdr_size+img_size);
+			Tex t;
+			if (tex_wrap(w, h, bpp, flags, buf, hdr_size, &t) < 0)
+				return;
+
+			u8* img = buf.get() + hdr_size;
+			for (size_t i = 0; i < data.size(); ++i)
+				img[i] = (data[i] * 255) / max;
+
+			tex_write(&t, filename);
+			tex_free(&t);
+		}
+
 		bool LoadScripts(const std::wstring& moduleName)
 		{
 			// Ignore modules that are already loaded
@@ -451,6 +497,10 @@ public:
 		// Get the game state from AIInterface
 		CScriptVal state = cmpAIInterface->GetRepresentation();
 
+		LoadTerrainData(state);
+
+		LoadPathfinderClasses(state);
+
 		m_Worker.StartComputation(scriptInterface.WriteStructuredClone(state.get()));
 	}
 
@@ -498,6 +548,40 @@ private:
 		m_Worker.LoadEntityTemplates(templates);
 	}
 
+	void LoadTerrainData(CScriptVal state)
+	{
+		PROFILE("LoadTerrainData");
+
+		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
+		if (cmpPathfinder.null())
+			return;
+
+		const Grid<u16>& grid = cmpPathfinder->GetPassabilityGrid();
+
+		ScriptInterface& scriptInterface = GetSimContext().GetScriptInterface();
+		scriptInterface.SetProperty(state.get(), "map", grid, true);
+		// (If this is slow, maybe we should only bother uploading the data
+		// if it's changed since last turn)
+	}
+
+	void LoadPathfinderClasses(CScriptVal state)
+	{
+		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
+		if (cmpPathfinder.null())
+			return;
+
+		ScriptInterface& scriptInterface = GetSimContext().GetScriptInterface();
+
+		CScriptVal classesVal;
+		scriptInterface.Eval("({ pathfinderObstruction: 1, foundationObstruction: 2 })", classesVal);
+
+		std::map<std::string, ICmpPathfinder::pass_class_t> classes = cmpPathfinder->GetPassabilityClasses();
+		for (std::map<std::string, ICmpPathfinder::pass_class_t>::iterator it = classes.begin(); it != classes.end(); ++it)
+			scriptInterface.SetProperty(classesVal.get(), it->first.c_str(), it->second, true);
+
+		scriptInterface.SetProperty(state.get(), "passabilityClasses", classesVal, true);
+	}
+
 	CAIWorker m_Worker;
 };
 
diff --git a/source/simulation2/components/CCmpFootprint.cpp b/source/simulation2/components/CCmpFootprint.cpp
index cfd487b32d..2121e751e1 100644
--- a/source/simulation2/components/CCmpFootprint.cpp
+++ b/source/simulation2/components/CCmpFootprint.cpp
@@ -168,7 +168,7 @@ public:
 				CFixedVector3D pos (initialPos.X + s.Multiply(radius), fixed::Zero(), initialPos.Y + c.Multiply(radius));
 
 				SkipTagObstructionFilter filter(spawnedTag); // ignore collisions with the spawned entity
-				if (!cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Z, spawnedRadius))
+				if (!cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Z, spawnedRadius, NULL))
 					return pos; // this position is okay, so return it
 			}
 		}
@@ -216,7 +216,7 @@ public:
 					CFixedVector2D pos (center + dir*i);
 
 					SkipTagObstructionFilter filter(spawnedTag); // ignore collisions with the spawned entity
-					if (!cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, spawnedRadius))
+					if (!cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, spawnedRadius, NULL))
 						return CFixedVector3D(pos.X, fixed::Zero(), pos.Y); // this position is okay, so return it
 				}
 			}
diff --git a/source/simulation2/components/CCmpObstruction.cpp b/source/simulation2/components/CCmpObstruction.cpp
index f01ec81b3f..c80d910d1f 100644
--- a/source/simulation2/components/CCmpObstruction.cpp
+++ b/source/simulation2/components/CCmpObstruction.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -48,10 +48,11 @@ public:
 	} m_Type;
 	entity_pos_t m_Size0; // radius or width
 	entity_pos_t m_Size1; // radius or depth
-	bool m_Active; // whether the obstruction is obstructing or just an inactive placeholder
+	u8 m_Flags;
 
 	// Dynamic state:
 
+	bool m_Active; // whether the obstruction is obstructing or just an inactive placeholder
 	bool m_Moving;
 	entity_id_t m_ControlGroup;
 	ICmpObstructionManager::tag_t m_Tag;
@@ -60,7 +61,7 @@ public:
 	{
 		return
 			"<a:example/>"
-			"<a:help>Causes this entity's footprint to obstruct the motion of other units.</a:help>"
+			"<a:help>Causes this entity to obstruct the motion of other units.</a:help>"
 			"<choice>"
 				"<element name='Static'>"
 					"<attribute name='width'>"
@@ -76,11 +77,21 @@ public:
 					"</attribute>"
 				"</element>"
 			"</choice>"
-			"<optional>"
-				"<element name='Inactive' a:help='If this element is present, this entity will be ignored in collision tests by other units but can still perform its own collision tests'>"
-					"<empty/>"
-				"</element>"
-			"</optional>";
+			"<element name='Active' a:help='If false, this entity will be ignored in collision tests by other units but can still perform its own collision tests'>"
+				"<data type='boolean'/>"
+			"</element>"
+			"<element name='BlockMovement' a:help='Whether units should be allowed to walk through this entity'>"
+				"<data type='boolean'/>"
+			"</element>"
+			"<element name='BlockPathfinding' a:help='Whether the long-distance pathfinder should avoid paths through this entity. This should only be set for large stationary obstructions'>"
+				"<data type='boolean'/>"
+			"</element>"
+			"<element name='BlockFoundation' a:help='Whether players should be unable to place building foundations on top of this entity. If true, BlockConstruction should be true too'>"
+				"<data type='boolean'/>"
+			"</element>"
+			"<element name='BlockConstruction' a:help='Whether players should be unable to begin constructing buildings placed on top of this entity'>"
+				"<data type='boolean'/>"
+			"</element>";
 	}
 
 	virtual void Init(const CParamNode& paramNode)
@@ -97,10 +108,17 @@ public:
 			m_Size1 = paramNode.GetChild("Static").GetChild("@depth").ToFixed();
 		}
 
-		if (paramNode.GetChild("Inactive").IsOk())
-			m_Active = false;
-		else
-			m_Active = true;
+		m_Flags = 0;
+		if (paramNode.GetChild("BlockMovement").ToBool())
+			m_Flags |= ICmpObstructionManager::FLAG_BLOCK_MOVEMENT;
+		if (paramNode.GetChild("BlockPathfinding").ToBool())
+			m_Flags |= ICmpObstructionManager::FLAG_BLOCK_PATHFINDING;
+		if (paramNode.GetChild("BlockFoundation").ToBool())
+			m_Flags |= ICmpObstructionManager::FLAG_BLOCK_FOUNDATION;
+		if (paramNode.GetChild("BlockConstruction").ToBool())
+			m_Flags |= ICmpObstructionManager::FLAG_BLOCK_CONSTRUCTION;
+
+		m_Active = paramNode.GetChild("Active").ToBool();
 
 		m_Tag = ICmpObstructionManager::tag_t();
 		m_Moving = false;
@@ -114,6 +132,7 @@ public:
 	template<typename S>
 	void SerializeCommon(S& serialize)
 	{
+		serialize.Bool("active", m_Active);
 		serialize.Bool("moving", m_Moving);
 		serialize.NumberU32_Unbounded("control group", m_ControlGroup);
 		serialize.NumberU32_Unbounded("tag", m_Tag.n);
@@ -147,7 +166,7 @@ public:
 
 			CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
 			if (cmpObstructionManager.null())
-				break;
+				break; // error
 
 			if (data.inWorld && m_Tag.valid())
 			{
@@ -157,9 +176,11 @@ public:
 			{
 				// Need to create a new pathfinder shape:
 				if (m_Type == STATIC)
-					m_Tag = cmpObstructionManager->AddStaticShape(data.x, data.z, data.a, m_Size0, m_Size1);
+					m_Tag = cmpObstructionManager->AddStaticShape(GetEntityId(),
+						data.x, data.z, data.a, m_Size0, m_Size1, m_Flags);
 				else
-					m_Tag = cmpObstructionManager->AddUnitShape(data.x, data.z, m_Size0, m_Moving, m_ControlGroup);
+					m_Tag = cmpObstructionManager->AddUnitShape(GetEntityId(),
+						data.x, data.z, m_Size0, m_Flags | (m_Moving ? ICmpObstructionManager::FLAG_MOVING : 0), m_ControlGroup);
 			}
 			else if (!data.inWorld && m_Tag.valid())
 			{
@@ -174,7 +195,7 @@ public:
 			{
 				CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
 				if (cmpObstructionManager.null())
-					break;
+					break; // error
 
 				cmpObstructionManager->RemoveShape(m_Tag);
 				m_Tag = ICmpObstructionManager::tag_t();
@@ -184,11 +205,78 @@ public:
 		}
 	}
 
+	virtual void SetActive(bool active)
+	{
+		if (active && !m_Active)
+		{
+			m_Active = true;
+
+			// Construct the obstruction shape
+
+			CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+			if (cmpObstructionManager.null())
+				return; // error
+
+			CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
+			if (cmpPosition.null())
+				return; // error
+
+			if (!cmpPosition->IsInWorld())
+				return; // don't need an obstruction
+
+			CFixedVector2D pos = cmpPosition->GetPosition2D();
+			if (m_Type == STATIC)
+				m_Tag = cmpObstructionManager->AddStaticShape(GetEntityId(),
+					pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1, m_Flags);
+			else
+				m_Tag = cmpObstructionManager->AddUnitShape(GetEntityId(),
+					pos.X, pos.Y, m_Size0, m_Flags | (m_Moving ? ICmpObstructionManager::FLAG_MOVING : 0), m_ControlGroup);
+		}
+		else if (!active && m_Active)
+		{
+			m_Active = false;
+
+			// Delete the obstruction shape
+
+			if (m_Tag.valid())
+			{
+				CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+				if (cmpObstructionManager.null())
+					return; // error
+
+				cmpObstructionManager->RemoveShape(m_Tag);
+				m_Tag = ICmpObstructionManager::tag_t();
+			}
+		}
+		// else we didn't change the active status
+	}
+
 	virtual ICmpObstructionManager::tag_t GetObstruction()
 	{
 		return m_Tag;
 	}
 
+	virtual bool GetObstructionSquare(ICmpObstructionManager::ObstructionSquare& out)
+	{
+		CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
+		if (cmpPosition.null())
+			return false; // error
+
+		CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+		if (cmpObstructionManager.null())
+			return false; // error
+
+		if (!cmpPosition->IsInWorld())
+			return false; // no obstruction square
+
+		CFixedVector2D pos = cmpPosition->GetPosition2D();
+		if (m_Type == STATIC)
+			out = cmpObstructionManager->GetStaticShapeObstruction(pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1);
+		else
+			out = cmpObstructionManager->GetUnitShapeObstruction(pos.X, pos.Y, m_Size0);
+		return true;
+	}
+
 	virtual entity_pos_t GetUnitRadius()
 	{
 		if (m_Type == UNIT)
@@ -197,22 +285,56 @@ public:
 			return entity_pos_t::Zero();
 	}
 
-	virtual bool CheckCollisions()
+	virtual bool CheckFoundationCollisions()
 	{
 		CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
 		if (cmpPosition.null())
-			return false;
+			return false; // error
+
+		if (!cmpPosition->IsInWorld())
+			return false; // no obstruction
 
 		CFixedVector2D pos = cmpPosition->GetPosition2D();
 
 		CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+		if (cmpObstructionManager.null())
+			return false; // error
 
-		SkipTagObstructionFilter filter(m_Tag); // ignore collisions with self
+		// Ignore collisions with self, or with non-foundation-blocking obstructions
+		SkipTagFlagsObstructionFilter filter(m_Tag, ICmpObstructionManager::FLAG_BLOCK_FOUNDATION);
 
 		if (m_Type == STATIC)
-			return cmpObstructionManager->TestStaticShape(filter, pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1);
+			return cmpObstructionManager->TestStaticShape(filter, pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1, NULL);
 		else
-			return cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, m_Size0);
+			return cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, m_Size0, NULL);
+	}
+
+	virtual std::vector<entity_id_t> GetConstructionCollisions()
+	{
+		std::vector<entity_id_t> ret;
+
+		CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
+		if (cmpPosition.null())
+			return ret; // error
+
+		if (!cmpPosition->IsInWorld())
+			return ret; // no obstruction
+
+		CFixedVector2D pos = cmpPosition->GetPosition2D();
+
+		CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+		if (cmpObstructionManager.null())
+			return ret; // error
+
+		// Ignore collisions with self, or with non-construction-blocking obstructions
+		SkipTagFlagsObstructionFilter filter(m_Tag, ICmpObstructionManager::FLAG_BLOCK_CONSTRUCTION);
+
+		if (m_Type == STATIC)
+			cmpObstructionManager->TestStaticShape(filter, pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1, &ret);
+		else
+			cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, m_Size0, &ret);
+
+		return ret;
 	}
 
 	virtual void SetMovingFlag(bool enabled)
diff --git a/source/simulation2/components/CCmpObstructionManager.cpp b/source/simulation2/components/CCmpObstructionManager.cpp
index c1b2d00ab4..64ca4bd324 100644
--- a/source/simulation2/components/CCmpObstructionManager.cpp
+++ b/source/simulation2/components/CCmpObstructionManager.cpp
@@ -48,9 +48,10 @@
  */
 struct UnitShape
 {
+	entity_id_t entity;
 	entity_pos_t x, z;
 	entity_pos_t r; // radius of circle, or half width of square
-	bool moving; // whether it's currently mobile (and should be generally ignored when pathing)
+	u8 flags;
 	entity_id_t group; // control group (typically the owner entity, or a formation controller entity) (units ignore collisions with others in the same group)
 };
 
@@ -59,9 +60,11 @@ struct UnitShape
  */
 struct StaticShape
 {
+	entity_id_t entity;
 	entity_pos_t x, z; // world-space coordinates
 	CFixedVector2D u, v; // orthogonal unit vectors - axes of local coordinate space
 	entity_pos_t hw, hh; // half width/height in local coordinate space
+	u8 flags;
 };
 
 /**
@@ -72,10 +75,11 @@ struct SerializeUnitShape
 	template<typename S>
 	void operator()(S& serialize, const char* UNUSED(name), UnitShape& value)
 	{
+		serialize.NumberU32_Unbounded("entity", value.entity);
 		serialize.NumberFixed_Unbounded("x", value.x);
 		serialize.NumberFixed_Unbounded("z", value.z);
 		serialize.NumberFixed_Unbounded("r", value.r);
-		serialize.Bool("moving", value.moving);
+		serialize.NumberU8_Unbounded("flags", value.flags);
 		serialize.NumberU32_Unbounded("group", value.group);
 	}
 };
@@ -88,6 +92,7 @@ struct SerializeStaticShape
 	template<typename S>
 	void operator()(S& serialize, const char* UNUSED(name), StaticShape& value)
 	{
+		serialize.NumberU32_Unbounded("entity", value.entity);
 		serialize.NumberFixed_Unbounded("x", value.x);
 		serialize.NumberFixed_Unbounded("z", value.z);
 		serialize.NumberFixed_Unbounded("u.x", value.u.X);
@@ -96,6 +101,7 @@ struct SerializeStaticShape
 		serialize.NumberFixed_Unbounded("v.y", value.v.Y);
 		serialize.NumberFixed_Unbounded("hw", value.hw);
 		serialize.NumberFixed_Unbounded("hh", value.hh);
+		serialize.NumberU8_Unbounded("flags", value.flags);
 	}
 };
 
@@ -239,9 +245,9 @@ public:
 		}
 	}
 
-	virtual tag_t AddUnitShape(entity_pos_t x, entity_pos_t z, entity_pos_t r, bool moving, entity_id_t group)
+	virtual tag_t AddUnitShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_pos_t r, u8 flags, entity_id_t group)
 	{
-		UnitShape shape = { x, z, r, moving, group };
+		UnitShape shape = { ent, x, z, r, flags, group };
 		size_t id = m_UnitShapeNext++;
 		m_UnitShapes[id] = shape;
 		MakeDirtyUnits();
@@ -251,14 +257,14 @@ public:
 		return UNIT_INDEX_TO_TAG(id);
 	}
 
-	virtual tag_t AddStaticShape(entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h)
+	virtual tag_t AddStaticShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h, u8 flags)
 	{
 		fixed s, c;
 		sincos_approx(a, s, c);
 		CFixedVector2D u(c, -s);
 		CFixedVector2D v(s, c);
 
-		StaticShape shape = { x, z, u, v, w/2, h/2 };
+		StaticShape shape = { ent, x, z, u, v, w/2, h/2, flags };
 		size_t id = m_StaticShapeNext++;
 		m_StaticShapes[id] = shape;
 		MakeDirty();
@@ -270,6 +276,25 @@ public:
 		return STATIC_INDEX_TO_TAG(id);
 	}
 
+	virtual ObstructionSquare GetUnitShapeObstruction(entity_pos_t x, entity_pos_t z, entity_pos_t r)
+	{
+		CFixedVector2D u(entity_pos_t::FromInt(1), entity_pos_t::Zero());
+		CFixedVector2D v(entity_pos_t::Zero(), entity_pos_t::FromInt(1));
+		ObstructionSquare o = { x, z, u, v, r, r };
+		return o;
+	}
+
+	virtual ObstructionSquare GetStaticShapeObstruction(entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h)
+	{
+		fixed s, c;
+		sincos_approx(a, s, c);
+		CFixedVector2D u(c, -s);
+		CFixedVector2D v(s, c);
+
+		ObstructionSquare o = { x, z, u, v, w/2, h/2 };
+		return o;
+	}
+
 	virtual void MoveShape(tag_t tag, entity_pos_t x, entity_pos_t z, entity_angle_t a)
 	{
 		debug_assert(TAG_IS_VALID(tag));
@@ -322,7 +347,11 @@ public:
 		if (TAG_IS_UNIT(tag))
 		{
 			UnitShape& shape = m_UnitShapes[TAG_TO_INDEX(tag)];
-			shape.moving = moving;
+			if (moving)
+				shape.flags |= FLAG_MOVING;
+			else
+				shape.flags &= ~FLAG_MOVING;
+
 			MakeDirtyUnits();
 		}
 	}
@@ -387,8 +416,8 @@ public:
 	}
 
 	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);
-	virtual bool TestStaticShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h);
-	virtual bool TestUnitShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r);
+	virtual bool TestStaticShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h, std::vector<entity_id_t>* out);
+	virtual bool TestUnitShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r, std::vector<entity_id_t>* out);
 
 	virtual bool Rasterise(Grid<u8>& grid);
 	virtual void GetObstructionsInRange(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, std::vector<ObstructionSquare>& squares);
@@ -481,7 +510,7 @@ bool CCmpObstructionManager::TestLine(const IObstructionTestFilter& filter, enti
 		std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
 		debug_assert(it != m_UnitShapes.end());
 
-		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.moving, it->second.group))
+		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group))
 			continue;
 
 		CFixedVector2D center(it->second.x, it->second.z);
@@ -496,7 +525,7 @@ bool CCmpObstructionManager::TestLine(const IObstructionTestFilter& filter, enti
 		std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
 		debug_assert(it != m_StaticShapes.end());
 
-		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), false, INVALID_ENTITY))
+		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), it->second.flags, INVALID_ENTITY))
 			continue;
 
 		CFixedVector2D center(it->second.x, it->second.z);
@@ -508,12 +537,17 @@ bool CCmpObstructionManager::TestLine(const IObstructionTestFilter& filter, enti
 	return false;
 }
 
-bool CCmpObstructionManager::TestStaticShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h)
+bool CCmpObstructionManager::TestStaticShape(const IObstructionTestFilter& filter,
+	entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h,
+	std::vector<entity_id_t>* out)
 {
 	PROFILE("TestStaticShape");
 
 	// TODO: should use the subdivision stuff here, if performance is non-negligible
 
+	if (out)
+		out->clear();
+
 	fixed s, c;
 	sincos_approx(a, s, c);
 	CFixedVector2D u(c, -s);
@@ -526,34 +560,54 @@ bool CCmpObstructionManager::TestStaticShape(const IObstructionTestFilter& filte
 		!IsInWorld(center + u.Multiply(halfSize.X) - v.Multiply(halfSize.Y)) ||
 		!IsInWorld(center - u.Multiply(halfSize.X) + v.Multiply(halfSize.Y)) ||
 		!IsInWorld(center - u.Multiply(halfSize.X) - v.Multiply(halfSize.Y)))
-		return true;
+	{
+		if (out)
+			out->push_back(INVALID_ENTITY); // no entity ID, so just push an arbitrary marker
+		else
+			return true;
+	}
 
 	for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
 	{
-		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.moving, it->second.group))
+		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group))
 			continue;
 
 		CFixedVector2D center1(it->second.x, it->second.z);
 
 		if (Geometry::PointIsInSquare(center1 - center, u, v, CFixedVector2D(halfSize.X + it->second.r, halfSize.Y + it->second.r)))
-			return true;
+		{
+			if (out)
+				out->push_back(it->second.entity);
+			else
+				return true;
+		}
 	}
 
 	for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
 	{
-		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), false, INVALID_ENTITY))
+		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), it->second.flags, INVALID_ENTITY))
 			continue;
 
 		CFixedVector2D center1(it->second.x, it->second.z);
 		CFixedVector2D halfSize1(it->second.hw, it->second.hh);
 		if (Geometry::TestSquareSquare(center, u, v, halfSize, center1, it->second.u, it->second.v, halfSize1))
-			return true;
+		{
+			if (out)
+				out->push_back(it->second.entity);
+			else
+				return true;
+		}
 	}
 
-	return false;
+	if (out)
+		return !out->empty(); // collided if the list isn't empty
+	else
+		return false; // didn't collide, if we got this far
 }
 
-bool CCmpObstructionManager::TestUnitShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r)
+bool CCmpObstructionManager::TestUnitShape(const IObstructionTestFilter& filter,
+	entity_pos_t x, entity_pos_t z, entity_pos_t r,
+	std::vector<entity_id_t>* out)
 {
 	PROFILE("TestUnitShape");
 
@@ -561,31 +615,51 @@ bool CCmpObstructionManager::TestUnitShape(const IObstructionTestFilter& filter,
 
 	// Check that the shape is within the world
 	if (!IsInWorld(x, z, r))
-		return true;
+	{
+		if (out)
+			out->push_back(INVALID_ENTITY); // no entity ID, so just push an arbitrary marker
+		else
+			return true;
+	}
 
 	CFixedVector2D center(x, z);
 
 	for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
 	{
-		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.moving, it->second.group))
+		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group))
 			continue;
 
 		entity_pos_t r1 = it->second.r;
 
 		if (!(it->second.x + r1 < x - r || it->second.x - r1 > x + r || it->second.z + r1 < z - r || it->second.z - r1 > z + r))
-			return true;
+		{
+			if (out)
+				out->push_back(it->second.entity);
+			else
+				return true;
+		}
 	}
 
 	for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
 	{
-		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), false, INVALID_ENTITY))
+		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), it->second.flags, INVALID_ENTITY))
 			continue;
 
 		CFixedVector2D center1(it->second.x, it->second.z);
 		if (Geometry::PointIsInSquare(center1 - center, it->second.u, it->second.v, CFixedVector2D(it->second.hw + r, it->second.hh + r)))
-			return true;
+		{
+			if (out)
+				out->push_back(it->second.entity);
+			else
+				return true;
+
+		}
 	}
-	return false;
+
+	if (out)
+		return !out->empty(); // collided if the list isn't empty
+	else
+		return false; // didn't collide, if we got this far
 }
 
 /**
@@ -621,35 +695,93 @@ bool CCmpObstructionManager::Rasterise(Grid<u8>& grid)
 
 	grid.reset();
 
+	// For tile-based pathfinding:
+	// Since we only count tiles whose centers are inside the square,
+	// we maybe want to expand the square a bit so we're less likely to think there's
+	// free space between buildings when there isn't. But this is just a random guess
+	// and needs to be tweaked until everything works nicely.
+	//entity_pos_t expandPathfinding = entity_pos_t::FromInt(CELL_SIZE / 2);
+	// Actually that's bad because units get stuck when the A* pathfinder thinks they're
+	// blocked on all sides, so it's better to underestimate
+	entity_pos_t expandPathfinding = entity_pos_t::FromInt(0);
+
+	// For AI building foundation planning, we want to definitely block all
+	// potentially-obstructed tiles (so we don't blindly build on top of an obstruction),
+	// so we need to expand by at least 1/sqrt(2) of a tile
+	entity_pos_t expandFoundation = (entity_pos_t::FromInt(CELL_SIZE) * 3) / 4;
+
 	for (std::map<u32, StaticShape>::iterator it = m_StaticShapes.begin(); it != m_StaticShapes.end(); ++it)
 	{
 		CFixedVector2D center(it->second.x, it->second.z);
 
-		// Since we only count tiles whose centers are inside the square,
-		// we maybe want to expand the square a bit so we're less likely to think there's
-		// free space between buildings when there isn't. But this is just a random guess
-		// and needs to be tweaked until everything works nicely.
-		//entity_pos_t expand = entity_pos_t::FromInt(CELL_SIZE / 2);
-		// Actually that's bad because units get stuck when the A* pathfinder thinks they're
-		// blocked on all sides, so it's better to underestimate
-		entity_pos_t expand = entity_pos_t::FromInt(0);
-
-		CFixedVector2D halfSize(it->second.hw + expand, it->second.hh + expand);
-		CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(it->second.u, it->second.v, halfSize);
-
-		u16 i0, j0, i1, j1;
-		NearestTile(center.X - halfBound.X, center.Y - halfBound.Y, i0, j0, grid.m_W, grid.m_H);
-		NearestTile(center.X + halfBound.X, center.Y + halfBound.Y, i1, j1, grid.m_W, grid.m_H);
-		for (u16 j = j0; j <= j1; ++j)
+		if (it->second.flags & FLAG_BLOCK_PATHFINDING)
 		{
-			for (u16 i = i0; i <= i1; ++i)
+			CFixedVector2D halfSize(it->second.hw + expandPathfinding, it->second.hh + expandPathfinding);
+			CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(it->second.u, it->second.v, halfSize);
+
+			u16 i0, j0, i1, j1;
+			NearestTile(center.X - halfBound.X, center.Y - halfBound.Y, i0, j0, grid.m_W, grid.m_H);
+			NearestTile(center.X + halfBound.X, center.Y + halfBound.Y, i1, j1, grid.m_W, grid.m_H);
+			for (u16 j = j0; j <= j1; ++j)
 			{
-				entity_pos_t x, z;
-				TileCenter(i, j, x, z);
-				if (Geometry::PointIsInSquare(CFixedVector2D(x, z) - center, it->second.u, it->second.v, halfSize))
-					grid.set(i, j, TILE_OBSTRUCTED);
+				for (u16 i = i0; i <= i1; ++i)
+				{
+					entity_pos_t x, z;
+					TileCenter(i, j, x, z);
+					if (Geometry::PointIsInSquare(CFixedVector2D(x, z) - center, it->second.u, it->second.v, halfSize))
+						grid.set(i, j, grid.get(i, j) | TILE_OBSTRUCTED_PATHFINDING);
+				}
 			}
 		}
+
+		if (it->second.flags & FLAG_BLOCK_FOUNDATION)
+		{
+			CFixedVector2D halfSize(it->second.hw + expandFoundation, it->second.hh + expandFoundation);
+			CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(it->second.u, it->second.v, halfSize);
+
+			u16 i0, j0, i1, j1;
+			NearestTile(center.X - halfBound.X, center.Y - halfBound.Y, i0, j0, grid.m_W, grid.m_H);
+			NearestTile(center.X + halfBound.X, center.Y + halfBound.Y, i1, j1, grid.m_W, grid.m_H);
+			for (u16 j = j0; j <= j1; ++j)
+			{
+				for (u16 i = i0; i <= i1; ++i)
+				{
+					entity_pos_t x, z;
+					TileCenter(i, j, x, z);
+					if (Geometry::PointIsInSquare(CFixedVector2D(x, z) - center, it->second.u, it->second.v, halfSize))
+						grid.set(i, j, grid.get(i, j) | TILE_OBSTRUCTED_FOUNDATION);
+				}
+			}
+		}
+	}
+
+	for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
+	{
+		CFixedVector2D center(it->second.x, it->second.z);
+
+		if (it->second.flags & FLAG_BLOCK_PATHFINDING)
+		{
+			entity_pos_t r = it->second.r + expandPathfinding;
+
+			u16 i0, j0, i1, j1;
+			NearestTile(center.X - r, center.Y - r, i0, j0, grid.m_W, grid.m_H);
+			NearestTile(center.X + r, center.Y + r, i1, j1, grid.m_W, grid.m_H);
+			for (u16 j = j0; j <= j1; ++j)
+				for (u16 i = i0; i <= i1; ++i)
+					grid.set(i, j, grid.get(i, j) | TILE_OBSTRUCTED_PATHFINDING);
+		}
+
+		if (it->second.flags & FLAG_BLOCK_FOUNDATION)
+		{
+			entity_pos_t r = it->second.r + expandFoundation;
+
+			u16 i0, j0, i1, j1;
+			NearestTile(center.X - r, center.Y - r, i0, j0, grid.m_W, grid.m_H);
+			NearestTile(center.X + r, center.Y + r, i1, j1, grid.m_W, grid.m_H);
+			for (u16 j = j0; j <= j1; ++j)
+				for (u16 i = i0; i <= i1; ++i)
+					grid.set(i, j, grid.get(i, j) | TILE_OBSTRUCTED_FOUNDATION);
+		}
 	}
 
 	// Any tiles outside or very near the edge of the map are impassable
@@ -657,6 +789,8 @@ bool CCmpObstructionManager::Rasterise(Grid<u8>& grid)
 	// WARNING: CCmpRangeManager::LosIsOffWorld needs to be kept in sync with this
 	const ssize_t edgeSize = 3; // number of tiles around the edge that will be off-world
 
+	u8 edgeFlags = TILE_OBSTRUCTED_PATHFINDING | TILE_OBSTRUCTED_FOUNDATION | TILE_OUTOFBOUNDS;
+
 	if (m_PassabilityCircular)
 	{
 		for (u16 j = 0; j < grid.m_H; ++j)
@@ -673,7 +807,7 @@ bool CCmpObstructionManager::Rasterise(Grid<u8>& grid)
 						+ (j*2 + 1 - grid.m_H)*(j*2 + 1 - grid.m_H);
 
 				if (dist2 >= (grid.m_W - 2*edgeSize) * (grid.m_H - 2*edgeSize))
-					grid.set(i, j, TILE_OBSTRUCTED | TILE_OUTOFBOUNDS);
+					grid.set(i, j, edgeFlags);
 			}
 		}
 	}
@@ -685,16 +819,16 @@ bool CCmpObstructionManager::Rasterise(Grid<u8>& grid)
 
 		for (u16 j = 0; j < grid.m_H; ++j)
 			for (u16 i = 0; i < i0+edgeSize; ++i)
-				grid.set(i, j, TILE_OBSTRUCTED | TILE_OUTOFBOUNDS);
+				grid.set(i, j, edgeFlags);
 		for (u16 j = 0; j < grid.m_H; ++j)
 			for (u16 i = i1-edgeSize+1; i < grid.m_W; ++i)
-				grid.set(i, j, TILE_OBSTRUCTED | TILE_OUTOFBOUNDS);
+				grid.set(i, j, edgeFlags);
 		for (u16 j = 0; j < j0+edgeSize; ++j)
 			for (u16 i = i0+edgeSize; i < i1-edgeSize+1; ++i)
-				grid.set(i, j, TILE_OBSTRUCTED | TILE_OUTOFBOUNDS);
+				grid.set(i, j, edgeFlags);
 		for (u16 j = j1-edgeSize+1; j < grid.m_H; ++j)
 			for (u16 i = i0+edgeSize; i < i1-edgeSize+1; ++i)
-				grid.set(i, j, TILE_OBSTRUCTED | TILE_OUTOFBOUNDS);
+				grid.set(i, j, edgeFlags);
 	}
 
 	return true;
@@ -712,7 +846,7 @@ void CCmpObstructionManager::GetObstructionsInRange(const IObstructionTestFilter
 		std::map<u32, UnitShape>::iterator it = m_UnitShapes.find(unitShapes[i]);
 		debug_assert(it != m_UnitShapes.end());
 
-		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.moving, it->second.group))
+		if (!filter.Allowed(UNIT_INDEX_TO_TAG(it->first), it->second.flags, it->second.group))
 			continue;
 
 		entity_pos_t r = it->second.r;
@@ -733,7 +867,7 @@ void CCmpObstructionManager::GetObstructionsInRange(const IObstructionTestFilter
 		std::map<u32, StaticShape>::iterator it = m_StaticShapes.find(staticShapes[i]);
 		debug_assert(it != m_StaticShapes.end());
 
-		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), false, INVALID_ENTITY))
+		if (!filter.Allowed(STATIC_INDEX_TO_TAG(it->first), it->second.flags, INVALID_ENTITY))
 			continue;
 
 		entity_pos_t r = it->second.hw + it->second.hh; // overestimate the max dist of an edge from the center
@@ -801,7 +935,7 @@ void CCmpObstructionManager::RenderSubmit(SceneCollector& collector)
 		for (std::map<u32, UnitShape>::iterator it = m_UnitShapes.begin(); it != m_UnitShapes.end(); ++it)
 		{
 			m_DebugOverlayLines.push_back(SOverlayLine());
-			m_DebugOverlayLines.back().m_Color = (it->second.moving ? movingColour : defaultColour);
+			m_DebugOverlayLines.back().m_Color = ((it->second.flags & FLAG_MOVING) ? movingColour : defaultColour);
 			SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.r.ToFloat()*2, it->second.r.ToFloat()*2, 0, m_DebugOverlayLines.back(), true);
 		}
 
diff --git a/source/simulation2/components/CCmpPathfinder.cpp b/source/simulation2/components/CCmpPathfinder.cpp
index 15607e07ae..aa0c397059 100644
--- a/source/simulation2/components/CCmpPathfinder.cpp
+++ b/source/simulation2/components/CCmpPathfinder.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -64,7 +64,7 @@ void CCmpPathfinder::Init(const CParamNode& UNUSED(paramNode))
 	{
 		std::string name = it->first;
 		debug_assert((int)m_PassClasses.size() <= PASS_CLASS_BITS);
-		u8 mask = (u8)(1u << (m_PassClasses.size() + 1));
+		pass_class_t mask = (pass_class_t)(1u << (m_PassClasses.size() + 2));
 		m_PassClasses.push_back(PathfinderPassability(mask, it->second));
 		m_PassClassMasks[name] = mask;
 	}
@@ -82,7 +82,7 @@ void CCmpPathfinder::Init(const CParamNode& UNUSED(paramNode))
 		for (CParamNode::ChildrenMap::const_iterator it = moveClasses.begin(); it != moveClasses.end(); ++it)
 		{
 			std::string terrainClassName = it->first;
-			m_TerrainCostClassTags[terrainClassName] = COST_CLASS_TAG(i);
+			m_TerrainCostClassTags[terrainClassName] = (cost_class_t)i;
 			++i;
 
 			const CParamNode::ChildrenMap& unitClasses = it->second.GetChild("UnitClasses").GetChildren();
@@ -97,7 +97,7 @@ void CCmpPathfinder::Init(const CParamNode& UNUSED(paramNode))
 		size_t i = 0;
 		for (std::set<std::string>::const_iterator nit = unitClassNames.begin(); nit != unitClassNames.end(); ++nit)
 		{
-			m_UnitCostClassTags[*nit] = (u8)i;
+			m_UnitCostClassTags[*nit] = (cost_class_t)i;
 			++i;
 
 			std::vector<u32> costs;
@@ -143,7 +143,7 @@ struct SerializeLongRequest
 		serialize.NumberFixed_Unbounded("x0", value.x0);
 		serialize.NumberFixed_Unbounded("z0", value.z0);
 		SerializeGoal()(serialize, "goal", value.goal);
-		serialize.NumberU8_Unbounded("pass class", value.passClass);
+		serialize.NumberU16_Unbounded("pass class", value.passClass);
 		serialize.NumberU8_Unbounded("cost class", value.costClass);
 		serialize.NumberU32_Unbounded("notify", value.notify);
 	}
@@ -160,7 +160,7 @@ struct SerializeShortRequest
 		serialize.NumberFixed_Unbounded("r", value.r);
 		serialize.NumberFixed_Unbounded("range", value.range);
 		SerializeGoal()(serialize, "goal", value.goal);
-		serialize.NumberU8_Unbounded("pass class", value.passClass);
+		serialize.NumberU16_Unbounded("pass class", value.passClass);
 		serialize.Bool("avoid moving units", value.avoidMovingUnits);
 		serialize.NumberU32_Unbounded("group", value.group);
 		serialize.NumberU32_Unbounded("notify", value.notify);
@@ -219,7 +219,7 @@ fixed CCmpPathfinder::GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, u8 cost
 	return m_MoveSpeeds.at(costClass).at(GET_COST_CLASS(tileTag));
 }
 
-u8 CCmpPathfinder::GetPassabilityClass(const std::string& name)
+ICmpPathfinder::pass_class_t CCmpPathfinder::GetPassabilityClass(const std::string& name)
 {
 	if (m_PassClassMasks.find(name) == m_PassClassMasks.end())
 	{
@@ -230,15 +230,12 @@ u8 CCmpPathfinder::GetPassabilityClass(const std::string& name)
 	return m_PassClassMasks[name];
 }
 
-std::vector<std::string> CCmpPathfinder::GetPassabilityClasses()
+std::map<std::string, ICmpPathfinder::pass_class_t> CCmpPathfinder::GetPassabilityClasses()
 {
-	std::vector<std::string> classes;
-	for (std::map<std::string, u8>::iterator it = m_PassClassMasks.begin(); it != m_PassClassMasks.end(); ++it)
-		classes.push_back(it->first);
-	return classes;
+	return m_PassClassMasks;
 }
 
-u8 CCmpPathfinder::GetCostClass(const std::string& name)
+ICmpPathfinder::cost_class_t CCmpPathfinder::GetCostClass(const std::string& name)
 {
 	if (m_UnitCostClassTags.find(name) == m_UnitCostClassTags.end())
 	{
@@ -272,6 +269,12 @@ fixed CCmpPathfinder::DistanceToGoal(CFixedVector2D pos, const CCmpPathfinder::G
 	}
 }
 
+const Grid<u16>& CCmpPathfinder::GetPassabilityGrid()
+{
+	UpdateGrid();
+	return *m_Grid;
+}
+
 void CCmpPathfinder::UpdateGrid()
 {
 	PROFILE("UpdateGrid");
@@ -297,6 +300,7 @@ void CCmpPathfinder::UpdateGrid()
 	{
 		// Obstructions or terrain changed - we need to recompute passability
 		// TODO: only bother recomputing the region that has actually changed
+		// TODO: if only obstructions changed, don't recompute the terrain masks
 
 		for (u16 j = 0; j < m_MapSize; ++j)
 		{
@@ -319,27 +323,30 @@ void CCmpPathfinder::UpdateGrid()
 
 				fixed slope = terrain.GetSlopeFixed(i, j);
 
-				if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED)
+				if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_PATHFINDING)
 					t |= 1;
 
+				if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_FOUNDATION)
+					t |= 2;
+
 				if (obstruct & ICmpObstructionManager::TILE_OUTOFBOUNDS)
 				{
 					// If out of bounds, nobody is allowed to pass
 					for (size_t n = 0; n < m_PassClasses.size(); ++n)
-						t |= (m_PassClasses[n].m_Mask & ~1);
+						t |= m_PassClasses[n].m_Mask;
 				}
 				else
 				{
 					for (size_t n = 0; n < m_PassClasses.size(); ++n)
 					{
 						if (!m_PassClasses[n].IsPassable(depth, slope))
-							t |= (m_PassClasses[n].m_Mask & ~1);
+							t |= m_PassClasses[n].m_Mask;
 					}
 				}
 
 				std::string moveClass = terrain.GetMovementClass(i, j);
 				if (m_TerrainCostClassTags.find(moveClass) != m_TerrainCostClassTags.end())
-					t |= m_TerrainCostClassTags[moveClass];
+					t |= COST_CLASS_MASK(m_TerrainCostClassTags[moveClass]);
 
 				m_Grid->set(i, j, t);
 			}
@@ -353,14 +360,14 @@ void CCmpPathfinder::UpdateGrid()
 
 // Async path requests:
 
-u32 CCmpPathfinder::ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass, entity_id_t notify)
+u32 CCmpPathfinder::ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, entity_id_t notify)
 {
 	AsyncLongPathRequest req = { m_NextAsyncTicket++, x0, z0, goal, passClass, costClass, notify };
 	m_AsyncLongPathRequests.push_back(req);
 	return req.ticket;
 }
 
-u32 CCmpPathfinder::ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, u8 passClass, bool avoidMovingUnits, entity_id_t group, entity_id_t notify)
+u32 CCmpPathfinder::ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, bool avoidMovingUnits, entity_id_t group, entity_id_t notify)
 {
 	AsyncShortPathRequest req = { m_NextAsyncTicket++, x0, z0, r, range, goal, passClass, avoidMovingUnits, group, notify };
 	m_AsyncShortPathRequests.push_back(req);
@@ -394,7 +401,7 @@ void CCmpPathfinder::FinishAsyncRequests()
 	{
 		const AsyncShortPathRequest& req = shortRequests[i];
 		Path path;
-		ControlGroupObstructionFilter filter(req.avoidMovingUnits, req.group);
+		ControlGroupMovementObstructionFilter filter(req.avoidMovingUnits, req.group);
 		ComputeShortPath(filter, req.x0, req.z0, req.r, req.range, req.goal, req.passClass, path);
 		CMessagePathResult msg(req.ticket, path);
 		GetSimContext().GetComponentManager().PostMessage(req.notify, msg);
diff --git a/source/simulation2/components/CCmpPathfinder_Common.h b/source/simulation2/components/CCmpPathfinder_Common.h
index b6a987e587..1980a72cc7 100644
--- a/source/simulation2/components/CCmpPathfinder_Common.h
+++ b/source/simulation2/components/CCmpPathfinder_Common.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -62,6 +62,8 @@ struct PathfindTile;
  *
  * We use a separate bit to indicate building obstructions (instead of folding it into
  * the class passabilities) so that it can be ignored when doing the accurate short paths.
+ * We use another bit to indicate tiles near obstructions that block construction,
+ * for the AI to plan safe building spots.
  *
  * To handle movement costs, we have an arbitrary number of unit cost classes (e.g. "infantry", "camel"),
  * and a small number of terrain cost classes (e.g. "grass", "steep grass", "road", "sand"),
@@ -69,8 +71,7 @@ struct PathfindTile;
  * We need log2(|terrain cost classes|) bits per tile to represent costs.
  *
  * We could have one passability bitmap per class, and another array for cost classes,
- * but instead (for no particular reason) we'll pack them all into a single u8 array.
- * Space is a bit tight so maybe this should be changed to a u16 in the future.
+ * but instead (for no particular reason) we'll pack them all into a single u16 array.
  *
  * We handle dynamic updates currently by recomputing the entire array, which is stupid;
  * it should only bother updating the region that has changed.
@@ -78,7 +79,7 @@ struct PathfindTile;
 class PathfinderPassability
 {
 public:
-	PathfinderPassability(u8 mask, const CParamNode& node) :
+	PathfinderPassability(ICmpPathfinder::pass_class_t mask, const CParamNode& node) :
 		m_Mask(mask)
 	{
 		if (node.GetChild("MinWaterDepth").IsOk())
@@ -102,20 +103,25 @@ public:
 		return ((m_MinDepth <= waterdepth && waterdepth <= m_MaxDepth) && (steepness < m_MaxSlope));
 	}
 
-	u8 m_Mask;
+	ICmpPathfinder::pass_class_t m_Mask;
 private:
 	fixed m_MinDepth;
 	fixed m_MaxDepth;
 	fixed m_MaxSlope;
 };
 
-typedef u8 TerrainTile; // 1 bit for obstructions, PASS_CLASS_BITS for terrain passability, COST_CLASS_BITS for movement costs
-const int PASS_CLASS_BITS = 4;
-const int COST_CLASS_BITS = 8 - (PASS_CLASS_BITS + 1);
+typedef u16 TerrainTile;
+// 1 bit for pathfinding obstructions,
+// 1 bit for construction obstructions (used by AI),
+// PASS_CLASS_BITS for terrain passability (allowing PASS_CLASS_BITS classes),
+// COST_CLASS_BITS for movement costs (allowing 2^COST_CLASS_BITS classes)
+
+const int PASS_CLASS_BITS = 10;
+const int COST_CLASS_BITS = 16 - (PASS_CLASS_BITS + 2);
 #define IS_TERRAIN_PASSABLE(item, classmask) (((item) & (classmask)) == 0)
 #define IS_PASSABLE(item, classmask) (((item) & ((classmask) | 1)) == 0)
-#define GET_COST_CLASS(item) ((item) >> (PASS_CLASS_BITS + 1))
-#define COST_CLASS_TAG(id) ( (u8) ((id) << (PASS_CLASS_BITS + 1)) )
+#define GET_COST_CLASS(item) ((item) >> (PASS_CLASS_BITS + 2))
+#define COST_CLASS_MASK(id) ( (TerrainTile) ((id) << (PASS_CLASS_BITS + 2)) )
 
 struct AsyncLongPathRequest
 {
@@ -123,8 +129,8 @@ struct AsyncLongPathRequest
 	entity_pos_t x0;
 	entity_pos_t z0;
 	ICmpPathfinder::Goal goal;
-	u8 passClass;
-	u8 costClass;
+	ICmpPathfinder::pass_class_t passClass;
+	ICmpPathfinder::cost_class_t costClass;
 	entity_id_t notify;
 };
 
@@ -136,7 +142,7 @@ struct AsyncShortPathRequest
 	entity_pos_t r;
 	entity_pos_t range;
 	ICmpPathfinder::Goal goal;
-	u8 passClass;
+	ICmpPathfinder::pass_class_t passClass;
 	bool avoidMovingUnits;
 	entity_id_t group;
 	entity_id_t notify;
@@ -159,11 +165,11 @@ public:
 
 	// Template state:
 
-	std::map<std::string, u8> m_PassClassMasks;
+	std::map<std::string, pass_class_t> m_PassClassMasks;
 	std::vector<PathfinderPassability> m_PassClasses;
 
-	std::map<std::string, u8> m_TerrainCostClassTags;
-	std::map<std::string, u8> m_UnitCostClassTags;
+	std::map<std::string, cost_class_t> m_TerrainCostClassTags;
+	std::map<std::string, cost_class_t> m_UnitCostClassTags;
 	std::vector<std::vector<u32> > m_MoveCosts; // costs[unitClass][terrainClass]
 	std::vector<std::vector<fixed> > m_MoveSpeeds; // speeds[unitClass][terrainClass]
 
@@ -185,7 +191,7 @@ public:
 	u32 m_DebugSteps;
 	Path* m_DebugPath;
 	PathfinderOverlay* m_DebugOverlay;
-	u8 m_DebugPassClass;
+	pass_class_t m_DebugPassClass;
 
 	std::vector<SOverlayLine> m_DebugOverlayShortPathLines;
 
@@ -204,31 +210,33 @@ public:
 
 	virtual void HandleMessage(const CMessage& msg, bool global);
 
-	virtual u8 GetPassabilityClass(const std::string& name);
+	virtual pass_class_t GetPassabilityClass(const std::string& name);
 
-	virtual std::vector<std::string> GetPassabilityClasses();
+	virtual std::map<std::string, pass_class_t> GetPassabilityClasses();
 
-	virtual u8 GetCostClass(const std::string& name);
+	virtual cost_class_t GetCostClass(const std::string& name);
 
-	virtual void ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass, Path& ret);
+	virtual const Grid<u16>& GetPassabilityGrid();
 
-	virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass, entity_id_t notify);
+	virtual void ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, Path& ret);
 
-	virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, u8 passClass, Path& ret);
+	virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, entity_id_t notify);
 
-	virtual u32 ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, u8 passClass, bool avoidMovingUnits, entity_id_t controller, entity_id_t notify);
+	virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, Path& ret);
 
-	virtual void SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass);
+	virtual u32 ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, bool avoidMovingUnits, entity_id_t controller, entity_id_t notify);
+
+	virtual void SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass);
 
 	virtual void ResetDebugPath();
 
 	virtual void SetDebugOverlay(bool enabled);
 
-	virtual fixed GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, u8 costClass);
+	virtual fixed GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, cost_class_t costClass);
 
 	virtual CFixedVector2D GetNearestPointOnGoal(CFixedVector2D pos, const Goal& goal);
 
-	virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, u8 passClass);
+	virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, pass_class_t passClass);
 
 	virtual void FinishAsyncRequests();
 
diff --git a/source/simulation2/components/CCmpPathfinder_Tile.cpp b/source/simulation2/components/CCmpPathfinder_Tile.cpp
index 86a3278b83..b7352559ec 100644
--- a/source/simulation2/components/CCmpPathfinder_Tile.cpp
+++ b/source/simulation2/components/CCmpPathfinder_Tile.cpp
@@ -153,7 +153,7 @@ void CCmpPathfinder::SetDebugOverlay(bool enabled)
 	}
 }
 
-void CCmpPathfinder::SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass)
+void CCmpPathfinder::SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass)
 {
 	if (!m_DebugOverlay)
 		return;
@@ -185,7 +185,7 @@ struct PathfinderState
 	u16 iGoal, jGoal; // goal tile
 	u16 rGoal; // radius of goal (around tile center)
 
-	u8 passClass;
+	ICmpPathfinder::pass_class_t passClass;
 	std::vector<u32> moveCosts;
 
 	PriorityQueue open;
@@ -357,7 +357,7 @@ static void ProcessNeighbour(u16 pi, u16 pj, u16 i, u16 j, u32 pg, PathfinderSta
 #endif
 }
 
-void CCmpPathfinder::ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass, Path& path)
+void CCmpPathfinder::ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, Path& path)
 {
 	UpdateGrid();
 
diff --git a/source/simulation2/components/CCmpPathfinder_Vertex.cpp b/source/simulation2/components/CCmpPathfinder_Vertex.cpp
index 58a842ed9e..51460867bc 100644
--- a/source/simulation2/components/CCmpPathfinder_Vertex.cpp
+++ b/source/simulation2/components/CCmpPathfinder_Vertex.cpp
@@ -333,7 +333,9 @@ struct TileEdge
 	enum { TOP, BOTTOM, LEFT, RIGHT } dir;
 };
 
-static void AddTerrainEdges(std::vector<Edge>& edgesAA, std::vector<Vertex>& vertexes, u16 i0, u16 j0, u16 i1, u16 j1, fixed r, u8 passClass, const Grid<TerrainTile>& terrain)
+static void AddTerrainEdges(std::vector<Edge>& edgesAA, std::vector<Vertex>& vertexes,
+	u16 i0, u16 j0, u16 i1, u16 j1, fixed r,
+	ICmpPathfinder::pass_class_t passClass, const Grid<TerrainTile>& terrain)
 {
 	PROFILE("AddTerrainEdges");
 
@@ -491,7 +493,9 @@ struct EdgeSort
 	}
 };
 
-void CCmpPathfinder::ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, u8 passClass, Path& path)
+void CCmpPathfinder::ComputeShortPath(const IObstructionTestFilter& filter,
+	entity_pos_t x0, entity_pos_t z0, entity_pos_t r,
+	entity_pos_t range, const Goal& goal, pass_class_t passClass, Path& path)
 {
 	UpdateGrid(); // TODO: only need to bother updating if the terrain changed
 
@@ -846,7 +850,9 @@ void CCmpPathfinder::ComputeShortPath(const IObstructionTestFilter& filter, enti
 	PROFILE_END("A*");
 }
 
-bool CCmpPathfinder::CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, u8 passClass)
+bool CCmpPathfinder::CheckMovement(const IObstructionTestFilter& filter,
+	entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r,
+	pass_class_t passClass)
 {
 	CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
 	if (cmpObstructionManager.null())
diff --git a/source/simulation2/components/CCmpTemplateManager.cpp b/source/simulation2/components/CCmpTemplateManager.cpp
index 62184a5abe..71aad6ee27 100644
--- a/source/simulation2/components/CCmpTemplateManager.cpp
+++ b/source/simulation2/components/CCmpTemplateManager.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -450,7 +450,7 @@ void CCmpTemplateManager::CopyPreviewSubset(CParamNode& out, const CParamNode& i
 	// Disable the Obstruction component (if there is one) so it doesn't affect pathfinding
 	// (but can still be used for testing this entity for collisions against others)
 	if (out.GetChild("Entity").GetChild("Obstruction").IsOk())
-		CParamNode::LoadXMLString(out, "<Entity><Obstruction><Inactive/></Obstruction></Entity>");
+		CParamNode::LoadXMLString(out, "<Entity><Obstruction><Active>false</Active></Obstruction></Entity>");
 
 	if (!corpse)
 	{
@@ -493,9 +493,6 @@ void CCmpTemplateManager::CopyFoundationSubset(CParamNode& out, const CParamNode
 	CParamNode::LoadXMLString(out, "<Entity/>");
 	out.CopyFilteredChildrenOfChild(in, "Entity", permittedComponentTypes);
 
-	// TODO: the foundation shouldn't be considered an obstruction by default, until construction has
-	// really started, to prevent players abusing it to block their opponents
-
 	// Switch the actor to foundation mode
 	CParamNode::LoadXMLString(out, "<Entity><VisualActor><Foundation/></VisualActor></Entity>");
 
@@ -505,6 +502,10 @@ void CCmpTemplateManager::CopyFoundationSubset(CParamNode& out, const CParamNode
 	// Initialise health to 1
 	CParamNode::LoadXMLString(out, "<Entity><Health><Initial>1</Initial></Health></Entity>");
 
+	// Disable the default obstruction status
+	if (out.GetChild("Entity").GetChild("Obstruction").IsOk())
+		CParamNode::LoadXMLString(out, "<Entity><Obstruction><Active>false</Active></Obstruction></Entity>");
+
 	// Don't provide population bonuses yet (but still do take up population cost)
 	if (out.GetChild("Entity").GetChild("Cost").IsOk())
 		CParamNode::LoadXMLString(out, "<Entity><Cost><PopulationBonus>0</PopulationBonus></Cost></Entity>");
diff --git a/source/simulation2/components/CCmpUnitMotion.cpp b/source/simulation2/components/CCmpUnitMotion.cpp
index 0a0b68b9d8..b0c72af676 100644
--- a/source/simulation2/components/CCmpUnitMotion.cpp
+++ b/source/simulation2/components/CCmpUnitMotion.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -527,7 +527,7 @@ private:
 	/**
 	 * Returns an appropriate obstruction filter for use with path requests.
 	 */
-	ControlGroupObstructionFilter GetObstructionFilter(bool forceAvoidMovingUnits = false);
+	ControlGroupMovementObstructionFilter GetObstructionFilter(bool forceAvoidMovingUnits = false);
 
 	/**
 	 * Start moving to the given goal, from our current position 'from'.
@@ -1045,7 +1045,7 @@ void CCmpUnitMotion::FaceTowardsPoint(CFixedVector2D pos, entity_pos_t x, entity
 	}
 }
 
-ControlGroupObstructionFilter CCmpUnitMotion::GetObstructionFilter(bool forceAvoidMovingUnits)
+ControlGroupMovementObstructionFilter CCmpUnitMotion::GetObstructionFilter(bool forceAvoidMovingUnits)
 {
 	entity_id_t group;
 	if (IsFormationMember())
@@ -1053,7 +1053,7 @@ ControlGroupObstructionFilter CCmpUnitMotion::GetObstructionFilter(bool forceAvo
 	else
 		group = GetEntityId();
 
-	return ControlGroupObstructionFilter(forceAvoidMovingUnits || ShouldAvoidMovingUnits(), group);
+	return ControlGroupMovementObstructionFilter(forceAvoidMovingUnits || ShouldAvoidMovingUnits(), group);
 }
 
 
@@ -1273,11 +1273,11 @@ bool CCmpUnitMotion::MoveToTargetRange(entity_id_t target, entity_pos_t minRange
 	if (cmpObstructionManager.null())
 		return false;
 
-	ICmpObstructionManager::tag_t tag;
-
+	bool hasObstruction = false;
+	ICmpObstructionManager::ObstructionSquare obstruction;
 	CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), target);
 	if (!cmpObstruction.null())
-		tag = cmpObstruction->GetObstruction();
+		hasObstruction = cmpObstruction->GetObstructionSquare(obstruction);
 
 	/*
 	 * If we're starting outside the maxRange, we need to move closer in.
@@ -1304,10 +1304,8 @@ bool CCmpUnitMotion::MoveToTargetRange(entity_id_t target, entity_pos_t minRange
 	 * (Those units should set minRange to 0 so they'll never be considered *too* close.)
 	 */
 
-	if (tag.valid())
+	if (hasObstruction)
 	{
-		ICmpObstructionManager::ObstructionSquare obstruction = cmpObstructionManager->GetObstruction(tag);
-
 		CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
 		ICmpPathfinder::Goal goal;
 		goal.x = obstruction.x;
@@ -1420,18 +1418,16 @@ bool CCmpUnitMotion::IsInTargetRange(entity_id_t target, entity_pos_t minRange,
 	if (cmpObstructionManager.null())
 		return false;
 
-	ICmpObstructionManager::tag_t tag;
-
+	bool hasObstruction = false;
+	ICmpObstructionManager::ObstructionSquare obstruction;
 	CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), target);
 	if (!cmpObstruction.null())
-		tag = cmpObstruction->GetObstruction();
+		hasObstruction = cmpObstruction->GetObstructionSquare(obstruction);
 
 	entity_pos_t distance;
 
-	if (tag.valid())
+	if (hasObstruction)
 	{
-		ICmpObstructionManager::ObstructionSquare obstruction = cmpObstructionManager->GetObstruction(tag);
-
 		CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
 		entity_pos_t distance = Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize);
 
diff --git a/source/simulation2/components/ICmpObstruction.cpp b/source/simulation2/components/ICmpObstruction.cpp
index 079f20a9b4..5b4ac4ebb3 100644
--- a/source/simulation2/components/ICmpObstruction.cpp
+++ b/source/simulation2/components/ICmpObstruction.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -23,6 +23,8 @@
 
 BEGIN_INTERFACE_WRAPPER(Obstruction)
 DEFINE_INTERFACE_METHOD_0("GetUnitRadius", entity_pos_t, ICmpObstruction, GetUnitRadius)
-DEFINE_INTERFACE_METHOD_0("CheckCollisions", bool, ICmpObstruction, CheckCollisions)
+DEFINE_INTERFACE_METHOD_0("CheckFoundationCollisions", bool, ICmpObstruction, CheckFoundationCollisions)
+DEFINE_INTERFACE_METHOD_0("GetConstructionCollisions", std::vector<entity_id_t>, ICmpObstruction, GetConstructionCollisions)
+DEFINE_INTERFACE_METHOD_1("SetActive", void, ICmpObstruction, SetActive, bool)
 DEFINE_INTERFACE_METHOD_1("SetControlGroup", void, ICmpObstruction, SetControlGroup, entity_id_t)
 END_INTERFACE_WRAPPER(Obstruction)
diff --git a/source/simulation2/components/ICmpObstruction.h b/source/simulation2/components/ICmpObstruction.h
index 9dd680b813..d9664598eb 100644
--- a/source/simulation2/components/ICmpObstruction.h
+++ b/source/simulation2/components/ICmpObstruction.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -32,13 +32,25 @@ public:
 
 	virtual ICmpObstructionManager::tag_t GetObstruction() = 0;
 
+	virtual bool GetObstructionSquare(ICmpObstructionManager::ObstructionSquare& out) = 0;
+
 	virtual entity_pos_t GetUnitRadius() = 0;
 
 	/**
-	 * Test whether this entity's footprint is colliding with any other's.
+	 * Test whether this entity is colliding with any obstruction that are set to
+	 * block the creation of foundations.
 	 * @return true if there is a collision
 	 */
-	virtual bool CheckCollisions() = 0;
+	virtual bool CheckFoundationCollisions() = 0;
+
+	/**
+	 * Returns a list of entities that are colliding with this entity, and that
+	 * are set to block construction.
+	 * @return true if there is a collision
+	 */
+	virtual std::vector<entity_id_t> GetConstructionCollisions() = 0;
+
+	virtual void SetActive(bool active) = 0;
 
 	virtual void SetMovingFlag(bool enabled) = 0;
 
diff --git a/source/simulation2/components/ICmpObstructionManager.h b/source/simulation2/components/ICmpObstructionManager.h
index ac053539e7..9abb27e9db 100644
--- a/source/simulation2/components/ICmpObstructionManager.h
+++ b/source/simulation2/components/ICmpObstructionManager.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -67,6 +67,18 @@ public:
 		u32 n;
 	};
 
+	/**
+	 * Boolean flags affecting the obstruction behaviour of a shape.
+	 */
+	enum EFlags
+	{
+		FLAG_BLOCK_MOVEMENT     = (1 << 0), // prevents units moving through this shape
+		FLAG_BLOCK_FOUNDATION   = (1 << 1), // prevents foundations being placed on this shape
+		FLAG_BLOCK_CONSTRUCTION = (1 << 2), // prevents buildings being constructed on this shape
+		FLAG_BLOCK_PATHFINDING  = (1 << 3), // prevents the tile pathfinder choosing paths through this shape
+		FLAG_MOVING             = (1 << 4)  // indicates this unit is currently moving
+	};
+
 	/**
 	 * Set the bounds of the world.
 	 * Any point outside the bounds is considered obstructed.
@@ -76,24 +88,28 @@ public:
 
 	/**
 	 * Register a static shape.
+	 * @param ent entity ID associated with this shape (or INVALID_ENTITY if none)
 	 * @param x X coordinate of center, in world space
 	 * @param z Z coordinate of center, in world space
 	 * @param a angle of rotation (clockwise from +Z direction)
 	 * @param w width (size along X axis)
 	 * @param h height (size along Z axis)
+	 * @param flags a set of EFlags values
 	 * @return a valid tag for manipulating the shape
 	 */
-	virtual tag_t AddStaticShape(entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h) = 0;
+	virtual tag_t AddStaticShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h, u8 flags) = 0;
 
 	/**
 	 * Register a unit shape.
+	 * @param ent entity ID associated with this shape (or INVALID_ENTITY if none)
 	 * @param x X coordinate of center, in world space
 	 * @param z Z coordinate of center, in world space
 	 * @param r radius (half the unit's width/height)
+	 * @param flags a set of EFlags values
 	 * @param moving whether the unit is currently moving through the world or is stationary
 	 * @return a valid tag for manipulating the shape
 	 */
-	virtual tag_t AddUnitShape(entity_pos_t x, entity_pos_t z, entity_angle_t r, bool moving, entity_id_t group) = 0;
+	virtual tag_t AddUnitShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t r, u8 flags, entity_id_t group) = 0;
 
 	/**
 	 * Adjust the position and angle of an existing shape.
@@ -146,9 +162,12 @@ public:
 	 * @param a angle of rotation (clockwise from +Z direction)
 	 * @param w width (size along X axis)
 	 * @param h height (size along Z axis)
+	 * @param out if non-NULL, all colliding shapes' entities will be added to this list
 	 * @return true if there is a collision
 	 */
-	virtual bool TestStaticShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h) = 0;
+	virtual bool TestStaticShape(const IObstructionTestFilter& filter,
+		entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h,
+		std::vector<entity_id_t>* out) = 0;
 
 	/**
 	 * Collision test a unit shape against the current set of shapes.
@@ -156,22 +175,27 @@ public:
 	 * @param x X coordinate of center
 	 * @param z Z coordinate of center
 	 * @param r radius (half the unit's width/height)
+	 * @param out if non-NULL, all colliding shapes' entities will be added to this list
 	 * @return true if there is a collision
 	 */
-	virtual bool TestUnitShape(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r) = 0;
+	virtual bool TestUnitShape(const IObstructionTestFilter& filter,
+		entity_pos_t x, entity_pos_t z, entity_pos_t r,
+		std::vector<entity_id_t>* out) = 0;
 
 	/**
 	 * Bit-flags for Rasterise.
 	 */
 	enum TileObstruction
 	{
-		TILE_OBSTRUCTED = 1,
-		TILE_OUTOFBOUNDS = 2
+		TILE_OBSTRUCTED_PATHFINDING = (1 << 0), // set if the tile pathfinder should consider this tile blocked
+		TILE_OBSTRUCTED_FOUNDATION = (1 << 1), // set if the AI foundation placement algorithm should consider this tile blocked
+		TILE_OUTOFBOUNDS = (1 << 2) // set if this tile is outside the world boundaries
 	};
 
 	/**
 	 * Convert the current set of shapes onto a grid.
-	 * Tiles that are partially or completely intersected by a shape will have TILE_OBSTRUCTED set;
+	 * Tiles that are intersected by a pathfind-blocking shape will have TILE_OBSTRUCTED_PATHFINDING set;
+	 * tiles that are intersected by a foundation-blocking shape will also have TILE_OBSTRUCTED_FOUNDATION;
 	 * tiles that are outside the world bounds will also have TILE_OUTOFBOUNDS;
 	 * others will be set to 0.
 	 * This is very cheap if the grid has been rasterised before and the set of shapes has not changed.
@@ -215,6 +239,10 @@ public:
 	 */
 	virtual ObstructionSquare GetObstruction(tag_t tag) = 0;
 
+	virtual ObstructionSquare GetUnitShapeObstruction(entity_pos_t x, entity_pos_t z, entity_pos_t r) = 0;
+
+	virtual ObstructionSquare GetStaticShapeObstruction(entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h) = 0;
+
 	/**
 	 * Set the passability to be restricted to a circular map.
 	 */
@@ -240,10 +268,10 @@ public:
 	 * Return true if the shape should be counted for collisions.
 	 * This is called for all shapes that would collide, and also for some that wouldn't.
 	 * @param tag tag of shape being tested
-	 * @param moving whether the shape is a moving unit
+	 * @param flags set of EFlags for the shape
 	 * @param group the control group (typically the shape's unit, or the unit's formation controller, or 0)
 	 */
-	virtual bool Allowed(ICmpObstructionManager::tag_t tag, bool moving, entity_id_t group) const = 0;
+	virtual bool Allowed(ICmpObstructionManager::tag_t tag, u8 flags, entity_id_t group) const = 0;
 };
 
 /**
@@ -252,7 +280,7 @@ public:
 class NullObstructionFilter : public IObstructionTestFilter
 {
 public:
-	virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), bool UNUSED(moving), entity_id_t UNUSED(group)) const
+	virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), u8 UNUSED(flags), entity_id_t UNUSED(group)) const
 	{
 		return true;
 	}
@@ -264,31 +292,34 @@ public:
 class StationaryObstructionFilter : public IObstructionTestFilter
 {
 public:
-	virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), bool moving, entity_id_t UNUSED(group)) const
+	virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), u8 flags, entity_id_t UNUSED(group)) const
 	{
-		return !moving;
+		return !(flags & ICmpObstructionManager::FLAG_MOVING);
 	}
 };
 
 /**
  * Obstruction test filter that reject shapes in a given control group,
- * and optionally rejects moving shapes.
+ * and optionally rejects moving shapes,
+ * and rejects shapes that don't block unit movement.
  */
-class ControlGroupObstructionFilter : public IObstructionTestFilter
+class ControlGroupMovementObstructionFilter : public IObstructionTestFilter
 {
 	bool m_AvoidMoving;
 	entity_id_t m_Group;
 public:
-	ControlGroupObstructionFilter(bool avoidMoving, entity_id_t group) :
+	ControlGroupMovementObstructionFilter(bool avoidMoving, entity_id_t group) :
 		m_AvoidMoving(avoidMoving), m_Group(group)
 	{
 	}
 
-	virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), bool moving, entity_id_t group) const
+	virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), u8 flags, entity_id_t group) const
 	{
 		if (group == m_Group)
 			return false;
-		if (moving && !m_AvoidMoving)
+		if (!(flags & ICmpObstructionManager::FLAG_BLOCK_MOVEMENT))
+			return false;
+		if ((flags & ICmpObstructionManager::FLAG_MOVING) && !m_AvoidMoving)
 			return false;
 		return true;
 	}
@@ -305,10 +336,28 @@ public:
 	{
 	}
 
-	virtual bool Allowed(ICmpObstructionManager::tag_t tag, bool UNUSED(moving), entity_id_t UNUSED(group)) const
+	virtual bool Allowed(ICmpObstructionManager::tag_t tag, u8 UNUSED(flags), entity_id_t UNUSED(group)) const
 	{
 		return tag.n != m_Tag.n;
 	}
 };
 
+/**
+ * Obstruction test filter that rejects a specific shape, and requires the given flags.
+ */
+class SkipTagFlagsObstructionFilter : public IObstructionTestFilter
+{
+	ICmpObstructionManager::tag_t m_Tag;
+	u8 m_Mask;
+public:
+	SkipTagFlagsObstructionFilter(ICmpObstructionManager::tag_t tag, u8 mask) : m_Tag(tag), m_Mask(mask)
+	{
+	}
+
+	virtual bool Allowed(ICmpObstructionManager::tag_t tag, u8 flags, entity_id_t UNUSED(group)) const
+	{
+		return (tag.n != m_Tag.n && (flags & m_Mask) != 0);
+	}
+};
+
 #endif // INCLUDED_ICMPOBSTRUCTIONMANAGER
diff --git a/source/simulation2/components/ICmpPathfinder.h b/source/simulation2/components/ICmpPathfinder.h
index 603205b9b0..19e979877c 100644
--- a/source/simulation2/components/ICmpPathfinder.h
+++ b/source/simulation2/components/ICmpPathfinder.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -28,6 +28,8 @@
 
 class IObstructionTestFilter;
 
+template<typename T> class Grid;
+
 /**
  * Pathfinder algorithms.
  *
@@ -44,6 +46,9 @@ class IObstructionTestFilter;
 class ICmpPathfinder : public IComponent
 {
 public:
+	typedef u16 pass_class_t;
+	typedef u8 cost_class_t;
+
 	struct Goal
 	{
 		enum Type {
@@ -71,28 +76,30 @@ public:
 	};
 
 	/**
-	 * Get the list of all known passability class names.
+	 * Get the list of all known passability classes.
 	 */
-	virtual std::vector<std::string> GetPassabilityClasses() = 0;
+	virtual std::map<std::string, pass_class_t> GetPassabilityClasses() = 0;
 
 	/**
 	 * Get the tag for a given passability class name.
 	 * Logs an error and returns something acceptable if the name is unrecognised.
 	 */
-	virtual u8 GetPassabilityClass(const std::string& name) = 0;
+	virtual pass_class_t GetPassabilityClass(const std::string& name) = 0;
 
 	/**
 	 * Get the tag for a given movement cost class name.
 	 * Logs an error and returns something acceptable if the name is unrecognised.
 	 */
-	virtual u8 GetCostClass(const std::string& name) = 0;
+	virtual cost_class_t GetCostClass(const std::string& name) = 0;
+
+	virtual const Grid<u16>& GetPassabilityGrid() = 0;
 
 	/**
 	 * Compute a tile-based path from the given point to the goal, and return the set of waypoints.
 	 * The waypoints correspond to the centers of horizontally/vertically adjacent tiles
 	 * along the path.
 	 */
-	virtual void ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass, Path& ret) = 0;
+	virtual void ComputePath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, Path& ret) = 0;
 
 	/**
 	 * Asynchronous version of ComputePath.
@@ -100,12 +107,12 @@ public:
 	 * Returns a unique non-zero number, which will match the 'ticket' in the result,
 	 * so callers can recognise each individual request they make.
 	 */
-	virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass, entity_id_t notify) = 0;
+	virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass, entity_id_t notify) = 0;
 
 	/**
 	 * If the debug overlay is enabled, render the path that will computed by ComputePath.
 	 */
-	virtual void SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, u8 passClass, u8 costClass) = 0;
+	virtual void SetDebugPath(entity_pos_t x0, entity_pos_t z0, const Goal& goal, pass_class_t passClass, cost_class_t costClass) = 0;
 
 	/**
 	 * Compute a precise path from the given point to the goal, and return the set of waypoints.
@@ -113,7 +120,7 @@ public:
 	 * a unit of radius 'r' will be able to follow the path with no collisions.
 	 * The path is restricted to a box of radius 'range' from the starting point.
 	 */
-	virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, u8 passClass, Path& ret) = 0;
+	virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, Path& ret) = 0;
 
 	/**
 	 * Asynchronous version of ComputeShortPath (using ControlGroupObstructionFilter).
@@ -121,13 +128,13 @@ public:
 	 * Returns a unique non-zero number, which will match the 'ticket' in the result,
 	 * so callers can recognise each individual request they make.
 	 */
-	virtual u32 ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, u8 passClass, bool avoidMovingUnits, entity_id_t group, entity_id_t notify) = 0;
+	virtual u32 ComputeShortPathAsync(entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const Goal& goal, pass_class_t passClass, bool avoidMovingUnits, entity_id_t group, entity_id_t notify) = 0;
 
 	/**
 	 * Find the speed factor (typically around 1.0) for a unit of the given cost class
 	 * at the given position.
 	 */
-	virtual fixed GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, u8 costClass) = 0;
+	virtual fixed GetMovementSpeed(entity_pos_t x0, entity_pos_t z0, cost_class_t costClass) = 0;
 
 	/**
 	 * Returns the coordinates of the point on the goal that is closest to pos in a straight line.
@@ -139,7 +146,7 @@ public:
 	 * or impassable terrain.
 	 * Returns true if the movement is okay.
 	 */
-	virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, u8 passClass) = 0;
+	virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, pass_class_t passClass) = 0;
 
 	/**
 	 * Toggle the storage and rendering of debug info.
diff --git a/source/simulation2/components/tests/test_Pathfinder.h b/source/simulation2/components/tests/test_Pathfinder.h
index 712f3e9b8c..05a74ecb81 100644
--- a/source/simulation2/components/tests/test_Pathfinder.h
+++ b/source/simulation2/components/tests/test_Pathfinder.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -111,7 +111,7 @@ public:
 			fixed x = fixed::FromFloat(1.5f*range.ToFloat() * rand()/(float)RAND_MAX);
 			fixed z = fixed::FromFloat(1.5f*range.ToFloat() * rand()/(float)RAND_MAX);
 //			printf("# %f %f\n", x.ToFloat(), z.ToFloat());
-			cmpObstructionMan->AddUnitShape(x, z, fixed::FromInt(2), false, INVALID_ENTITY);
+			cmpObstructionMan->AddUnitShape(INVALID_ENTITY, x, z, fixed::FromInt(2), 0, INVALID_ENTITY);
 		}
 
 		NullObstructionFilter filter;
diff --git a/source/simulation2/scripting/EngineScriptConversions.cpp b/source/simulation2/scripting/EngineScriptConversions.cpp
index 9378bcd980..59bf1c6606 100644
--- a/source/simulation2/scripting/EngineScriptConversions.cpp
+++ b/source/simulation2/scripting/EngineScriptConversions.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -25,11 +25,16 @@
 #include "ps/CLogger.h"
 #include "ps/Overlay.h"
 #include "ps/utf16string.h"
+#include "simulation2/helpers/Grid.h"
 #include "simulation2/system/IComponent.h"
 #include "simulation2/system/ParamNode.h"
 
 #include "js/jsapi.h"
 
+#define signbit std::signbit
+#include "js/jstypedarray.h"
+#undef signbit
+
 template<> jsval ScriptInterface::ToJSVal<IComponent*>(JSContext* cx, IComponent* const& val)
 {
 	if (val == NULL)
@@ -207,3 +212,30 @@ template<> jsval ScriptInterface::ToJSVal<CFixedVector2D>(JSContext* cx, const C
 
 	return OBJECT_TO_JSVAL(obj);
 }
+
+template<> jsval ScriptInterface::ToJSVal<Grid<u16> >(JSContext* cx, const Grid<u16>& val)
+{
+	JSObject* obj = JS_NewObject(cx, NULL, NULL, NULL);
+	if (!obj)
+		return JSVAL_VOID;
+
+	size_t len = val.m_W * val.m_H;
+	JSObject *darray = js_CreateTypedArray(cx, js::TypedArray::TYPE_UINT16, len);
+	if (!darray)
+		return JSVAL_VOID;
+
+	js::TypedArray *tdest = js::TypedArray::fromJSObject(darray);
+	debug_assert(tdest->byteLength == len*sizeof(u16));
+
+	memcpy(tdest->data, val.m_Data, tdest->byteLength);
+
+	jsval w = ToJSVal(cx, val.m_W);
+	jsval h = ToJSVal(cx, val.m_H);
+	jsval data = OBJECT_TO_JSVAL(darray);
+
+	JS_SetProperty(cx, obj, "width", &w);
+	JS_SetProperty(cx, obj, "height", &h);
+	JS_SetProperty(cx, obj, "data", &data);
+
+	return OBJECT_TO_JSVAL(obj);
+}
diff --git a/source/simulation2/serialization/BinarySerializer.h b/source/simulation2/serialization/BinarySerializer.h
index 000af6b78b..1d5e673a74 100644
--- a/source/simulation2/serialization/BinarySerializer.h
+++ b/source/simulation2/serialization/BinarySerializer.h
@@ -121,6 +121,18 @@ protected:
 		m_Impl.Put(name, (const u8*)&value, sizeof(int8_t));
 	}
 
+	virtual void PutNumber(const char* name, uint16_t value)
+	{
+		uint16_t v = to_le16(value);
+		m_Impl.Put(name, (const u8*)&v, sizeof(uint16_t));
+	}
+
+	virtual void PutNumber(const char* name, int16_t value)
+	{
+		int16_t v = (i16)to_le16((u16)value);
+		m_Impl.Put(name, (const u8*)&v, sizeof(int16_t));
+	}
+
 	virtual void PutNumber(const char* name, uint32_t value)
 	{
 		uint32_t v = to_le32(value);
diff --git a/source/simulation2/serialization/DebugSerializer.cpp b/source/simulation2/serialization/DebugSerializer.cpp
index fe692fcf8f..89893583ad 100644
--- a/source/simulation2/serialization/DebugSerializer.cpp
+++ b/source/simulation2/serialization/DebugSerializer.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -90,6 +90,16 @@ void CDebugSerializer::PutNumber(const char* name, int8_t value)
 	m_Stream << INDENT << name << ": " << (int)value << "\n";
 }
 
+void CDebugSerializer::PutNumber(const char* name, uint16_t value)
+{
+	m_Stream << INDENT << name << ": " << value << "\n";
+}
+
+void CDebugSerializer::PutNumber(const char* name, int16_t value)
+{
+	m_Stream << INDENT << name << ": " << value << "\n";
+}
+
 void CDebugSerializer::PutNumber(const char* name, uint32_t value)
 {
 	m_Stream << INDENT << name << ": " << value << "\n";
diff --git a/source/simulation2/serialization/DebugSerializer.h b/source/simulation2/serialization/DebugSerializer.h
index 221edca503..7b67cef491 100644
--- a/source/simulation2/serialization/DebugSerializer.h
+++ b/source/simulation2/serialization/DebugSerializer.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -44,6 +44,8 @@ public:
 protected:
 	virtual void PutNumber(const char* name, uint8_t value);
 	virtual void PutNumber(const char* name, int8_t value);
+	virtual void PutNumber(const char* name, uint16_t value);
+	virtual void PutNumber(const char* name, int16_t value);
 	virtual void PutNumber(const char* name, uint32_t value);
 	virtual void PutNumber(const char* name, int32_t value);
 	virtual void PutNumber(const char* name, float value);
diff --git a/source/simulation2/serialization/IDeserializer.cpp b/source/simulation2/serialization/IDeserializer.cpp
index 9e5262c46b..1560e9a9a5 100644
--- a/source/simulation2/serialization/IDeserializer.cpp
+++ b/source/simulation2/serialization/IDeserializer.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -27,36 +27,74 @@ IDeserializer::~IDeserializer()
 {
 }
 
-template<typename T>
-T IDeserializer::Number_(T lower, T upper)
+void IDeserializer::NumberU8(const char* UNUSED(name), uint8_t& out, uint8_t lower, uint8_t upper)
 {
-	T value;
-	Get((u8*)&value, sizeof(T));
+	uint8_t value;
+	Get((u8*)&value, sizeof(uint8_t));
 
 	if (!(lower <= value && value <= upper))
 		throw PSERROR_Deserialize_OutOfBounds();
 
-	return value;
-}
-
-void IDeserializer::NumberU8(const char* UNUSED(name), uint8_t& out, uint8_t lower, uint8_t upper)
-{
-	out = Number_(lower, upper);
+	out = value;
 }
 
 void IDeserializer::NumberI8(const char* UNUSED(name), int8_t& out, int8_t lower, int8_t upper)
 {
-	out = Number_(lower, upper);
+	int8_t value;
+	Get((u8*)&value, sizeof(uint8_t));
+
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Deserialize_OutOfBounds();
+
+	out = value;
+}
+
+void IDeserializer::NumberU16(const char* UNUSED(name), uint16_t& out, uint16_t lower, uint16_t upper)
+{
+	uint16_t value;
+	Get((u8*)&value, sizeof(uint16_t));
+	value = to_le16(value);
+
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Deserialize_OutOfBounds();
+
+	out = value;
+}
+
+void IDeserializer::NumberI16(const char* UNUSED(name), int16_t& out, int16_t lower, int16_t upper)
+{
+	int16_t value;
+	Get((u8*)&value, sizeof(uint16_t));
+	value = (i16)to_le16((u16)value);
+
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Deserialize_OutOfBounds();
+
+	out = value;
 }
 
 void IDeserializer::NumberU32(const char* UNUSED(name), uint32_t& out, uint32_t lower, uint32_t upper)
 {
-	out = to_le32(Number_(lower, upper));
+	uint32_t value;
+	Get((u8*)&value, sizeof(uint32_t));
+	value = to_le32(value);
+
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Deserialize_OutOfBounds();
+
+	out = value;
 }
 
 void IDeserializer::NumberI32(const char* UNUSED(name), int32_t& out, int32_t lower, int32_t upper)
 {
-	out = (i32)to_le32((u32)Number_(lower, upper));
+	int32_t value;
+	Get((u8*)&value, sizeof(uint32_t));
+	value = (i32)to_le32((u32)value);
+
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Deserialize_OutOfBounds();
+
+	out = value;
 }
 
 void IDeserializer::NumberU8_Unbounded(const char* UNUSED(name), uint8_t& out)
@@ -69,6 +107,20 @@ void IDeserializer::NumberI8_Unbounded(const char* UNUSED(name), int8_t& out)
 	Get((u8*)&out, sizeof(int8_t));
 }
 
+void IDeserializer::NumberU16_Unbounded(const char* UNUSED(name), uint16_t& out)
+{
+	uint16_t value;
+	Get((u8*)&value, sizeof(uint16_t));
+	out = to_le16(value);
+}
+
+void IDeserializer::NumberI16_Unbounded(const char* UNUSED(name), int16_t& out)
+{
+	int16_t value;
+	Get((u8*)&value, sizeof(int16_t));
+	out = (i16)to_le16((u16)value);
+}
+
 void IDeserializer::NumberU32_Unbounded(const char* UNUSED(name), uint32_t& out)
 {
 	uint32_t value;
diff --git a/source/simulation2/serialization/IDeserializer.h b/source/simulation2/serialization/IDeserializer.h
index a806740efc..0b101dc14e 100644
--- a/source/simulation2/serialization/IDeserializer.h
+++ b/source/simulation2/serialization/IDeserializer.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -38,10 +38,14 @@ public:
 
 	virtual void NumberU8(const char* name, uint8_t& out, uint8_t lower, uint8_t upper);
 	virtual void NumberI8(const char* name, int8_t& out, int8_t lower, int8_t upper);
+	virtual void NumberU16(const char* name, uint16_t& out, uint16_t lower, uint16_t upper);
+	virtual void NumberI16(const char* name, int16_t& out, int16_t lower, int16_t upper);
 	virtual void NumberU32(const char* name, uint32_t& out, uint32_t lower, uint32_t upper);
 	virtual void NumberI32(const char* name, int32_t& out, int32_t lower, int32_t upper);
 	virtual void NumberU8_Unbounded(const char* name, uint8_t& out);
 	virtual void NumberI8_Unbounded(const char* name, int8_t& out);
+	virtual void NumberU16_Unbounded(const char* name, uint16_t& out);
+	virtual void NumberI16_Unbounded(const char* name, int16_t& out);
 	virtual void NumberU32_Unbounded(const char* name, uint32_t& out);
 	virtual void NumberI32_Unbounded(const char* name, int32_t& out);
 	virtual void NumberFloat_Unbounded(const char* name, float& out);
@@ -78,10 +82,6 @@ protected:
 	virtual void ReadString(std::string& out);
 
 	virtual void Get(u8* data, size_t len) = 0;
-
-private:
-	// Helper function for bounded number types
-	template<typename T> T Number_(T lower, T upper);
 };
 
 #endif // INCLUDED_IDESERIALIZER
diff --git a/source/simulation2/serialization/ISerializer.cpp b/source/simulation2/serialization/ISerializer.cpp
index c6b19f1a36..201bf81d95 100644
--- a/source/simulation2/serialization/ISerializer.cpp
+++ b/source/simulation2/serialization/ISerializer.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -39,6 +39,20 @@ void ISerializer::NumberI8(const char* name, int8_t value, int8_t lower, int8_t
 	PutNumber(name, value);
 }
 
+void ISerializer::NumberU16(const char* name, uint16_t value, uint16_t lower, uint16_t upper)
+{
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Serialize_OutOfBounds();
+	PutNumber(name, value);
+}
+
+void ISerializer::NumberI16(const char* name, int16_t value, int16_t lower, int16_t upper)
+{
+	if (!(lower <= value && value <= upper))
+		throw PSERROR_Serialize_OutOfBounds();
+	PutNumber(name, value);
+}
+
 void ISerializer::NumberU32(const char* name, uint32_t value, uint32_t lower, uint32_t upper)
 {
 	if (!(lower <= value && value <= upper))
diff --git a/source/simulation2/serialization/ISerializer.h b/source/simulation2/serialization/ISerializer.h
index 61049a6af1..d742c27608 100644
--- a/source/simulation2/serialization/ISerializer.h
+++ b/source/simulation2/serialization/ISerializer.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -136,6 +136,8 @@ public:
 	 */
 	void NumberU8(const char* name, uint8_t value, uint8_t lower, uint8_t upper);
 	void NumberI8(const char* name, int8_t value, int8_t lower, int8_t upper);
+	void NumberU16(const char* name, uint16_t value, uint16_t lower, uint16_t upper); ///< @copydoc NumberU8
+	void NumberI16(const char* name, int16_t value, int16_t lower, int16_t upper); ///< @copydoc NumberU8
 	void NumberU32(const char* name, uint32_t value, uint32_t lower, uint32_t upper); ///< @copydoc NumberU8
 	void NumberI32(const char* name, int32_t value, int32_t lower, int32_t upper); ///< @copydoc NumberU8
 
@@ -156,6 +158,16 @@ public:
 		PutNumber(name, value);
 	}
 
+	void NumberU16_Unbounded(const char* name, uint16_t value) ///@copydoc NumberU8_Unbounded()
+	{
+		PutNumber(name, value);
+	}
+
+	void NumberI16_Unbounded(const char* name, int16_t value) ///@copydoc NumberU8_Unbounded()
+	{
+		PutNumber(name, value);
+	}
+
 	void NumberU32_Unbounded(const char* name, uint32_t value) ///@copydoc NumberU8_Unbounded()
 	{
 		PutNumber(name, value);
@@ -248,6 +260,8 @@ public:
 protected:
 	virtual void PutNumber(const char* name, uint8_t value) = 0;
 	virtual void PutNumber(const char* name, int8_t value) = 0;
+	virtual void PutNumber(const char* name, uint16_t value) = 0;
+	virtual void PutNumber(const char* name, int16_t value) = 0;
 	virtual void PutNumber(const char* name, uint32_t value) = 0;
 	virtual void PutNumber(const char* name, int32_t value) = 0;
 	virtual void PutNumber(const char* name, float value) = 0;
diff --git a/source/simulation2/tests/test_CmpTemplateManager.h b/source/simulation2/tests/test_CmpTemplateManager.h
index f7ae6ebb04..14ad76d99d 100644
--- a/source/simulation2/tests/test_CmpTemplateManager.h
+++ b/source/simulation2/tests/test_CmpTemplateManager.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -90,7 +90,10 @@ public:
 		TS_ASSERT(previewobstruct != NULL);
 		TS_ASSERT_WSTR_EQUALS(previewobstruct->ToXML(),
 				L"<Footprint><Circle radius=\"4\"></Circle><Height>1.0</Height></Footprint>"
-				L"<Obstruction><Inactive></Inactive><Unit radius=\"4\"></Unit></Obstruction>"
+				L"<Obstruction>"
+					L"<Active>false</Active><BlockConstruction>true</BlockConstruction><BlockFoundation>false</BlockFoundation>"
+					L"<BlockMovement>true</BlockMovement><BlockPathfinding>false</BlockPathfinding><Unit radius=\"4\"></Unit>"
+				L"</Obstruction>"
 				L"<Position><Altitude>0</Altitude><Anchor>upright</Anchor><Floating>false</Floating></Position>"
 				L"<Vision><AlwaysVisible>true</AlwaysVisible><Range>0</Range><RetainInFog>false</RetainInFog></Vision>"
 				L"<VisualActor><Actor>example</Actor></VisualActor>");
diff --git a/source/simulation2/tests/test_Serializer.h b/source/simulation2/tests/test_Serializer.h
index 7d1b0e8ef2..92f784d22f 100644
--- a/source/simulation2/tests/test_Serializer.h
+++ b/source/simulation2/tests/test_Serializer.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -48,7 +48,10 @@ class TestSerializer : public CxxTest::TestSuite
 public:
 	void serialize_types(ISerializer& serialize)
 	{
-		serialize.NumberU8_Unbounded("u8", 255);
+		serialize.NumberI8_Unbounded("i8", (signed char)-123);
+		serialize.NumberU8_Unbounded("u8", (unsigned char)255);
+		serialize.NumberI16_Unbounded("i16", -12345);
+		serialize.NumberU16_Unbounded("u16", 56789);
 		serialize.NumberI32_Unbounded("i32", -123);
 		serialize.NumberU32_Unbounded("u32", (unsigned)-123);
 		serialize.NumberFloat_Unbounded("float", 1e+30f);
@@ -122,7 +125,10 @@ public:
 
 		TS_ASSERT_STR_EQUALS(stream.str(),
 				"# comment\n"
+				"i8: -123\n"
 				"u8: 255\n"
+				"i16: -12345\n"
+				"u16: 56789\n"
 				"i32: -123\n"
 				"u32: 4294967173\n"
 				"float: 1e+30\n"
@@ -173,7 +179,10 @@ public:
 		serialize_types(serialize);
 
 		CStdDeserializer deserialize(script, stream);
+		int8_t i8v;
 		uint8_t u8v;
+		int16_t i16v;
+		uint16_t u16v;
 		int32_t i32v;
 		uint32_t u32v;
 		float flt;
@@ -184,8 +193,14 @@ public:
 		std::wstring wstr;
 		u8 cbuf[256];
 
+		deserialize.NumberI8_Unbounded("i8", i8v);
+		TS_ASSERT_EQUALS(i8v, -123);
 		deserialize.NumberU8_Unbounded("u8", u8v);
 		TS_ASSERT_EQUALS(u8v, 255);
+		deserialize.NumberI16_Unbounded("i16", i16v);
+		TS_ASSERT_EQUALS(i16v, -12345);
+		deserialize.NumberU16_Unbounded("u16", u16v);
+		TS_ASSERT_EQUALS(u16v, 56789);
 		deserialize.NumberI32_Unbounded("i32", i32v);
 		TS_ASSERT_EQUALS(i32v, -123);
 		deserialize.NumberU32_Unbounded("u32", u32v);
diff --git a/source/tools/atlas/GameInterface/Handlers/TerrainHandlers.cpp b/source/tools/atlas/GameInterface/Handlers/TerrainHandlers.cpp
index 4da5f518e3..36155e68ed 100644
--- a/source/tools/atlas/GameInterface/Handlers/TerrainHandlers.cpp
+++ b/source/tools/atlas/GameInterface/Handlers/TerrainHandlers.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010 Wildfire Games.
+/* Copyright (C) 2011 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -125,11 +125,11 @@ QUERYHANDLER(GetTerrainPassabilityClasses)
 	CmpPtr<ICmpPathfinder> cmpPathfinder(*View::GetView_Game()->GetSimulation2(), SYSTEM_ENTITY);
 	if (!cmpPathfinder.null())
 	{
-		std::vector<std::string> names = cmpPathfinder->GetPassabilityClasses();
+		std::map<std::string, ICmpPathfinder::pass_class_t> classes = cmpPathfinder->GetPassabilityClasses();
 
 		std::vector<std::wstring> classnames;
-		for (std::vector<std::string>::iterator it = names.begin(); it != names.end(); ++it)
-			classnames.push_back(CStrW(*it));
+		for (std::map<std::string, ICmpPathfinder::pass_class_t>::iterator it = classes.begin(); it != classes.end(); ++it)
+			classnames.push_back(CStrW(it->first));
 		msg->classnames = classnames;
 	}
 }