diff --git a/binaries/data/mods/public/gui/session/input.js b/binaries/data/mods/public/gui/session/input.js
index 23ed23a..8034091 100644
--- a/binaries/data/mods/public/gui/session/input.js
+++ b/binaries/data/mods/public/gui/session/input.js
@@ -17,21 +17,21 @@ const ACTION_GARRISON = 1;
const ACTION_REPAIR = 2;
var preSelectedAction = ACTION_NONE;
-var INPUT_NORMAL = 0;
-var INPUT_SELECTING = 1;
-var INPUT_BANDBOXING = 2;
-var INPUT_BUILDING_PLACEMENT = 3;
-var INPUT_BUILDING_CLICK = 4;
-var INPUT_BUILDING_DRAG = 5;
-var INPUT_BATCHTRAINING = 6;
-var INPUT_PRESELECTEDACTION = 7;
+const INPUT_NORMAL = 0;
+const INPUT_SELECTING = 1;
+const INPUT_BANDBOXING = 2;
+const INPUT_BUILDING_PLACEMENT = 3;
+const INPUT_BUILDING_CLICK = 4;
+const INPUT_BUILDING_DRAG = 5;
+const INPUT_BATCHTRAINING = 6;
+const INPUT_PRESELECTEDACTION = 7;
+const INPUT_BUILDING_WALL_CLICK = 8;
+const INPUT_BUILDING_WALL_PATHING = 9;
var inputState = INPUT_NORMAL;
-var defaultPlacementAngle = Math.PI*3/4;
-var placementAngle = undefined;
-var placementPosition = undefined;
-var placementEntity = undefined;
+const defaultPlacementAngle = Math.PI*3/4;
+var placementSupport = new PlacementSupport();
var mouseX = 0;
var mouseY = 0;
@@ -88,29 +88,46 @@ function updateCursorAndTooltip()
function updateBuildingPlacementPreview()
{
// The preview should be recomputed every turn, so that it responds
- // to obstructions/fog/etc moving underneath it
+ // to obstructions/fog/etc moving underneath it, or in the case of
+ // the wall previews, in response to new tower foundations getting
+ // constructed for it to snap to.
- if (placementEntity && placementPosition)
+ if (placementSupport.mode === "building")
{
- return Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
- "template": placementEntity,
- "x": placementPosition.x,
- "z": placementPosition.z,
- "angle": placementAngle
- });
+ if (placementSupport.template && placementSupport.position)
+ {
+ return Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
+ "template": placementSupport.template,
+ "x": placementSupport.position.x,
+ "z": placementSupport.position.z,
+ "angle": placementSupport.angle,
+ });
+ }
+ }
+ else if (placementSupport.mode === "wall")
+ {
+ if (placementSupport.wallSet && placementSupport.position)
+ {
+ // Fetch an updated list of snapping candidate entities
+ placementSupport.wallSnapEntities = Engine.PickSimilarFriendlyEntities(
+ placementSupport.wallSet.tower,
+ placementSupport.wallSnapEntitiesIncludeOffscreen,
+ true, // require exact template match
+ true // include foundations
+ );
+
+ return Engine.GuiInterfaceCall("SetWallPlacementPreview", {
+ "wallSet": placementSupport.wallSet,
+ "start": placementSupport.position,
+ "end": placementSupport.wallEndPosition,
+ "snapEntities": placementSupport.wallSnapEntities, // snapping entities (towers) for starting a wall segment
+ });
+ }
}
return false;
}
-function resetPlacementEntity()
-{
- Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {"template": ""});
- placementEntity = undefined;
- placementPosition = undefined;
- placementAngle = undefined;
-}
-
function findGatherType(gatherer, supply)
{
if (!gatherer || !supply)
@@ -434,6 +451,12 @@ var dragStart; // used for remembering mouse coordinates at start of drag operat
function tryPlaceBuilding(queued)
{
+ if (placementSupport.mode !== "building")
+ {
+ error("[tryPlaceBuilding] Called while in '"+placementSupport.mode+"' placement mode instead of 'building'");
+ return false;
+ }
+
var selection = g_Selection.toList();
// Use the preview to check it's a valid build location
@@ -447,10 +470,10 @@ function tryPlaceBuilding(queued)
// Start the construction
Engine.PostNetworkCommand({
"type": "construct",
- "template": placementEntity,
- "x": placementPosition.x,
- "z": placementPosition.z,
- "angle": placementAngle,
+ "template": placementSupport.template,
+ "x": placementSupport.position.x,
+ "z": placementSupport.position.z,
+ "angle": placementSupport.angle,
"entities": selection,
"autorepair": true,
"autocontinue": true,
@@ -459,7 +482,59 @@ function tryPlaceBuilding(queued)
Engine.GuiInterfaceCall("PlaySound", { "name": "order_repair", "entity": selection[0] });
if (!queued)
- resetPlacementEntity();
+ placementSupport.Reset();
+
+ return true;
+}
+
+function tryPlaceWall()
+{
+ if (placementSupport.mode !== "wall")
+ {
+ error("[tryPlaceWall] Called while in '" + placementSupport.mode + "' placement mode; expected 'wall' mode");
+ return false;
+ }
+
+ var wallPlacementInfo = updateBuildingPlacementPreview(); // entities making up the wall (wall segments, towers, ...)
+ if (!(wallPlacementInfo === false || typeof(wallPlacementInfo) === "object"))
+ {
+ error("[tryPlaceWall] Unexpected return value from updateBuildingPlacementPreview: '" + uneval(placementInfo) + "'; expected either 'false' or 'object'");
+ return false;
+ }
+
+ if (!wallPlacementInfo)
+ return false;
+
+ var selection = g_Selection.toList();
+ var cmd = {
+ "type": "construct-wall",
+ "autorepair": true,
+ "autocontinue": true,
+ "queued": true,
+ "entities": selection,
+ "wallSet": placementSupport.wallSet,
+ "pieces": wallPlacementInfo.pieces,
+ "startSnappedEntity": wallPlacementInfo.startSnappedEnt,
+ "endSnappedEntity": wallPlacementInfo.endSnappedEnt,
+ };
+
+ //warn("-------------");
+ //for (var k in cmd)
+ // warn(" " + k + ": " + uneval(cmd[k]));
+ //warn("-------------");
+
+ /*for each (var entInfo in wallPlacementInfo.pieces)
+ {
+ cmd.pieces.push({
+ "template": entInfo.template,
+ "x": entInfo.x,
+ "z": entInfo.z,
+ "angle": entInfo.angle,
+ });
+ }*/
+
+ Engine.PostNetworkCommand(cmd);
+ Engine.GuiInterfaceCall("PlaySound", {"name": "order_repair", "entity": selection[0] });
return true;
}
@@ -659,7 +734,7 @@ function handleInputBeforeGui(ev, hoveredObject)
if (ev.button == SDL_BUTTON_RIGHT)
{
// Cancel building
- resetPlacementEntity();
+ placementSupport.Reset();
inputState = INPUT_NORMAL;
return true;
}
@@ -667,6 +742,98 @@ function handleInputBeforeGui(ev, hoveredObject)
}
break;
+ case INPUT_BUILDING_WALL_CLICK:
+ // User is mid-click in choosing a starting point for building a wall. The build process can still be cancelled at this point
+ // by right-clicking; releasing the left mouse button will 'register' the starting point and commence endpoint choosing mode.
+ switch (ev.type)
+ {
+ case "mousebuttonup":
+ if (ev.button === SDL_BUTTON_LEFT)
+ {
+ inputState = INPUT_BUILDING_WALL_PATHING; warn("-> INPUT_BUILDING_WALL_PATHING");
+ return true;
+ }
+ break;
+
+ case "mousebuttondown":
+ if (ev.button == SDL_BUTTON_RIGHT)
+ {
+ // Cancel building
+ placementSupport.Reset();
+ updateBuildingPlacementPreview();
+
+ inputState = INPUT_NORMAL; warn("-> INPUT_NORMAL");
+ return true;
+ }
+ break;
+ }
+ break;
+
+ case INPUT_BUILDING_WALL_PATHING:
+ // User has chosen a starting point for constructing the wall, and is now looking to set the endpoint.
+ // Right-clicking cancels wall building mode, left-clicking sets the endpoint and builds the wall and returns to
+ // normal input mode. Optionally, shift + left-clicking does not return to normal input, and instead allows the
+ // user to continue building walls.
+ switch (ev.type)
+ {
+ case "mousemotion":
+ placementSupport.wallEndPosition = Engine.GetTerrainAtPoint(ev.x, ev.y);
+
+ // Update the building placement preview, and by extension, the list of snapping candidate entities for both (!)
+ // the ending point and the starting point to snap to.
+ //
+ // TODO: Note that here, we need to fetch all similar entities, including any offscreen ones, to support the case
+ // where the snap entity for the starting point has moved offscreen, or has been deleted/destroyed, or was a
+ // foundation and has been replaced with a completed entity since the user first chose it. Fetching all towers on
+ // the entire map instead of only the current screen might get expensive fast since walls all have a ton of towers
+ // in them. Might be useful to query only for entities within a certain range around the starting point and ending
+ // points.
+
+ placementSupport.wallSnapEntitiesIncludeOffscreen = true;
+ updateBuildingPlacementPreview(); // includes an update of the snap entity candidates
+ break;
+
+ case "mousebuttondown":
+ if (ev.button == SDL_BUTTON_LEFT)
+ {
+ if (tryPlaceWall())
+ {
+ if (Engine.HotkeyIsPressed("session.queue"))
+ {
+ // continue building, just set a new starting position where we left off
+ placementSupport.position = placementSupport.wallEndPosition;
+ placementSupport.wallEndPosition = undefined;
+
+ inputState = INPUT_BUILDING_WALL_CLICK; warn("-> INPUT_BUILDING_WALL_CLICK");
+ }
+ else
+ {
+ placementSupport.Reset();
+ inputState = INPUT_NORMAL; warn("-> INPUT_NORMAL");
+ }
+ }
+ else
+ {
+ // TODO: display some useful error message to the player
+ error("Cannot build wall here!");
+ }
+
+ updateBuildingPlacementPreview();
+ return true;
+ }
+ else if (ev.button == SDL_BUTTON_RIGHT)
+ {
+ // reset to normal input mode
+ placementSupport.Reset();
+ updateBuildingPlacementPreview();
+
+ inputState = INPUT_NORMAL; warn("-> INPUT_NORMAL");
+ return true;
+ }
+ break;
+ }
+ break;
+
case INPUT_BUILDING_DRAG:
switch (ev.type)
{
@@ -678,24 +845,24 @@ function handleInputBeforeGui(ev, hoveredObject)
{
// Rotate in the direction of the mouse
var target = Engine.GetTerrainAtPoint(ev.x, ev.y);
- placementAngle = Math.atan2(target.x - placementPosition.x, target.z - placementPosition.z);
+ placementSupport.angle = Math.atan2(target.x - placementSupport.position.x, target.z - placementSupport.position.z);
}
else
{
// If the mouse is near the center, snap back to the default orientation
- placementAngle = defaultPlacementAngle;
+ placementSupport.SetDefaultAngle();
}
var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
- "template": placementEntity,
- "x": placementPosition.x,
- "z": placementPosition.z
+ "template": placementSupport.template,
+ "x": placementSupport.position.x,
+ "z": placementSupport.position.z
});
if (snapData)
{
- placementAngle = snapData.angle;
- placementPosition.x = snapData.x;
- placementPosition.z = snapData.z;
+ placementSupport.angle = snapData.angle;
+ placementSupport.position.x = snapData.x;
+ placementSupport.position.z = snapData.z;
}
updateBuildingPlacementPreview();
@@ -725,7 +892,7 @@ function handleInputBeforeGui(ev, hoveredObject)
if (ev.button == SDL_BUTTON_RIGHT)
{
// Cancel building
- resetPlacementEntity();
+ placementSupport.Reset();
inputState = INPUT_NORMAL;
return true;
}
@@ -819,6 +986,7 @@ function handleInputAfterGui(ev)
break;
}
break;
+
case INPUT_PRESELECTEDACTION:
switch (ev.type)
{
@@ -849,6 +1017,7 @@ function handleInputAfterGui(ev)
}
}
break;
+
case INPUT_SELECTING:
switch (ev.type)
{
@@ -922,7 +1091,7 @@ function handleInputAfterGui(ev)
}
// TODO: Should we handle "control all units" here as well?
- ents = Engine.PickSimilarFriendlyEntities(templateToMatch, showOffscreen, matchRank);
+ ents = Engine.PickSimilarFriendlyEntities(templateToMatch, showOffscreen, matchRank, false);
}
else
{
@@ -961,35 +1130,62 @@ function handleInputAfterGui(ev)
switch (ev.type)
{
case "mousemotion":
- placementPosition = Engine.GetTerrainAtPoint(ev.x, ev.y);
- var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
- "template": placementEntity,
- "x": placementPosition.x,
- "z": placementPosition.z
- });
- if (snapData)
+
+ placementSupport.position = Engine.GetTerrainAtPoint(ev.x, ev.y);
+
+ if (placementSupport.mode === "wall")
{
- placementAngle = snapData.angle;
- placementPosition.x = snapData.x;
- placementPosition.z = snapData.z;
+ // Including only the on-screen towers in the next snap candidate list is sufficient here, since the user is
+ // still selecting a starting point (which must necessarily be on-screen). (The update itself happens in the
+ // call to updateBuildingPlacementPreview below).
+ placementSupport.wallSnapEntitiesIncludeOffscreen = false;
+ }
+ else
+ {
+ var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
+ "template": placementSupport.template,
+ "x": placementSupport.position.x,
+ "z": placementSupport.position.z,
+ });
+ if (snapData)
+ {
+ placementSupport.angle = snapData.angle;
+ placementSupport.position.x = snapData.x;
+ placementSupport.position.z = snapData.z;
+ }
}
- updateBuildingPlacementPreview();
-
+ updateBuildingPlacementPreview(); // includes an update of the snap entity candidates
return false; // continue processing mouse motion
case "mousebuttondown":
if (ev.button == SDL_BUTTON_LEFT)
{
- placementPosition = Engine.GetTerrainAtPoint(ev.x, ev.y);
- dragStart = [ ev.x, ev.y ];
- inputState = INPUT_BUILDING_CLICK;
+ if (placementSupport.mode === "wall")
+ {
+ var validPlacement = updateBuildingPlacementPreview();
+ if (validPlacement !== false)
+ {
+ inputState = INPUT_BUILDING_WALL_CLICK;
+ }
+ else
+ {
+ // TODO: add a user-friendly notification
+ error("Not a valid starting location!");
+ }
+ }
+ else
+ {
+ placementSupport.position = Engine.GetTerrainAtPoint(ev.x, ev.y);
+ dragStart = [ ev.x, ev.y ];
+ inputState = INPUT_BUILDING_CLICK;
+ }
return true;
}
else if (ev.button == SDL_BUTTON_RIGHT)
{
// Cancel building
- resetPlacementEntity();
+ placementSupport.Reset();
inputState = INPUT_NORMAL;
return true;
}
@@ -1002,11 +1198,11 @@ function handleInputAfterGui(ev)
switch (ev.hotkey)
{
case "session.rotate.cw":
- placementAngle += rotation_step;
+ placementSupport.angle += rotation_step;
updateBuildingPlacementPreview();
break;
case "session.rotate.ccw":
- placementAngle -= rotation_step;
+ placementSupport.angle -= rotation_step;
updateBuildingPlacementPreview();
break;
}
@@ -1144,11 +1340,29 @@ function handleMinimapEvent(target)
}
// Called by GUI when user clicks construction button
-function startBuildingPlacement(buildEntType)
+// @param buildTemplate Template name of the entity the user wants to build
+function startBuildingPlacement(buildTemplate)
{
- placementEntity = buildEntType;
- placementAngle = defaultPlacementAngle;
- inputState = INPUT_BUILDING_PLACEMENT;
+ // TODO: we should clear any highlight selection rings here. If the mouse was over an entity before going onto the GUI
+ // to start building a structure, then the highlight selection rings are kept during the construction of the building.
+ // Gives the impression that somehow the hovered-over entity has something to do with the building you're constructing.
+
+ placementSupport.SetDefaultAngle();
+
+ // find out if we're building a wall, and change the entity appropriately if so
+ var templateData = GetTemplateData(buildTemplate);
+ if (templateData.wallSet)
+ {
+ placementSupport.mode = "wall";
+ placementSupport.wallSet = templateData.wallSet;
+ inputState = INPUT_BUILDING_PLACEMENT;
+ }
+ else
+ {
+ placementSupport.mode = "building";
+ placementSupport.template = buildTemplate;
+ inputState = INPUT_BUILDING_PLACEMENT;
+ }
}
// Called by GUI when user changes preferred trading goods
diff --git a/binaries/data/mods/public/gui/session/placement.js b/binaries/data/mods/public/gui/session/placement.js
new file mode 100644
index 0000000..29d5d04
--- /dev/null
+++ b/binaries/data/mods/public/gui/session/placement.js
@@ -0,0 +1,31 @@
+function PlacementSupport()
+{
+ this.Reset();
+}
+
+PlacementSupport.DEFAULT_ANGLE = Math.PI*3/4;
+
+/**
+ * Resets the building placement support state. Use this to cancel construction of an entity.
+ */
+PlacementSupport.prototype.Reset = function()
+{
+ this.mode = null;
+ this.position = null;
+ this.template = null;
+ this.wallSet = null; // maps types of wall pieces ("tower", "long", "short", ...) to template names
+ this.wallSnapEntities = null; // list of candidate entities to snap the starting and (!) ending positions to when building walls
+ this.wallEndPosition = null;
+ this.wallSnapEntitiesIncludeOffscreen = false; // should the next update of the snap candidate list include offscreen towers?
+
+ this.SetDefaultAngle();
+
+ warn("PlacementSupport::Reset");
+ Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {"template": ""});
+ Engine.GuiInterfaceCall("SetWallPlacementPreview", {"wallSet": null});
+};
+
+PlacementSupport.prototype.SetDefaultAngle = function()
+{
+ this.angle = PlacementSupport.DEFAULT_ANGLE;
+};
\ No newline at end of file
diff --git a/binaries/data/mods/public/gui/session/session.js b/binaries/data/mods/public/gui/session/session.js
index 8ecf776..c981c18 100644
--- a/binaries/data/mods/public/gui/session/session.js
+++ b/binaries/data/mods/public/gui/session/session.js
@@ -169,6 +169,10 @@ function getSavedGameData()
}
var lastTickTime = new Date;
+
+/**
+ * Called every frame.
+ */
function onTick()
{
var now = new Date;
@@ -187,7 +191,8 @@ function onTick()
updateCursorAndTooltip();
- // If the selection changed, we need to regenerate the sim display
+ // If the selection changed, we need to regenerate the sim display (the display depends on both the
+ // simulation state and the current selection).
if (g_Selection.dirty)
{
onSimulationUpdate();
@@ -252,6 +257,10 @@ function checkPlayerState()
}
}
+/**
+ * Recomputes GUI state that depends on simulation state or selection state. Called directly every simulation
+ * update (see session.xml), or from onTick when the selection has changed.
+ */
function onSimulationUpdate()
{
g_Selection.dirty = false;
diff --git a/binaries/data/mods/public/gui/session/session.xml b/binaries/data/mods/public/gui/session/session.xml
index 5de7e23..f5a37f3 100644
--- a/binaries/data/mods/public/gui/session/session.xml
+++ b/binaries/data/mods/public/gui/session/session.xml
@@ -9,6 +9,7 @@
+
diff --git a/binaries/data/mods/public/gui/session/unit_commands.js b/binaries/data/mods/public/gui/session/unit_commands.js
index 8e8e2da..0d84dde 100644
--- a/binaries/data/mods/public/gui/session/unit_commands.js
+++ b/binaries/data/mods/public/gui/session/unit_commands.js
@@ -120,7 +120,18 @@ function layoutButtonRow(rowNumber, guiName, buttonSideLength, buttonSpacer, sta
}
}
-// Sets up "unit panels" - the panels with rows of icons (Helper function for updateUnitDisplay)
+/**
+ * Helper function for updateUnitCommands; sets up "unit panels" (i.e. panels with rows of icons) for the currently selected
+ * unit.
+ *
+ * @param guiName Short identifier string of this panel; see constants defined at the top of this file.
+ * @param usedPanels Output object; usedPanels[guiName] will be set to 1 to indicate that this panel was used during this
+ * run of updateUnitCommands and should not be hidden. TODO: why is this done this way instead of having
+ * updateUnitCommands keep track of this?
+ * @param unitEntState Entity state of the (first) selected unit.
+ * @param items Panel-specific data to construct the icons with.
+ * @param callback Callback function to argument to execute when an item's icon gets clicked. Takes a single 'item' argument.
+ */
function setupUnitPanel(guiName, usedPanels, unitEntState, items, callback)
{
usedPanels[guiName] = 1;
@@ -183,7 +194,7 @@ function setupUnitPanel(guiName, usedPanels, unitEntState, items, callback)
for (i = 0; i < numberOfItems; i++)
{
var item = items[i];
- var entType = ((guiName == "Queue")? item.template : item);
+ var entType = ((guiName == "Queue") ? item.template : item);
var template;
if (guiName != "Formation" && guiName != "Command" && guiName != "Stance")
{
@@ -236,7 +247,7 @@ function setupUnitPanel(guiName, usedPanels, unitEntState, items, callback)
var [batchSize, batchIncrement] = getTrainingQueueBatchStatus(unitEntState.id, entType);
var trainNum = batchSize ? batchSize+batchIncrement : batchIncrement;
- tooltip += "\n" + getEntityCost(template);
+ tooltip += "\n" + getEntityCostTooltip(template);
if (template.health)
tooltip += "\n[font=\"serif-bold-13\"]Health:[/font] " + template.health;
@@ -256,9 +267,9 @@ function setupUnitPanel(guiName, usedPanels, unitEntState, items, callback)
if (template.tooltip)
tooltip += "\n[font=\"serif-13\"]" + template.tooltip + "[/font]";
- tooltip += "\n" + getEntityCost(template);
+ tooltip += "\n" + getEntityCostTooltip(template); // see utility_functions.js
+ tooltip += getPopulationBonusTooltip(template); // see utility_functions.js
- tooltip += getPopulationBonus(template);
if (template.health)
tooltip += "\n[font=\"serif-bold-13\"]Health:[/font] " + template.health;
@@ -483,7 +494,15 @@ function setupUnitBarterPanel(unitEntState)
}
}
-// Updates right Unit Commands Panel - runs in the main session loop via updateSelectionDetails()
+/**
+ * Updates the right hand side "Unit Commands" panel. Runs in the main session loop via updateSelectionDetails().
+ * Delegates to setupUnitPanel to set up individual subpanels, appropriately activated depending on the selected
+ * unit's state.
+ *
+ * @param entState Entity state of the (first) selected unit.
+ * @param supplementalDetailsPanel Reference to the "supplementalSelectionDetails" GUI Object
+ * @param selection Array of currently selected entity IDs.
+ */
function updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection)
{
// Panels that are active
diff --git a/binaries/data/mods/public/gui/session/utility_functions.js b/binaries/data/mods/public/gui/session/utility_functions.js
index 0d95a70..bbc81f7 100644
--- a/binaries/data/mods/public/gui/session/utility_functions.js
+++ b/binaries/data/mods/public/gui/session/utility_functions.js
@@ -193,27 +193,65 @@ function getEntityCommandsList(entState)
return commands;
}
-function getEntityCost(template)
+/**
+ * Helper function for getEntityCostTooltip.
+ */
+function getEntityCostComponentsTooltipString(template)
{
- var cost = "";
- if (template.cost)
+ var costs = [];
+ if (template.cost.food) costs.push(template.cost.food + " [font=\"serif-12\"]Food[/font]");
+ if (template.cost.wood) costs.push(template.cost.wood + " [font=\"serif-12\"]Wood[/font]");
+ if (template.cost.metal) costs.push(template.cost.metal + " [font=\"serif-12\"]Metal[/font]");
+ if (template.cost.stone) costs.push(template.cost.stone + " [font=\"serif-12\"]Stone[/font]");
+ if (template.cost.population) costs.push(template.cost.population + " [font=\"serif-12\"]Population[/font]");
+ return costs;
+}
+
+/**
+ * Returns the cost information to display in the specified entity's construction button tooltip.
+ */
+function getEntityCostTooltip(template)
+{
+ var cost = "[font=\"serif-bold-13\"]Costs:[/font] ";
+
+ // Entities with a wallset component are proxies for initiating wall placement and as such do not have a cost of
+ // their own; the individual wall pieces within it do.
+ if (template.wallSet)
+ {
+ var templateLong = GetTemplateData(template.wallSet.long);
+ var templateMedium = GetTemplateData(template.wallSet.medium);
+ var templateShort = GetTemplateData(template.wallSet.short);
+ var templateTower = GetTemplateData(template.wallSet.tower);
+
+ // TODO: the costs of the wall segments should be the same, and for now we will assume they are (ideally we
+ // should take the average here or something).
+ var wallCosts = getEntityCostComponentsTooltipString(templateLong);
+ var towerCosts = getEntityCostComponentsTooltipString(templateTower);
+
+ cost += "\n";
+ cost += " Walls: " + wallCosts.join(", ") + "\n";
+ cost += " Towers: " + towerCosts.join(", ");
+ }
+ else if (template.cost)
{
- var costs = [];
- if (template.cost.food) costs.push(template.cost.food + " [font=\"serif-12\"]Food[/font]");
- if (template.cost.wood) costs.push(template.cost.wood + " [font=\"serif-12\"]Wood[/font]");
- if (template.cost.metal) costs.push(template.cost.metal + " [font=\"serif-12\"]Metal[/font]");
- if (template.cost.stone) costs.push(template.cost.stone + " [font=\"serif-12\"]Stone[/font]");
- if (template.cost.population) costs.push(template.cost.population + " [font=\"serif-12\"]Population[/font]");
-
- cost += "[font=\"serif-bold-13\"]Costs:[/font] " + costs.join(", ");
+ var costs = getEntityCostComponentsTooltipString(template);
+ cost += costs.join(", ");
}
+ else
+ {
+ cost = ""; // cleaner than duplicating the serif-bold-13 stuff
+ }
+
return cost;
}
-function getPopulationBonus(template)
+/**
+ * Returns the population bonus information to display in the specified entity's construction button tooltip.
+ */
+function getPopulationBonusTooltip(template)
{
var popBonus = "";
- if (template.cost.populationBonus)
+ if (template.cost && template.cost.populationBonus)
popBonus = "\n[font=\"serif-bold-13\"]Population Bonus:[/font] " + template.cost.populationBonus;
return popBonus;
}
diff --git a/binaries/data/mods/public/maps/scenarios/WallTest.pmp b/binaries/data/mods/public/maps/scenarios/WallTest.pmp
new file mode 100644
index 0000000..bf23296
Binary files /dev/null and b/binaries/data/mods/public/maps/scenarios/WallTest.pmp differ
diff --git a/binaries/data/mods/public/maps/scenarios/WallTest.xml b/binaries/data/mods/public/maps/scenarios/WallTest.xml
new file mode 100644
index 0000000..44428a8
--- /dev/null
+++ b/binaries/data/mods/public/maps/scenarios/WallTest.xml
@@ -0,0 +1,167 @@
+
+
+
+
+ standard
+ default
+
+
+
+
+
+
+
+ default
+
+ 5
+ 150
+ 8
+ 0.45
+
+
+ 0
+
+
+
+
+
+
+
+
+
+
+
+ structures/celt_civil_centre
+ 1
+
+
+
+
+ structures/pers_civil_centre
+ 2
+
+
+
+
+ other/palisades_rocks_tower
+ 1
+
+
+
+
+ other/palisades_rocks_tower
+ 1
+
+
+
+
+ other/palisades_rocks_tower
+ 1
+
+
+
+
+ other/palisades_rocks_tower
+ 1
+
+
+
+
+ units/celt_fanatic
+ 1
+
+
+
+
+ units/celt_fanatic
+ 1
+
+
+
+
+ units/celt_fanatic
+ 1
+
+
+
+
+ units/celt_fanatic
+ 1
+
+
+
+
+ units/celt_fanatic
+ 1
+
+
+
+
+ units/celt_fanatic
+ 1
+
+
+
+
+
+
\ No newline at end of file
diff --git a/binaries/data/mods/public/simulation/components/BuildRestrictions.js b/binaries/data/mods/public/simulation/components/BuildRestrictions.js
index b9d1e87..b50999c 100644
--- a/binaries/data/mods/public/simulation/components/BuildRestrictions.js
+++ b/binaries/data/mods/public/simulation/components/BuildRestrictions.js
@@ -71,6 +71,9 @@ BuildRestrictions.prototype.Init = function()
this.territories = this.template.Territory.split(/\s+/);
};
+/**
+ * Returns true iff this entity can be built at its current position.
+ */
BuildRestrictions.prototype.CheckPlacement = function(player)
{
// TODO: Return error code for invalid placement, which can be handled by the UI
diff --git a/binaries/data/mods/public/simulation/components/Foundation.js b/binaries/data/mods/public/simulation/components/Foundation.js
index 14029da..f63a1e3 100644
--- a/binaries/data/mods/public/simulation/components/Foundation.js
+++ b/binaries/data/mods/public/simulation/components/Foundation.js
@@ -187,15 +187,38 @@ Foundation.prototype.Build = function(builderEnt, work)
cmpBuildingPosition.SetXZRotation(rot.x, rot.z);
// TODO: should add a ICmpPosition::CopyFrom() instead of all this
+ // ----------------------------------------------------------------------
+
var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
var cmpBuildingOwnership = Engine.QueryInterface(building, IID_Ownership);
cmpBuildingOwnership.SetOwner(cmpOwnership.GetOwner());
+ // ----------------------------------------------------------------------
+
+ // Copy over the obstruction control group IDs from the foundation entities. This is needed to ensure that when a foundation
+ // is completed and replaced by a new entity, it remains in the same control group(s) as any other foundation entities that
+ // may surround it. This is the mechanism that is used to e.g. enable wall pieces to be built closely together, ignoring their
+ // mutual obstruction shapes (since they would otherwise be prevented from being built so closely together). If the control
+ // groups are not copied over, the new entity will default to a new control group containing only itself, and will hence block
+ // construction of any surrounding foundations that it was previously in the same control group with.
+
+ // Note that this will result in the completed building entities having control group IDs that equal entity IDs of old (and soon
+ // to be deleted) foundation entities. This should not have any consequences, however, since the control group IDs are only meant
+ // to be unique identifiers, which is still true when reusing the old ones.
+
+ var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
+ var cmpBuildingObstruction = Engine.QueryInterface(building, IID_Obstruction);
+ cmpBuildingObstruction.SetControlGroup(cmpObstruction.GetControlGroup());
+ cmpBuildingObstruction.SetControlGroup2(cmpObstruction.GetControlGroup2());
+
+ // ----------------------------------------------------------------------
+
var cmpPlayerStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
cmpPlayerStatisticsTracker.IncreaseConstructedBuildingsCounter();
var cmpIdentity = Engine.QueryInterface(building, IID_Identity);
- if (cmpIdentity.GetClassesList().indexOf("CivCentre") != -1) cmpPlayerStatisticsTracker.IncreaseBuiltCivCentresCounter();
+ if (cmpIdentity.GetClassesList().indexOf("CivCentre") != -1)
+ cmpPlayerStatisticsTracker.IncreaseBuiltCivCentresCounter();
var cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
var cmpBuildingHealth = Engine.QueryInterface(building, IID_Health);
@@ -203,9 +226,7 @@ Foundation.prototype.Build = function(builderEnt, work)
PlaySound("constructed", building);
- Engine.PostMessage(this.entity, MT_ConstructionFinished,
- { "entity": this.entity, "newentity": building });
-
+ Engine.PostMessage(this.entity, MT_ConstructionFinished, { "entity": this.entity, "newentity": building });
Engine.BroadcastMessage(MT_EntityRenamed, { entity: this.entity, newentity: building });
Engine.DestroyEntity(this.entity);
diff --git a/binaries/data/mods/public/simulation/components/GuiInterface.js b/binaries/data/mods/public/simulation/components/GuiInterface.js
index 2c4a82f..47058e7 100644
--- a/binaries/data/mods/public/simulation/components/GuiInterface.js
+++ b/binaries/data/mods/public/simulation/components/GuiInterface.js
@@ -18,6 +18,8 @@ GuiInterface.prototype.Deserialize = function(obj)
GuiInterface.prototype.Init = function()
{
this.placementEntity = undefined; // = undefined or [templateName, entityID]
+ this.placementWallEntities = undefined;
+ this.placementWallLastAngle = 0;
this.rallyPoints = undefined;
this.notifications = [];
this.renamedEntities = [];
@@ -131,7 +133,7 @@ GuiInterface.prototype.GetEntityState = function(player, ent)
var ret = {
"id": ent,
"template": template
- }
+ };
var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
if (cmpIdentity)
@@ -202,6 +204,15 @@ GuiInterface.prototype.GetEntityState = function(player, ent)
};
}
+ var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
+ if (cmpObstruction)
+ {
+ ret.obstruction = {
+ "controlGroup": cmpObstruction.GetControlGroup(),
+ "controlGroup2": cmpObstruction.GetControlGroup2(),
+ };
+ }
+
var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
if (cmpOwnership)
{
@@ -311,6 +322,26 @@ GuiInterface.prototype.GetTemplateData = function(player, name)
}
}
+ if (template.BuildRestrictions)
+ {
+ // required properties
+ ret.buildRestrictions = {
+ "placementType": template.BuildRestrictions.PlacementType,
+ "territory": template.BuildRestrictions.Territory,
+ "category": template.BuildRestrictions.Category,
+ };
+
+ // optional properties
+ if (template.BuildRestrictions.Distance)
+ {
+ ret.buildRestrictions.distance = {
+ "fromCategory": template.BuildRestrictions.Distance.FromCategory,
+ };
+ if (template.BuildRestrictions.Distance.MinDistance) ret.buildRestrictions.distance.min = +template.BuildRestrictions.Distance.MinDistance;
+ if (template.BuildRestrictions.Distance.MaxDistance) ret.buildRestrictions.distance.max = +template.BuildRestrictions.Distance.MaxDistance;
+ }
+ }
+
if (template.Cost)
{
ret.cost = {};
@@ -322,6 +353,44 @@ GuiInterface.prototype.GetTemplateData = function(player, name)
if (template.Cost.PopulationBonus) ret.cost.populationBonus = +template.Cost.PopulationBonus;
}
+ if (template.Footprint)
+ {
+ ret.footprint = {"height": template.Footprint.Height};
+
+ if (template.Footprint.Square)
+ ret.footprint.square = {"width": +template.Footprint.Square["@width"], "depth": +template.Footprint.Square["@depth"]};
+ else if (template.Footprint.Circle)
+ ret.footprint.circle = {"radius": +template.Footprint.Circle["@radius"]};
+ else
+ warn("[GetTemplateData] Unrecognized Footprint type");
+ }
+
+ if (template.Obstruction)
+ {
+ ret.obstruction = {
+ "active": ("" + template.Obstruction.Active == "true"),
+ "blockMovement": ("" + template.Obstruction.BlockMovement == "true"),
+ "blockPathfinding": ("" + template.Obstruction.BlockPathfinding == "true"),
+ "blockFoundation": ("" + template.Obstruction.BlockFoundation == "true"),
+ "blockConstruction": ("" + template.Obstruction.BlockConstruction == "true"),
+ "disableBlockMovement": ("" + template.Obstruction.DisableBlockMovement == "true"),
+ "disableBlockPathfinding": ("" + template.Obstruction.DisableBlockPathfinding == "true"),
+ "shape": {}
+ };
+
+ if (template.Obstruction.Static)
+ {
+ ret.obstruction.shape.type = "static";
+ ret.obstruction.shape.width = +template.Obstruction.Static["@width"];
+ ret.obstruction.shape.depth = +template.Obstruction.Static["@depth"];
+ }
+ else
+ {
+ ret.obstruction.shape.type = "unit";
+ ret.obstruction.shape.radius = +template.Obstruction.Unit["@radius"];
+ }
+ }
+
if (template.Health)
{
ret.health = +template.Health.Max;
@@ -346,6 +415,22 @@ GuiInterface.prototype.GetTemplateData = function(player, name)
if (template.UnitMotion.Run) ret.speed.run = +template.UnitMotion.Run.Speed;
}
+ if (template.WallSet)
+ {
+ ret.wallSet = {
+ "long": template.WallSet.WallLong,
+ "medium": template.WallSet.WallMedium,
+ "short": template.WallSet.WallShort,
+ "tower": template.WallSet.Tower,
+ "gate": template.WallSet.Gate,
+ };
+ }
+
+ if (template.WallPiece)
+ {
+ ret.wallPiece = {"length": +template.WallPiece.Length};
+ }
+
return ret;
};
@@ -517,6 +602,7 @@ GuiInterface.prototype.DisplayRallyPoint = function(player, cmd)
* Display the building placement preview.
* cmd.template is the name of the entity template, or "" to disable the preview.
* cmd.x, cmd.z, cmd.angle give the location.
+ *
* Returns true if the placement is okay (everything is valid and the entity is not obstructed by others).
*/
GuiInterface.prototype.SetBuildingPlacementPreview = function(player, cmd)
@@ -585,11 +671,487 @@ GuiInterface.prototype.SetBuildingPlacementPreview = function(player, cmd)
return false;
};
+/**
+ * Previews the placement of a wall between cmd.start and cmd.end, or just the starting piece of a wall if cmd.end is not
+ * specified. Returns an object with information about the list of entities that need to be newly constructed to complete
+ * at least a part of the wall, or false if there are entities required to build at least part of the wall but none of
+ * them can be validly constructed.
+ *
+ * It's important to distinguish between three lists of entities that are at play here, because they may be subsets of one
+ * another depending on things like snapping and whether some of the entities inside them can be validly positioned.
+ * We have:
+ * - The list of entities that previews the wall. This list is usually equal to the entities required to construct the
+ * entire wall. However, if there is snapping to an incomplete tower (i.e. a foundation), it includes extra entities
+ * to preview the completed tower on top of its foundation.
+ *
+ * - The list of entities that need to be newly constructed to build the entire wall. This list is regardless of whether
+ * any of them can be validly positioned. The emphasishere here is on 'newly'; this list does not include any existing
+ * towers at either side of the wall that we snapped to. Or, more generally; it does not include any _entities_ that we
+ * snapped to; we might still snap to e.g. terrain, in which case the towers on either end will still need to be newly
+ * constructed.
+ *
+ * - The list of entities that need to be newly constructed to build at least a part of the wall. This list is the same
+ * as the one above, except that it is truncated at the first entity that cannot be validly positioned. This happens
+ * e.g. if the player tries to build a wall straight through an obstruction. Note that any entities that can be validly
+ * constructed but come after said first invalid entity are also truncated away.
+ *
+ * With this in mind, this method will return false if the second list is not empty, but the third one is. That is, if there
+ * were entities that are needed to build the wall, but none of them can be validly constructed. False is also returned in
+ * case of unexpected errors (typically missing components), and when clearing the preview by passing an empty wallset
+ * argument (see below). Otherwise, it will return an object with the following information:
+ *
+ * result: {
+ * 'startSnappedEnt': ID of the entity that we snapped to at the starting side of the wall. Currently only supports towers.
+ * 'endSnappedEnt': ID of the entity that we snapped to at the (possibly truncated) ending side of the wall. Note that this
+ * can only be set if no truncation of the second list occurs; if we snapped to an entity at the ending side
+ * but the wall construction was truncated before we could reach it, it won't be set here. Currently only
+ * supports towers.
+ * 'pieces': Array with the following data for each of the entities in the third list:
+ * [{
+ * 'template': Template name of the entity.
+ * 'x': X coordinate of the entity's position.
+ * 'z': Z coordinate of the entity's position.
+ * 'angle': Rotation around the Y axis of the entity (in radians).
+ * },
+ * ...]
+ * }
+ *
+ * @param cmd.wallSet Object holding the set of wall piece template names. Set to an empty value to clear the preview.
+ * @param cmd.start Starting point of the wall segment being created.
+ * @param cmd.end (Optional) Ending point of the wall segment being created. If not defined, it is understood that only
+ * the starting point of the wall is available at this time (e.g. while the player is still in the process
+ * of picking a starting point), and that therefore only the first entity in the wall (a tower) should be
+ * previewed.
+ * @param cmd.snapEntities List of candidate entities to snap the start and ending positions to.
+ */
+GuiInterface.prototype.SetWallPlacementPreview = function(player, cmd)
+{
+ var wallSet = cmd.wallSet;
+
+ var start = {
+ "pos": cmd.start,
+ "angle": 0,
+ "snapped": false, // did the start position snap to anything?
+ "snappedEnt": INVALID_ENTITY, // if we snapped, was it to an entity? if yes, holds that entity's ID
+ };
+
+ var end = {
+ "pos": cmd.end,
+ "angle": 0,
+ "snapped": false, // did the start position snap to anything?
+ "snappedEnt": INVALID_ENTITY, // if we snapped, was it to an entity? if yes, holds that entity's ID
+ };
+
+ // --------------------------------------------------------------------------------
+ // do some entity cache management and check for snapping
+
+ if (!this.placementWallEntities)
+ this.placementWallEntities = {};
+
+ if (!wallSet)
+ {
+ // we're clearing the preview, clear the entity cache and bail
+ var numCleared = 0;
+ for (var tpl in this.placementWallEntities)
+ {
+ for each (var ent in this.placementWallEntities[tpl].entities)
+ Engine.DestroyEntity(ent);
+
+ this.placementWallEntities[tpl].numUsed = 0;
+ this.placementWallEntities[tpl].entities = [];
+ // keep template data around
+ }
+
+ return false;
+ }
+ else
+ {
+ // Move all existing cached entities outside of the world and reset their use count
+ for (var tpl in this.placementWallEntities)
+ {
+ for each (var ent in this.placementWallEntities[tpl].entities)
+ {
+ var pos = Engine.QueryInterface(ent, IID_Position);
+ if (pos)
+ pos.MoveOutOfWorld();
+ }
+
+ this.placementWallEntities[tpl].numUsed = 0;
+ }
+
+ // Create cache entries for templates we haven't seen before
+ for each (var tpl in wallSet)
+ {
+ if (!(tpl in this.placementWallEntities))
+ {
+ //warn("[SetWallPlacementPreview] Initializing wall data for '" + tpl + "'");
+ this.placementWallEntities[tpl] = {
+ "numUsed": 0,
+ "entities": [],
+ "templateData": this.GetTemplateData(player, tpl),
+ };
+
+ // ensure that the loaded template data contains a wallPiece component
+ if (!this.placementWallEntities[tpl].templateData.wallPiece)
+ {
+ error("[SetWallPlacementPreview] No WallPiece component found for wall set template '" + tpl + "'");
+ return false;
+ }
+ }
+ }
+ }
+
+
+ // prevent division by zero errors further on if the start and end positions are the same
+ if (end.pos && (start.pos.x === end.pos.x && start.pos.z === end.pos.z))
+ end.pos = undefined;
+
+ // See if we need to snap the start and/or end coordinates to any of our list of snap entities. Note that, despite the list
+ // of snapping candidate entities, it might still snap to e.g. terrain features. Use the "ent" key in the returned snapping
+ // data (if any) to determine whether it snapped to an entity, and to which one (see GetFoundationSnapData).
+ if (cmd.snapEntities)
+ {
+ var snapRadius = this.placementWallEntities[wallSet.tower].templateData.wallPiece.length * 0.5; // determined through trial and error
+ var startSnapData = this.GetFoundationSnapData(player, {
+ "x": start.pos.x,
+ "z": start.pos.z,
+ "template": wallSet.tower,
+ "snapEntities": cmd.snapEntities,
+ "snapRadius": snapRadius,
+ });
+
+ if (startSnapData)
+ {
+ start.pos.x = startSnapData.x;
+ start.pos.z = startSnapData.z;
+ start.angle = startSnapData.angle;
+ start.snapped = true;
+
+ if (startSnapData.ent)
+ start.snappedEnt = startSnapData.ent;
+ }
+
+ if (end.pos)
+ {
+ var endSnapData = this.GetFoundationSnapData(player, {
+ "x": end.pos.x,
+ "z": end.pos.z,
+ "template": wallSet.tower,
+ "snapEntities": cmd.snapEntities,
+ "snapRadius": snapRadius,
+ });
+
+ if (endSnapData)
+ {
+ end.pos.x = endSnapData.x;
+ end.pos.z = endSnapData.z;
+ end.angle = endSnapData.angle;
+ end.snapped = true;
+
+ if (endSnapData.ent)
+ end.snappedEnt = endSnapData.ent;
+ }
+ }
+ }
+
+ // clear the single-building preview entity (we'll be rolling our own)
+ this.SetBuildingPlacementPreview(player, {"template": ""});
+
+ // --------------------------------------------------------------------------------
+ // calculate wall placement and position preview entities
+
+ var result = {"pieces": []};
+
+ var previewEntities = [];
+ if (end.pos)
+ previewEntities = GetWallPlacement(this.placementWallEntities, wallSet, start, end); // see helpers/Walls.js
+
+ // For wall placement, we may (and usually do) need to have wall pieces overlap each other more than would
+ // otherwise be allowed by their obstruction shapes. However, during this preview phase, this is not so much of
+ // an issue, because all preview entities have their obstruction components deactivated, meaning that their
+ // obstruction shapes do not register in the simulation and hence cannot affect it. This means that the preview
+ // entities cannot be found to obstruct each other, which largely solves the issue of overlap between wall pieces.
+
+ // Note that they will still be obstructed by existing shapes in the simulation (that have the BLOCK_FOUNDATION
+ // flag set), which is what we want. The only exception to this is when snapping to existing towers (or
+ // foundations thereof); the wall segments that connect up to these will be found to be obstructed by the
+ // existing tower/foundation and be shaded red to indicate that they cannot be placed there. To prevent this,
+ // we manually set the control group of the outermost wall pieces equal to those of the snapped-to towers, so
+ // that they are free from mutual obstruction (per definition of obstruction control groups). This is done by
+ // assigning them an extra "controlGroup" field, which we'll then set during the placement loop below.
+
+ // Additionally, in the situation that we're snapping to merely a foundation of a tower instead of a fully
+ // constructed one, we'll need an extra preview entity for the starting tower, which also must not be obstructed
+ // by the foundation it snaps to.
+
+ if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
+ {
+ var startEntObstruction = Engine.QueryInterface(start.snappedEnt, IID_Obstruction);
+ if (previewEntities.length > 0 && startEntObstruction)
+ previewEntities[0].controlGroup = startEntObstruction.GetControlGroup();
+
+ // if we're snapping to merely a foundation, add an extra preview tower and also set it to the same control group
+ var startEntState = this.GetEntityState(player, start.snappedEnt);
+ if (startEntState.foundation)
+ {
+ var cmpPosition = Engine.QueryInterface(start.snappedEnt, IID_Position);
+ if (cmpPosition)
+ {
+ previewEntities.unshift({
+ "template": wallSet.tower,
+ "pos": start.pos,
+ "angle": cmpPosition.GetRotation().y,
+ "controlGroup": (startEntObstruction ? startEntObstruction.GetControlGroup() : undefined),
+ "excludeFromResult": true,
+ });
+ }
+ }
+ }
+ else
+ {
+ // Didn't snap to an existing entity, add the starting tower manually. Reuse the placement angle that was last
+ // seen on a validly positioned wall piece, for better visual consistency and to prevent odd-looking jumps in
+ // rotation when shift-clicking to build a wall.
+
+ // (Consider what happens if we used a constant of, say, 0 instead. Issuing the build command for a wall is
+ // asynchronous, so when the preview updates after shift-clicking, the foundation is typically not there yet in
+ // the simulation. This means they cannot possibly be picked in the list of candidate entities for snapping, and
+ // so we hit this case and rotate the preview to 0 radians. Then, after one or two simulation updates or so, the
+ // foundation registers and onSimulationUpdate in session.js updates the preview again. It first grabs a new list
+ // of snapping candidates, which this time does contain the new foundations; so we snap to the entity, and rotate
+ // the preview back to the foundation's angle. The result is a noticeable rotation to 0 and back, which is
+ // undesirable. So, for a split second there until the simulation updates, we fake it by reusing the last angle,
+ // and hope the player doesn't notice).
+ previewEntities.unshift({
+ "template": wallSet.tower,
+ "pos": start.pos,
+ "angle": (previewEntities.length > 0 ? previewEntities[0].angle : this.placementWallLastAngle)
+ });
+ }
+
+ if (end.pos)
+ {
+ // Analogous to the starting side case above
+ if (end.snappedEnt && end.snappedEnt != INVALID_ENTITY)
+ {
+ var endEntObstruction = Engine.QueryInterface(end.snappedEnt, IID_Obstruction);
+
+ // TODO: technically it's possible (but highly unlikely) for the last entity in previewEntities to be the same as the first,
+ // i.e. the same wall piece snapping to both a starting and an ending tower. For this to happen, the wall piece would have to
+ // be exactly as long as the distance between start.pos and end.pos, but it's possible, so we should probably turn
+ // '.controlGroup' into '.controlGroups' and append to it, and assign them to the primary and secondary control groups if there
+ // are two (there can only be 0, 1 or 2).
+ if (previewEntities.length > 0 && endEntObstruction)
+ previewEntities[previewEntities.length-1].controlGroup = endEntObstruction.GetControlGroup();
+
+ // if we're snapping to a foundation, add an extra preview tower and also set it to the same control group
+ var endEntState = this.GetEntityState(player, end.snappedEnt);
+ if (endEntState.foundation)
+ {
+ var cmpPosition = Engine.QueryInterface(end.snappedEnt, IID_Position);
+ if (cmpPosition)
+ {
+ previewEntities.push({
+ "template": wallSet.tower,
+ "pos": end.pos,
+ "angle": cmpPosition.GetRotation().y,
+ "controlGroup": (endEntObstruction ? endEntObstruction.GetControlGroup() : undefined),
+ "excludeFromResult": true
+ });
+ }
+ }
+ }
+ else
+ {
+ previewEntities.push({
+ "template": wallSet.tower,
+ "pos": end.pos,
+ "angle": (previewEntities.length > 0 ? previewEntities[previewEntities.length-1].angle : this.placementWallLastAngle)
+ });
+ }
+ }
+
+ // Loop through the preview entities, and construct the subset of them that need to be, and can be, validly constructed to build at
+ // least a part of the wall (meaning that the subset is truncated after the first entity that needs to be, but cannot validly be,
+ // constructed).
+
+ var allPiecesValid = true;
+ var numRequiredPieces = 0; // number of entities that are required to build the entire wall, regardless of validity
+
+ for (var i = 0; i < previewEntities.length; ++i)
+ {
+ var entInfo = previewEntities[i];
+
+ var ent = null;
+ var tpl = entInfo.template;
+ var entPool = this.placementWallEntities[tpl];
+
+ if (entPool.numUsed >= entPool.entities.length)
+ {
+ // allocate new entity
+ //warn("Allocating new entity of template '" + tpl + "'");
+ ent = Engine.AddLocalEntity("preview|" + tpl);
+ entPool.entities.push(ent);
+ }
+ else
+ {
+ // reuse an existing one
+ ent = entPool.entities[entPool.numUsed];
+ }
+
+ if (!ent)
+ {
+ error("[SetWallPlacementPreview] Failed to allocate or reuse preview entity of template '" + tpl + "'");
+ continue;
+ }
+
+ // move piece to right location
+ // TODO: reuse SetBuildingPlacementReview for this, multiplexed to be able to deal with multiple entities?
+
+ var cmpPosition = Engine.QueryInterface(ent, IID_Position);
+ if (cmpPosition)
+ {
+ cmpPosition.JumpTo(entInfo.pos.x, entInfo.pos.z);
+ cmpPosition.SetYRotation(entInfo.angle);
+ }
+
+ var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
+ if (!cmpObstruction)
+ {
+ error("[SetWallPlacementPreview] Preview entity of template " + tpl + " does not have an obstruction component!");
+ continue;
+ }
+
+ if (entInfo.controlGroup)
+ {
+ cmpObstruction.SetControlGroup(entInfo.controlGroup);
+ }
+ else
+ {
+ // Reset the control group (remember, we're reusing entities; without this, an ending wall segment that was
+ // at one point snapped to an existing tower, and is subsequently reused to be the same ending segment (only
+ // this time not snapped), would no longer be capable of being obstructed by the same tower)
+ cmpObstruction.SetControlGroup(ent);
+ }
+
+ // check whether this wall piece can be validly positioned here
+ var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
+ if (!cmpBuildRestrictions)
+ {
+ error("[SetWallPlacementPreview] cmpBuildRestrictions not defined for template '" + tpl + "'");
+ continue;
+ }
+
+ var validPlacement = (cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement(player));
+ allPiecesValid = allPiecesValid && validPlacement;
+
+ var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
+ if (cmpVisual)
+ {
+ if (!validPlacement)
+ cmpVisual.SetShadingColour(1.4, 0.4, 0.4, 1);
+ else
+ cmpVisual.SetShadingColour(1, 1, 1, 1);
+ }
+
+ // The requirement that all pieces so far have to have valid positions, rather than only this single one,
+ // ensures that no more foundations will be placed after a first invalidly-positioned piece. (It is possible
+ // for pieces past some invalidly-positioned ones to still have valid positions, e.g. if you drag a wall
+ // through and past an existing building).
+
+ // Additionally, the excludeFromResult flag is set for preview entities that were manually added to be placed
+ // on top of foundations of incompleted towers that we snapped to; they must not be part of the result.
+
+ if (!entInfo.excludeFromResult)
+ numRequiredPieces++;
+
+ if (allPiecesValid && !entInfo.excludeFromResult)
+ {
+ result.pieces.push({
+ "template": tpl,
+ "x": entInfo.pos.x,
+ "z": entInfo.pos.z,
+ "angle": entInfo.angle,
+ });
+ this.placementWallLastAngle = entInfo.angle;
+ }
+
+ entPool.numUsed++;
+ }
+
+ // If any were entities required to build the wall, but none of them could be validly positioned, return failure
+ // (see method documentation).
+ if (numRequiredPieces > 0 && result.pieces.length <= 0)
+ return false;
+
+ if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
+ result.startSnappedEnt = start.snappedEnt;
+
+ // We should only return that we snapped to an entity if all pieces up until that entity can be validly constructed,
+ // i.e. are included in result.pieces (see docs for the result object).
+ if (end.pos && end.snappedEnt && end.snappedEnt != INVALID_ENTITY && allPiecesValid)
+ result.endSnappedEnt = end.snappedEnt;
+
+ return result;
+};
+
+/**
+ * Given the current position {data.x, data.z} of an foundation of template data.template, returns the position and angle to snap
+ * it to (if necessary/useful).
+ *
+ * @param data.x The X position of the foundation to snap.
+ * @param data.z The Z position of the foundation to snap.
+ * @param data.template The template to get the foundation snapping data for.
+ * @param data.snapEntities Optional; list of entity IDs to snap to if {data.x, data.z} is within a circle of radius data.snapRadius
+ * around the entity. Only takes effect when used in conjunction with data.snapRadius.
+ * When this option is used and the foundation is found to snap to one of the entities passed in this list
+ * (as opposed to e.g. snapping to terrain features), then the result will contain an additional key "ent",
+ * holding the ID of the entity that was snapped to.
+ * @param data.snapRadius Optional; when used in conjunction with data.snapEntities, indicates the circle radius around an entity that
+ * {data.x, data.z} must be located within to have it snap to that entity.
+ */
GuiInterface.prototype.GetFoundationSnapData = function(player, data)
{
var cmpTemplateMgr = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
var template = cmpTemplateMgr.GetTemplate(data.template);
+ if (!template)
+ {
+ warn("[GetFoundationSnapData] Failed to load template '" + data.template + "'");
+ return false;
+ }
+
+ if (data.snapEntities && data.snapRadius && data.snapRadius > 0)
+ {
+ // see if {data.x, data.z} is inside the snap radius of any of the snap entities; and if so, to which it is closest
+ // (TODO: break unlikely ties by choosing the lowest entity ID)
+
+ var minDist2 = -1;
+ var minDistEntitySnapData = null;
+ var radius2 = data.snapRadius * data.snapRadius;
+
+ for each (ent in data.snapEntities)
+ {
+ var cmpPosition = Engine.QueryInterface(ent, IID_Position);
+ if (!cmpPosition || !cmpPosition.IsInWorld())
+ continue;
+
+ var pos = cmpPosition.GetPosition();
+ var dist2 = (data.x - pos.x) * (data.x - pos.x) + (data.z - pos.z) * (data.z - pos.z);
+ if (dist2 > radius2)
+ continue;
+
+ if (minDist2 < 0 || dist2 < minDist2)
+ {
+ minDist2 = dist2;
+ minDistEntitySnapData = {"x": pos.x, "z": pos.z, "angle": cmpPosition.GetRotation().y, "ent": ent};
+ }
+ }
+
+ if (minDistEntitySnapData != null)
+ return minDistEntitySnapData;
+ }
+
if (template.BuildRestrictions.Category == "Dock")
{
var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
@@ -813,6 +1375,7 @@ var exposedFunctions = {
"SetStatusBars": 1,
"DisplayRallyPoint": 1,
"SetBuildingPlacementPreview": 1,
+ "SetWallPlacementPreview": 1,
"GetFoundationSnapData": 1,
"PlaySound": 1,
"FindIdleUnit": 1,
diff --git a/binaries/data/mods/public/simulation/components/WallPiece.js b/binaries/data/mods/public/simulation/components/WallPiece.js
new file mode 100644
index 0000000..f55f4d0
--- /dev/null
+++ b/binaries/data/mods/public/simulation/components/WallPiece.js
@@ -0,0 +1,16 @@
+function WallPiece() {}
+
+WallPiece.prototype.Schema =
+ "" +
+ "" +
+ "" +
+ "" +
+ "