Ticket #524: rallypoints_wip_25aug11.patch

binaries/data/mods/public/art/actors/props/special/common/waypoint_flag.xml

@@ -11 +11 @@
     <variant name="waypoint_hellenes">
       <texture>props/banner_greek.png</texture>
     </variant>
+    <variant name="waypoint_persians">
+      <texture>props/banner_persian.png</texture>
+    </variant>
+    <variant name="waypoint_celts">
+      <texture>props/banner_celt.png</texture>
+    </variant>
+    <variant name="waypoint_carthaginians">
+      <texture>props/banner_carthage.png</texture>
+    </variant>
+    <variant name="waypoint_iberians">
+      <texture>props/banner_iberians.png</texture>
+    </variant>
+    <variant name="waypoint_romans">
+      <texture>props/banner_romans.png</texture>
+    </variant>
   </group>
 </actor>

binaries/data/mods/public/gui/session/input.js

@@ -1109 +1109 @@
             case "unload-all":
                 unloadAll(entity);
                 break;
+            case "focus-rally":
+                // make the camera move to the building's rally point
+                
+                // grab the rally point position (if any)
+                var entState = Engine.GuiInterfaceCall("GetEntityState", entity);
+                if (entState.rallyPoint)
+                {
+                    // the rally point isn't necessarily set
+                    if (entState.rallyPoint.position)
+                    {
+                        Engine.CameraMoveTo(entState.rallyPoint.position.x, entState.rallyPoint.position.z);
+                    }
+                    else
+                    {
+                        // no rally point set, jump to the building itself instead (since units will now spawn right next to the
+                        // building)
+                        if (entState.position)
+                            Engine.CameraMoveTo(entState.position.x, entState.position.z);
+                    }
+                }
+                
+                break;
             default:
                 break;
             }

binaries/data/mods/public/gui/session/unit_commands.js

@@ -225 +225 @@
             break;
 
         case COMMAND:
-            if (item == "unload-all")
+            // here, "item" is an object with properties .name (command name), .tooltip and .icon (relative to session/icons/single)
+            if (item.name == "unload-all")
             {
                 var count = unitEntState.garrisonHolder.entities.length;
                 getGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = (count > 0 ? count : "");
@@ -235 +236 @@
                 getGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = "";
             }
 
-            tooltip = toTitleCase(item);
+            tooltip = (item.tooltip ? item.tooltip : toTitleCase(item.name)); // use item.tooltip if available, otherwise default to title-cased command name
             break;
 
         default:
@@ -289 +290 @@
         {
             //icon.cell_id = i;
             //icon.cell_id = getCommandCellId(item);
-            icon.sprite = "stretched:session/icons/single/" + getCommandImage(item);
+            icon.sprite = "stretched:session/icons/single/" + item.icon;
             
         }
         else if (template.icon)
@@ -373 +374 @@
         var commands = getEntityCommandsList(entState);
         if (commands.length)
             setupUnitPanel("Command", usedPanels, entState, commands,
-                function (item) { performCommand(entState.id, item); } );
+                function (item) { performCommand(entState.id, item.name); } );
 
         if (entState.garrisonHolder)
         {

binaries/data/mods/public/gui/session/utility_functions.js

@@ -253 +253 @@
     }
 }
 
-function getCommandImage(commandName)
-{
-    switch (commandName)
-    {
-    case "delete":
-        return "kill_small.png";
-    case "unload-all":
-        return "garrison-out.png";
-    case "garrison":
-        return "garrison.png";
-    case "repair":
-        return "repair.png";
-    default:
-        return "";
-    }
-}
-
 function getEntityFormationsList(entState)
 {
     var civ = g_Players[entState.player].civ;
@@ -298 +281 @@
 {
     var commands = [];
     if (entState.garrisonHolder)
-        commands.push("unload-all");
-    commands.push("delete");
+    {
+        commands.push({
+            "name": "unload-all",
+            "tooltip": "Unload All",
+            "icon": "garrison-out.png"
+        });
+    }
+    
+    commands.push({
+        "name": "delete",
+        "tooltip": "Delete",
+        "icon": "kill_small.png"
+    });
+    
     if (isUnit(entState))
-        commands.push("garrison");
+    {
+        commands.push({
+            "name": "garrison",
+            "tooltip": "Garrison",
+            "icon": "garrison.png"
+        });
+    }
+    
     if (entState.buildEntities)
-        commands.push("repair");
+    {
+        commands.push({
+            "name": "repair",
+            "tooltip": "Repair",
+            "icon": "repair.png"
+        });
+    }
+    
+    if(entState.rallyPoint)
+    {
+        commands.push({
+            "name": "focus-rally",
+            "tooltip": "Focus on Rally Point",
+            "icon": "focus-rally.png"
+        });
+    }
+    
     return commands;
 }
 

binaries/data/mods/public/shaders/overlayline.fp

@@ -3 +3 @@
 TEMP base;
 TEMP mask;
 TEMP color;
-TEMP los;
+
 
 // Combine base texture and color, using mask texture
 TEX base, fragment.texcoord[0], texture[0], 2D;
 TEX mask, fragment.texcoord[0], texture[1], 2D;
 LRP color.rgb, mask, objectColor, base;
 
+#ifdef IGNORE_LOS
+  MOV result.color.rgb, color;
+  MOV result.color.a, 1; // full-bright
+#else
+  TEMP los;
 // Multiply by LOS texture
 TEX los, fragment.texcoord[1], texture[2], 2D;
 MUL result.color.rgb, color, los.a;
 
 // Use alpha from base texture
+  //MOV result.color.a, base.a;
 MUL result.color.a, objectColor.a, base.a;
+#endif
+
 
 END

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -219 +219 @@
     if (cmpRallyPoint)
     {
         ret.rallyPoint = { };
+        if (cmpRallyPoint.IsSet()) // can't return a rally point position if none is set ...
+            ret.rallyPoint.position = cmpRallyPoint.GetPosition();
     }
 
     var cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
@@ -376 +378 @@
  */
 GuiInterface.prototype.DisplayRallyPoint = function(player, cmd)
 {
-    // If there are rally points already displayed, destroy them
-    for each (var ent in this.rallyPoints)
+    // If there are some rally points already displayed, first hide them
+    for each (var ent in this.entsRallyPointsDisplayed)
     {
-        // Hide it first (the destruction won't be instantaneous)
-        var cmpPosition = Engine.QueryInterface(ent, IID_Position);
-        cmpPosition.MoveOutOfWorld();
+        var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
+        if (!cmpRallyPoint)
+            continue;
 
-        Engine.DestroyEntity(ent);
+        cmpRallyPoint.SetDisplayed(false);
     }
 
-    this.rallyPoints = [];
-
-    var positions = [];
-    // DisplayRallyPoints is called passing a list of entities for which
-    // rally points must be displayed
+    // Show the rally points for the passed entities
     for each (var ent in cmd.entities)
     {
         var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
@@ -402 +400 @@
         if (!cmpOwnership || cmpOwnership.GetOwner() != player)
             continue;
 
-        // If the command was passed an explicit position, use that and
-        // override the real rally point position; otherwise use the real position
-        var pos;
+        // If the command was passed an explicit position, first set it
         if (cmd.x && cmd.z)
-            pos = {"x": cmd.x, "z": cmd.z};
-        else
-            pos = cmpRallyPoint.GetPosition();
+            cmpRallyPoint.SetPosition(cmd);
 
-        if (pos)
-        {
-            // TODO: it'd probably be nice if we could draw some kind of line
-            // between the building and pos, to make the marker easy to find even
-            // if it's a long way from the building
+        cmpRallyPoint.SetDisplayed(true);
 
-            positions.push(pos);
-        }
     }
 
-    // Add rally point entity for each building
-    for each (var pos in positions)
-    {
-        var rallyPoint = Engine.AddLocalEntity("actor|props/special/common/waypoint_flag.xml");
-        var cmpPosition = Engine.QueryInterface(rallyPoint, IID_Position);
-        cmpPosition.JumpTo(pos.x, pos.z);
-        this.rallyPoints.push(rallyPoint);
-    }   
+    // Remember which entities have their rally points displayed so we can hide them again
+    this.entsRallyPointsDisplayed = cmd.entities;
+    
 };
 
 /**

deleted file binaries/data/mods/public/simulation/components/RallyPoint.js

@@ -1 @@
-function RallyPoint() {}
-
-RallyPoint.prototype.Schema =
-    "<a:component/><empty/>";
-
-RallyPoint.prototype.Init = function()
-{
-    this.pos = undefined;
-};
-
-RallyPoint.prototype.SetPosition = function(x, z)
-{
-    this.pos = {
-        "x": x,
-        "z": z
-    }
-};
-
-RallyPoint.prototype.Unset = function()
-{
-    this.pos = undefined;
-};
-
-RallyPoint.prototype.GetPosition = function()
-{
-    return this.pos;
-};
-
-Engine.RegisterComponentType(IID_RallyPoint, "RallyPoint", RallyPoint);

deleted file binaries/data/mods/public/simulation/components/interfaces/RallyPoint.js

@@ -1 @@
-Engine.RegisterInterface("RallyPoint");

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -229 +229 @@
         {
             var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
             if (cmpRallyPoint)
-                cmpRallyPoint.SetPosition(cmd.x, cmd.z);
+                cmpRallyPoint.SetPosition(cmd);
         }
         break;
 

new file inaries/data/mods/public/simulation/templates/special/rallypoint.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="special/actor">
+  <VisualActor>
+    <Actor>props/special/common/waypoint_flag.xml</Actor>
+  </VisualActor>
+  <Vision>
+    <AlwaysVisible>true</AlwaysVisible>
+  </Vision>
+</Entity>

binaries/data/mods/public/simulation/templates/template_structure.xml

@@ -53 +53 @@
     <DisableBlockPathfinding>false</DisableBlockPathfinding>
   </Obstruction>
   <OverlayRenderer/>
-  <RallyPoint/>
+  <RallyPoint>
+    <MarkerTemplate>special/rallypoint</MarkerTemplate>
+    <LineThickness>0.2</LineThickness>
+    <LineColour r="35" g="86" b="188"></LineColour>
+    <LineDashColour r="158" g="11" b="15"></LineDashColour>
+    <LineStartCap>square</LineStartCap>
+    <LineEndCap>round</LineEndCap>
+  </RallyPoint>
   <Sound>
     <SoundGroups>
       <select>interface/select/building/sel_universal.xml</select>

new file source/graphics/Overlay.cpp

@@ +1 @@
+/* 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
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "Overlay.h"
+
+bool SOverlayTexturedLine::StrToLineCap(const std::wstring& str, SOverlayTexturedLine::LineCap& out)
+{
+    if (str.compare(L"flat") == 0)
+    {
+        out = LINECAP_FLAT;
+        return true;
+    }
+    else if (str.compare(L"round") == 0)
+    {
+        out = LINECAP_ROUND;
+        return true;
+    }
+    else if (str.compare(L"sharp") == 0)
+    {
+        out = LINECAP_SHARP;
+        return true;
+    }
+    else if (str.compare(L"square") == 0)
+    {
+        out = LINECAP_SQUARE;
+        return true;
+    }
+    else
+        return false;
+}

source/graphics/Overlay.h

@@ -44 +44 @@
  */
 struct SOverlayTexturedLine
 {
-    SOverlayTexturedLine() : m_Terrain(NULL), m_Thickness(1.0f) { }
+
+    enum LineCap
+    {
+        LINECAP_FLAT, ///< no line ending; abrupt stop of the line (aka. butt ending)
+
+        /**
+         * Semi-circular line ending. The texture is mapped by curving the left vertical edge around the semi-circle's rim. That is,
+         * the center point has UV coordinates (0.5;0.5), and the rim vertices all have U coordinate 0 and a V coordinate that ranges
+         * from 0 to 1 as the rim is traversed.
+         */
+        LINECAP_ROUND,
+        LINECAP_SHARP, ///< sharp point ending
+        LINECAP_SQUARE, ///< square end that extends half the line width beyond the line end
+    };
+
+    SOverlayTexturedLine()
+        : m_Terrain(NULL), m_Thickness(1.0f), m_Closed(false), m_AlwaysVisible(false), m_StartCap(LINECAP_FLAT), m_EndCap(LINECAP_FLAT)
+    {}
 
     CTerrain* m_Terrain;
     CTexturePtr m_TextureBase;
     CTexturePtr m_TextureMask;
-    CColor m_Color;
-    std::vector<float> m_Coords; // (x, z) vertex coordinate pairs; y is computed automatically; shape is automatically closed
-    float m_Thickness; // world-space units
+    CColor m_Color; // color to apply to the line texture
+    std::vector<float> m_Coords; // (x, z) vertex coordinate pairs; y is computed automatically
+    float m_Thickness; // half-width of the line, in world-space units
+
+    bool m_Closed; // should this line be treated as a closed loop? (if set, the end cap settings are ignored)
+    bool m_AlwaysVisible; // should this line be rendered even under the SoD?
+    LineCap m_StartCap; // LineEndCap to be used at the start of the line
+    LineCap m_EndCap; // LineEndCap to be used at the end of the line
 
     shared_ptr<CRenderData> m_RenderData; // cached renderer data (shared_ptr so that copies/deletes are automatic)
+
+    /**
+     * Interprets @p str as a LineCap value, and writes the matching value to @p out, if any. Returns true if a value was written to @p out,
+     * false otherwise.
+     */
+    static bool StrToLineCap(const std::wstring& str, LineCap& out);
+
 };
 
 /**

source/gui/scripting/ScriptFunctions.cpp

@@ -34 +34 @@
 #include "ps/CConsole.h"
 #include "ps/Errors.h"
 #include "ps/Game.h"
+#include "ps/World.h"
 #include "ps/Hotkey.h"
 #include "ps/Overlay.h"
 #include "ps/ProfileViewer.h"
@@ -346 +347 @@
         g_Game->GetView()->CameraFollow(entityid, true);
 }
 
+void MoveCameraTarget2D(void* UNUSED(cbdata), entity_pos_t x, entity_pos_t z)
+{
+    // this must not fail
+    if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
+        return;
+
+    CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
+
+    CVector3D target;
+    target.X = x.ToFloat();
+    target.Z = z.ToFloat();
+    target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
+    g_Game->GetView()->MoveCameraTarget(target, true); // perform this in minimap mode since this is an "instant" camera movement similar to what you would get for clicking the minimap (also prevents height glitches)
+}
+
 entity_id_t GetFollowedEntity(void* UNUSED(cbdata))
 {
     if (g_Game && g_Game->GetView())
@@ -499 +515 @@
     scriptInterface.RegisterFunction<CScriptVal, &GetMapSettings>("GetMapSettings");
     scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollow>("CameraFollow");
     scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollowFPS>("CameraFollowFPS");
+    scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, &MoveCameraTarget2D>("CameraMoveTo"); // renamed slightly to better match the rest of the CameraXxx functions
     scriptInterface.RegisterFunction<entity_id_t, &GetFollowedEntity>("GetFollowedEntity");
     scriptInterface.RegisterFunction<bool, std::string, &HotkeyIsPressed_>("HotkeyIsPressed");
     scriptInterface.RegisterFunction<void, std::wstring, &DisplayErrorDialog>("DisplayErrorDialog");

source/maths/Vector2D.h

@@ -127 +127 @@
         return CVector2D(X / mag, Y / mag);
     }
 
+    /**
+     * Returns a version of this vector rotated by @p angle radians counterclockwise.
+     */
+    CVector2D Rotated(float angle)
+    {
+        float c = cos(angle);
+        float s = sin(angle);
+        return CVector2D(
+            c*X - s*Y,
+            s*X + c*Y
+        );
+    }
+
+    /**
+     * Rotates this vector by @p angle radians counterclockwise.
+     */
+    void Rotate(float angle)
+    {
+        float c = cos(angle);
+        float s = sin(angle);
+        float newX = c*X - s*Y;
+        float newY = s*X + c*Y;
+        X = newX;
+        Y = newY;
+    }
+
 public:
     float X, Y;
 };

source/renderer/OverlayRenderer.cpp

@@ -1 @@
-/* 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
@@ -19 +19 @@
 
 #include "OverlayRenderer.h"
 
+#include "maths/MathUtil.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/Overlay.h"
-#include "graphics/ShaderManager.h"
 #include "graphics/Terrain.h"
 #include "graphics/TextureManager.h"
 #include "lib/ogl.h"
+#include "maths/Vector2D.h"
 #include "ps/Game.h"
 #include "ps/Profile.h"
+#include "ps/CLogger.h"
 #include "renderer/Renderer.h"
 #include "renderer/VertexBuffer.h"
 #include "renderer/VertexBufferManager.h"
@@ -44 +46 @@
 {
 public:
     CTexturedLineRData(SOverlayTexturedLine* line) :
-        m_Line(line), m_VB(NULL), m_VBIndices(NULL)
+        m_Line(line),
+        m_VB(NULL),
+        m_VBIndices(NULL),
+        m_VBStartCap(NULL),
+        m_VBStartCapIndices(NULL),
+        m_VBEndCap(NULL),
+        m_VBEndCapIndices(NULL),
+        m_Raise(.2f)
     {
     }
 
@@ -54 +63 @@
             g_VBMan.Release(m_VB);
         if (m_VBIndices)
             g_VBMan.Release(m_VBIndices);
+        if (m_VBStartCap)
+            g_VBMan.Release(m_VBStartCap);
+        if (m_VBStartCapIndices)
+            g_VBMan.Release(m_VBStartCapIndices);
+        if (m_VBEndCap)
+            g_VBMan.Release(m_VBEndCap);
+        if (m_VBEndCapIndices)
+            g_VBMan.Release(m_VBEndCapIndices);
     }
 
     struct SVertex
     {
-        SVertex(CVector3D pos, short u, short v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
+        SVertex(CVector3D pos, float u, float v) : m_Position(pos) { m_UVs[0] = u; m_UVs[1] = v; }
         CVector3D m_Position;
-        GLshort m_UVs[2];
+        //GLshort m_UVs[2];
+        GLfloat m_UVs[2];
     };
-    cassert(sizeof(SVertex) == 16);
+    //cassert(sizeof(SVertex) == 16);
 
     void Update();
 
+    /**
+     * Creates a line cap of the specified type @p endCapType at the end of the segment going in direction @p normal, and write the vertices and indices
+     * to @p verticesOut and @p indicesOut, respectively. The drawing mode to use for the resulting vertices/indices array (quad strip,
+     * triangle strip, ...) is written to @p drawModeOut.
+     *
+     * @param corner1 One of the two butt-end corner points of the line to which the cap should be attached.
+     * @param corner2 One of the two butt-end corner points of the line to which the cap should be attached.
+     * @param normal Normal vector indicating the direction of the segment to which the cap should be attached.
+     * @param endCapType The type of end cap to produce.
+     * @param verticesOut Output vector of vertices to draw using @p drawModeOut. These will be entered into a vertex buffer and handed to the
+     *                    renderer along with the indices array.
+     * @param indicesOut Output vector of vertex indices to draw using @p drawModeOut. These will be entered into a vertex index buffer and
+     *                   handed to the rendered along with the vertex array.
+     * @param drawModeOut The rendering mode to be used by the renderer to draw the end cap, e.g. GL_QUAD_STRIP, GL_TRIANGLE_STRIP, etc.
+     */
+    void CreateLineCap(const CVector3D& corner1, const CVector3D& corner2, const CVector3D& normal, SOverlayTexturedLine::LineCap endCapType,
+                       std::vector<SVertex>& verticesOut, std::vector<u16>& indicesOut, GLenum& drawModeOut);
+
+    /// Small utility function; grabs the centroid of the positions of two vertices
+    inline CVector3D Centroid(const SVertex& v1, const SVertex& v2)
+    {
+        return (v1.m_Position + v2.m_Position) * 0.5;
+    }
+
     SOverlayTexturedLine* m_Line;
 
     CVertexBuffer::VBChunk* m_VB;
     CVertexBuffer::VBChunk* m_VBIndices;
+
+    // vertex buffers for custom line end caps (at both the start and end of the line)
+    CVertexBuffer::VBChunk* m_VBStartCap;
+    CVertexBuffer::VBChunk* m_VBStartCapIndices;
+    GLenum m_StartCapDrawMode; // quad strip, triangle fan, ...
+
+    CVertexBuffer::VBChunk* m_VBEndCap;
+    CVertexBuffer::VBChunk* m_VBEndCapIndices;
+    GLenum m_EndCapDrawMode;
+
+    float m_Raise; // small vertical offset of line from terrain to prevent visual glitches
+
 };
 
 OverlayRenderer::OverlayRenderer()
@@ -164 +218 @@
     glDisable(GL_BLEND);
 }
 
+void OverlayRenderer::RenderTexturedOverlayLines(const std::vector<size_t>& indices, CShaderProgramPtr shaderTexLine)
+{
+
+    //for (size_t i = 0; i < m->texlines.size(); ++i)
+    for (std::vector<size_t>::const_iterator idxIt = indices.begin(); idxIt != indices.end(); idxIt++)
+    {
+        SOverlayTexturedLine* line = m->texlines[(*idxIt)];
+        if (!line->m_RenderData)
+            continue;
+
+        shaderTexLine->BindTexture("baseTex", line->m_TextureBase->GetHandle());
+        shaderTexLine->BindTexture("maskTex", line->m_TextureMask->GetHandle());
+        shaderTexLine->Uniform("objectColor", line->m_Color);
+
+        CTexturedLineRData* rdata = static_cast<CTexturedLineRData*>(line->m_RenderData.get());
+
+        // -- render main line quad strip ----------------------
+
+        GLsizei stride = sizeof(CTexturedLineRData::SVertex);
+        CTexturedLineRData::SVertex* base = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VB->m_Owner->Bind());
+
+        glVertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
+        glTexCoordPointer(2, GL_FLOAT, stride, &base->m_UVs[0]);
+
+        u8* indexBase = rdata->m_VBIndices->m_Owner->Bind();
+        glDrawElements(GL_QUAD_STRIP, rdata->m_VBIndices->m_Count, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*rdata->m_VBIndices->m_Index);
+
+        g_Renderer.GetStats().m_OverlayTris += rdata->m_VBIndices->m_Count - 2;
+
+        // -- render end cap (if any) --------------------------
+
+        if (rdata->m_VBEndCap && rdata->m_VBEndCapIndices) // only draw end cap if we've created vertex/index buffers for it
+        {
+            CTexturedLineRData::SVertex* endCapBase = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VBEndCap->m_Owner->Bind());
+
+            glVertexPointer(3, GL_FLOAT, stride, &endCapBase->m_Position[0]);
+            glTexCoordPointer(2, GL_FLOAT, stride, &endCapBase->m_UVs[0]);
+
+            u8* endCapIndexBase = rdata->m_VBEndCapIndices->m_Owner->Bind();
+            glDrawElements(rdata->m_EndCapDrawMode, rdata->m_VBEndCapIndices->m_Count, GL_UNSIGNED_SHORT, endCapIndexBase + sizeof(u16)*rdata->m_VBEndCapIndices->m_Index);
+
+            g_Renderer.GetStats().m_OverlayTris += rdata->m_VBEndCapIndices->m_Count - 2; // valid for both quad strip and triangle strip
+
+        }
+
+        // -- render start cap (if any) ------------------------
+
+        if (rdata->m_VBStartCap && rdata->m_VBStartCapIndices) // only draw start cap if we've created vertex/index buffers for it
+        {
+            CTexturedLineRData::SVertex* startCapBase = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VBStartCap->m_Owner->Bind());
+
+            glVertexPointer(3, GL_FLOAT, stride, &startCapBase->m_Position[0]);
+            glTexCoordPointer(2, GL_FLOAT, stride, &startCapBase->m_UVs[0]);
+
+            u8* startCapIndexBase = rdata->m_VBStartCapIndices->m_Owner->Bind();
+            glDrawElements(rdata->m_StartCapDrawMode, rdata->m_VBStartCapIndices->m_Count, GL_UNSIGNED_SHORT, startCapIndexBase + sizeof(u16)*rdata->m_VBStartCapIndices->m_Index);
+
+            g_Renderer.GetStats().m_OverlayTris += rdata->m_VBStartCapIndices->m_Count - 2; // valid for both quad strip and triangle strip
+        }
+
+    }
+
+}
+
 void OverlayRenderer::RenderOverlaysAfterWater()
 {
     PROFILE("render overlays (after water)");
@@ -182 +300 @@
         glEnableClientState(GL_VERTEX_ARRAY);
         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
-        CShaderManager& shaderManager = g_Renderer.GetShaderManager();
-        CShaderProgramPtr shaderTexLine(shaderManager.LoadProgram("overlayline", std::map<CStr, CStr>()));
+        CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
 
-        shaderTexLine->Bind();
+        std::map<CStr, CStr> defAlwaysVisible;
+        defAlwaysVisible.insert(std::make_pair(CStr("IGNORE_LOS"), CStr("1")));
 
-        CLOSTexture& los = g_Renderer.GetScene().GetLOSTexture();
-        shaderTexLine->BindTexture("losTex", los.GetTexture());
-        shaderTexLine->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+        CShaderManager& shaderManager = g_Renderer.GetShaderManager();
+        CShaderProgramPtr shaderTexLineNormal(shaderManager.LoadProgram("overlayline", std::map<CStr, CStr>()));
+        CShaderProgramPtr shaderTexLineAlwaysVisible(shaderManager.LoadProgram("overlayline", defAlwaysVisible));
 
-        for (size_t i = 0; i < m->texlines.size(); ++i)
+        // ----------------------------------------------------------------------------------------
+        // group the overlay lines by whether they need to be always visible
+        std::vector<size_t> alwaysVisibleTexLineIndices;
+        std::vector<size_t> normalTexLineIndices;
+
+        for (size_t i = 0; i < m->texlines.size(); i++)
         {
-            SOverlayTexturedLine* line = m->texlines[i];
-            if (!line->m_RenderData)
-                continue;
+            if (m->texlines[i]->m_AlwaysVisible)
+            {
+                alwaysVisibleTexLineIndices.push_back(i);
+            }
+            else
+            {
+                normalTexLineIndices.push_back(i);
+            }
+        }
 
-            shaderTexLine->BindTexture("baseTex", line->m_TextureBase->GetHandle());
-            shaderTexLine->BindTexture("maskTex", line->m_TextureMask->GetHandle());
-            shaderTexLine->Uniform("objectColor", line->m_Color);
+        // render go go
 
-            CTexturedLineRData* rdata = static_cast<CTexturedLineRData*>(line->m_RenderData.get());
+        shaderTexLineNormal->Bind();
+        shaderTexLineNormal->BindTexture("losTex", los.GetTexture());
+        shaderTexLineNormal->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
 
-            GLsizei stride = sizeof(CTexturedLineRData::SVertex);
-            CTexturedLineRData::SVertex* base = reinterpret_cast<CTexturedLineRData::SVertex*>(rdata->m_VB->m_Owner->Bind());
+        RenderTexturedOverlayLines(normalTexLineIndices, shaderTexLineNormal);
 
-            glVertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
-            glTexCoordPointer(2, GL_SHORT, stride, &base->m_UVs[0]);
+        shaderTexLineNormal->Unbind();
 
-            u8* indexBase = rdata->m_VBIndices->m_Owner->Bind();
-            glDrawElements(GL_QUAD_STRIP, rdata->m_VBIndices->m_Count, GL_UNSIGNED_SHORT, indexBase + sizeof(u16)*rdata->m_VBIndices->m_Index);
+        // ----------------------------------------------------------------------------------------
 
-            g_Renderer.GetStats().m_OverlayTris += rdata->m_VBIndices->m_Count - 2;
-        }
+        shaderTexLineAlwaysVisible->Bind();
+        // TODO: losTex and losTransform are unused in the always visible shader, but I'm not sure if it's worthwhile messing 
+        // with it just to remove these calls
+        shaderTexLineAlwaysVisible->BindTexture("losTex", los.GetTexture());
+        shaderTexLineAlwaysVisible->Uniform("losTransform", los.GetTextureMatrix()[0], los.GetTextureMatrix()[12], 0.f, 0.f);
+
+        RenderTexturedOverlayLines(alwaysVisibleTexLineIndices, shaderTexLineAlwaysVisible);
+
+        shaderTexLineAlwaysVisible->Unbind();
 
-        shaderTexLine->Unbind();
+        // ----------------------------------------------------------------------------------------
 
         // TODO: the shader should probably be responsible for unbinding its textures
         g_Renderer.BindTexture(1, 0);
@@ -289 +422 @@
         m_VBIndices = NULL;
     }
 
+    if (m_VBStartCap)
+    {
+        g_VBMan.Release(m_VBStartCap);
+        m_VBStartCap = NULL;
+    }
+
+    if (m_VBStartCapIndices)
+    {
+        g_VBMan.Release(m_VBStartCapIndices);
+        m_VBStartCapIndices = NULL;
+    }
+
+    if (m_VBEndCap)
+    {
+        g_VBMan.Release(m_VBEndCap);
+        m_VBEndCap = NULL;
+    }
+
+    if (m_VBEndCapIndices)
+    {
+        g_VBMan.Release(m_VBEndCapIndices);
+        m_VBEndCapIndices = NULL;
+    }
+
     CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
 
     std::vector<SVertex> vertices;
     std::vector<u16> indices;
 
-    short v = 0;
+    float v = 0.f;
 
-    size_t n = m_Line->m_Coords.size() / 2;
-    ENSURE(n >= 1);
+    size_t n = m_Line->m_Coords.size() / 2; // number of line points
+    bool closed = m_Line->m_Closed;
 
-    CTerrain* terrain = m_Line->m_Terrain;
+    if (closed)
+        ENSURE(n >= 1); // granted, it's kind of hard to draw a closed loop through 1 point, but this is the minimum to avoid errors
+    else
+        ENSURE(n >= 2);
 
-    // TODO: this assumes paths are closed loops; probably should extend this to
-    // handle non-closed paths too
+    CTerrain* terrain = m_Line->m_Terrain;
 
     // In each iteration, p1 is the position of vertex i, p0 is i-1, p2 is i+1.
     // To avoid slightly expensive terrain computations we cycle these around and
     // recompute p2 at the end of each iteration.
-    CVector3D p0 = CVector3D(m_Line->m_Coords[(n-1)*2], 0, m_Line->m_Coords[(n-1)*2+1]);
-    CVector3D p1 = CVector3D(m_Line->m_Coords[0], 0, m_Line->m_Coords[1]);
-    CVector3D p2 = CVector3D(m_Line->m_Coords[(1 % n)*2], 0, m_Line->m_Coords[(1 % n)*2+1]);
+
+    CVector3D p0;
+    CVector3D p1(m_Line->m_Coords[0], 0, m_Line->m_Coords[1]);
+    CVector3D p2(m_Line->m_Coords[(1 % n)*2], 0, m_Line->m_Coords[(1 % n)*2+1]);
+
+    if (closed)
+        // grab the ending point so as to close the loop
+        p0 = CVector3D(m_Line->m_Coords[(n-1)*2], 0, m_Line->m_Coords[(n-1)*2+1]);
+    else
+        // we don't want to loop around and use the direction towards the other end of the line, so create an artificial p0 that 
+        // extends the p2 -> p1 direction, and use that point instead
+        p0 = p1 + (p1 - p2);
+
     bool p1floating = false;
     bool p2floating = false;
 
@@ -341 +510 @@
     {
         // For vertex i, compute bisector of lines (i-1)..(i) and (i)..(i+1)
         // perpendicular to terrain normal
+        // Push vertices in GL_QUAD_STRIP order
 
         // Normal is vertical if on water, else computed from terrain
         CVector3D norm;
@@ -356 +526 @@
         if (fabs(l) > 0.000001f) // avoid unlikely divide-by-zero
             b *= m_Line->m_Thickness / l;
 
-        // Raise off the terrain a little bit
-        const float raised = 0.2f;
-
-        vertices.push_back(SVertex(p1 + b + norm*raised, 0, v));
+        vertices.push_back(SVertex(p1 + b + norm*m_Raise, 0.f, v));
         indices.push_back(vertices.size() - 1);
 
-        vertices.push_back(SVertex(p1 - b + norm*raised, 1, v));
+        vertices.push_back(SVertex(p1 - b + norm*m_Raise, 1.f, v));
         indices.push_back(vertices.size() - 1);
 
         // Alternate V coordinate for debugging
@@ -372 +539 @@
         p0 = p1;
         p1 = p2;
         p1floating = p2floating;
+
+        // if in closed mode, wrap around the coordinate array for p2 -- otherwise, extend linearly
+        if (!closed && i == n-2)
+            // next iteration is the last point of the line, so create an artificial p2 that extends the p0 -> p1 direction
+            p2 = p1 + (p1 - p0);
+        else
         p2 = CVector3D(m_Line->m_Coords[((i+2) % n)*2], 0, m_Line->m_Coords[((i+2) % n)*2+1]);
+
         p2.Y = terrain->GetExactGroundLevel(p2.X, p2.Z);
         if (p2.Y < w)
         {
@@ -383 +557 @@
             p2floating = false;
     }
 
+    
+    if (closed)
+    {
     // Close the path
     indices.push_back(0);
     indices.push_back(1);
+    }
 
     m_VB = g_VBMan.Allocate(sizeof(SVertex), vertices.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
     m_VB->m_Owner->UpdateChunkVertices(m_VB, &vertices[0]);
@@ -396 +574 @@
 
     m_VBIndices = g_VBMan.Allocate(sizeof(u16), indices.size(), GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
     m_VBIndices->m_Owner->UpdateChunkVertices(m_VBIndices, &indices[0]);
+
+    if (!closed)
+    {
+        // -------------------------------------------------------------------
+        // create start cap
+
+        std::vector<u16> startCapIndices;
+        std::vector<SVertex> startCapVertices;
+
+        CreateLineCap(
+            vertices[1].m_Position, // the order of these vertices is actually important here, swapping them produces caps at the wrong side
+            vertices[0].m_Position,
+            (Centroid(vertices[1], vertices[0]) - Centroid(vertices[3], vertices[2])).Normalized(),
+            m_Line->m_StartCap,
+            startCapVertices,
+            startCapIndices,
+            m_StartCapDrawMode
+        );
+
+        if (!startCapVertices.empty() && !startCapIndices.empty())
+        {
+            m_VBStartCap = g_VBMan.Allocate(sizeof(SVertex), startCapVertices.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+            m_VBStartCap->m_Owner->UpdateChunkVertices(m_VBStartCap, &startCapVertices[0]);
+
+            // Update the indices to include the base offset of the vertex data
+            for (size_t k = 0; k < startCapVertices.size(); ++k)
+                startCapIndices[k] += m_VBStartCap->m_Index;
+
+            m_VBStartCapIndices = g_VBMan.Allocate(sizeof(u16), startCapIndices.size(), GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
+            m_VBStartCapIndices->m_Owner->UpdateChunkVertices(m_VBStartCapIndices, &startCapIndices[0]);
+
+        }
+
+        // -------------------------------------------------------------------
+        // create end cap
+
+        std::vector<u16> endcapIndices;
+        std::vector<SVertex> endcapVertices;
+
+        CreateLineCap(
+            vertices[2*n-2].m_Position, // second-to-last line vertex
+            vertices[2*n-1].m_Position, // last line vertex
+            (Centroid(vertices[2*n-2], vertices[2*n-1]) - Centroid(vertices[2*n-4], vertices[2*n-3])).Normalized(),
+            m_Line->m_EndCap,
+            endcapVertices,
+            endcapIndices,
+            m_EndCapDrawMode
+        );
+
+        if (!endcapVertices.empty() && !endcapIndices.empty())
+        {
+            m_VBEndCap = g_VBMan.Allocate(sizeof(SVertex), endcapVertices.size(), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
+            m_VBEndCap->m_Owner->UpdateChunkVertices(m_VBEndCap, &endcapVertices[0]);
+
+            // Update the indices to include the base offset of the vertex data
+            for (size_t k = 0; k < endcapVertices.size(); ++k)
+                endcapIndices[k] += m_VBEndCap->m_Index;
+
+            m_VBEndCapIndices = g_VBMan.Allocate(sizeof(u16), endcapIndices.size(), GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
+            m_VBEndCapIndices->m_Owner->UpdateChunkVertices(m_VBEndCapIndices, &endcapIndices[0]);
+
+        }
+
+    }
+}
+
+void CTexturedLineRData::CreateLineCap(const CVector3D& corner1, const CVector3D& corner2, const CVector3D& normal, SOverlayTexturedLine::LineCap endCapType,
+                                       std::vector<SVertex>& verticesOut, std::vector<u16>& indicesOut, GLenum& drawModeOut)
+{
+
+    if (endCapType == SOverlayTexturedLine::LINECAP_FLAT)
+        return; // no action needed, this is the default
+
+    CTerrain* terrain = m_Line->m_Terrain;
+    CmpPtr<ICmpWaterManager> cmpWaterManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+
+    // when not in closed mode, we've created artificial points for the start- and endpoints that extend the line in the
+    // direction of the first and the last segment, respectively. Thus, we know both the start and endpoints have perpendicular
+    // butt endings, i.e. the end corner vertices on either side of the line extend perpendicularly from the segment direction.
+    // That is to say, we will have something like
+    //                                                 .
+    //  this:                     and not like this:  /|
+    //         ____.                                 / |
+    //             |                                /  .
+    //             |                                  /
+    //         ____.                                 /
+    //
+
+    int roundCapPoints = 8; // = how many points to sample along the semicircle for rounded caps (including corner points)
+    float radius = m_Line->m_Thickness;
+    float texCenterU = 0.5f; // U coordinate of butt end centroid
+    float texCenterV = 0.5f; // V coordinate of butt end centroid
+
+    CVector3D centerPoint = (corner1 + corner2) * 0.5f; // middle between last two vertices (i.e. "butt" corner points)
+    /*centerPoint.X = (corner1.X + corner2.X)/2.f;
+    centerPoint.Y = (corner1.Y + corner2.Y)/2.f;
+    centerPoint.Z = (corner1.Z + corner2.Z)/2.f;*/
+
+    switch (endCapType)
+    {
+
+    case SOverlayTexturedLine::LINECAP_SHARP:
+        {
+            roundCapPoints = 3; // creates only one point directly ahead
+            radius *= 1.2f; // make it a bit sharper (note that we don't use this for the butt corner points so it should be ok)
+            texCenterU = 0.485f; // slight visual correction to make the texture edges match up better (they're slightly too thin with only 3 points and a U coord of 0.5f)
+        }
+    case SOverlayTexturedLine::LINECAP_ROUND:
+        {
+            
+            // TODO: this currently uses a complicated method where it grabs the points across the arc of the rounded cap, and then
+            // fetches the height of the map at that point. The idea was to make it "stick" to the terrain better, but it turns out
+            // to look bad on funky terrain. It'd probably be better to adopt the same method the square line caps use, and just
+            // extend the line plane. However, that requires rotating the (centerPoint -> cornerPoint) vector along an arbitrary 3D axis,
+            // and I'm not sure how to do that yet. (--vts)
+
+            drawModeOut = GL_TRIANGLE_FAN;
+
+            // depending on whether we start rotating from the (center -> corner1) or (center -> corner2) vector,
+            // this angle needs to be inverted. For the (center -> corner1) vector, apparently we need to use the positive angle;
+            // there's probably some reason for why that one is the positive one and not vice-versa, but I don't want to be bothered
+            // to find out why as it probably has to do with right-hand-rules and whatnot.
+            float stepAngle = (float)(M_PI/(roundCapPoints-1));
+
+            // add center point vertex
+            CVector2D centerPoint2D(centerPoint.X, centerPoint.Z);
+
+            verticesOut.push_back(SVertex(centerPoint, texCenterU, texCenterV));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+            // rotate a 2D unit vector from center to one of the butt corner points stepwise 180 degrees to sample semicircular points, then
+            // multiply by the radius. For each resulting point, grab the actual terrain height. To prevent visual glitches, we reuse the two
+            // butt corner vertices directly instead of recomputing them as part of the semicircle.
+            CVector2D baseVector((corner2 - centerPoint).X, (corner2 - centerPoint).Z);
+            baseVector.Normalize();
+
+            // connect to first butt corner point
+            verticesOut.push_back(SVertex(corner2, 0.f, 0.f));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+            //for (int i=0; i<roundCapPoints; i++)
+            for (int i=1; i<roundCapPoints-1; i++) // note: excludes the first and last iteration, since we're adding those points manually
+            {
+                CVector2D currentVector = baseVector.Rotated(i * stepAngle);
+
+                // 2D sample point location in absolute world space
+                CVector2D worldPos2D = centerPoint2D + (currentVector * radius);
+
+                // now grab the 3D location
+                CVector3D norm;
+                float groundLevel = terrain->GetExactGroundLevel(worldPos2D.X, worldPos2D.Y);
+                float w = cmpWaterManager->GetExactWaterLevel(worldPos2D.X, worldPos2D.Y);
+
+                // we want this to float on water, so if the actual terrain ground level is under water, then we artificially raise it
+                // to the water level
+                if (groundLevel < w)
+                {
+                    norm = CVector3D(0, 1, 0);
+                    groundLevel = w;
+                }
+                else
+                    norm = m_Line->m_Terrain->CalcExactNormal(worldPos2D.X, worldPos2D.Y);
+
+                CVector3D worldPos3D(worldPos2D.X, groundLevel, worldPos2D.Y);
+                worldPos3D += norm * m_Raise;
+
+                // let v range from 0 to 1 as we move along the semi-circle, keep u fixed at 0 (i.e. curve the left vertical edge of the texture
+                // around the edge of the semicircle)
+                float u = 0.f;
+                float v = clamp((i/(float)(roundCapPoints-1)), 0.f, 1.f);
+                verticesOut.push_back(SVertex(worldPos3D, u, v)); // pos, u, v
+                indicesOut.push_back(verticesOut.size() - 1);
+            }
+
+            // connect back to the other butt corner point to complete the semicircle
+            verticesOut.push_back(SVertex(corner1, 0.f, 1.f));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+        }
+        break;
+
+    case SOverlayTexturedLine::LINECAP_SQUARE:
+        {
+            // extend the (corner1 -> corner2) vector along the direction normal and draw a triangle fan with 3 triangles
+            // NOTE: the order in which the vertices are pushed out determines the visibility of the rendered fan, as they
+            // are rendered only one-sided; the wrong order of vertices will only make the fan visible from the bottom.
+
+            drawModeOut = GL_TRIANGLE_FAN;
+
+            // push center point
+            verticesOut.push_back(SVertex(centerPoint, texCenterU, texCenterV));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+            // push butt corner point 2
+            verticesOut.push_back(SVertex(corner2, 0.f, 0.f));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+            // extend butt corner point 2 along the normal vector
+            verticesOut.push_back(SVertex(corner2 + (normal * (m_Line->m_Thickness)), 0.f, 0.333f));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+            // extend butt corner point 1 along the normal vector
+            verticesOut.push_back(SVertex(corner1 + (normal * (m_Line->m_Thickness)), 0.f, 0.666f));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+            // push butt corner point 1
+            verticesOut.push_back(SVertex(corner1, 0.f, 1.0f));
+            indicesOut.push_back(verticesOut.size() - 1);
+
+        }
+        break;
+
+    default:
+        break;
+
+    }
+
 }

source/renderer/OverlayRenderer.h

@@ -1 @@
-/* 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
@@ -18 +18 @@
 #ifndef INCLUDED_OVERLAYRENDERER
 #define INCLUDED_OVERLAYRENDERER
 
+#include "graphics/ShaderManager.h"
+
 struct SOverlayLine;
 struct SOverlayTexturedLine;
 struct SOverlaySprite;
@@ -84 +86 @@
     void RenderForegroundOverlays(const CCamera& viewCamera);
 
 private:
+    
+    /**
+     * Helper method; renders the overlay lines currently registered in the internals (i.e. in m->texlines) in the order 
+     * specified by @p indices. Used for splitting the textured overlay lines by their visibility status, and then batch
+     * rendering them with the right shader by passing the correct indices to this method.
+     */
+    void RenderTexturedOverlayLines(const std::vector<size_t>& indices, CShaderProgramPtr shader);
+
+private:
     OverlayRendererInternals* m;
 };
 

source/renderer/RenderModifiers.h

@@ -1 @@
-/* Copyright (C) 2009 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
@@ -137 +137 @@
 /**
  * Class RenderModifierRenderer: Interface to a model renderer that can render
  * its models via a RenderModifier that sets up fragment stages.
+ * TODO: this appears to be currently unused, should be considered for deletion
  */
 class RenderModifierRenderer : public ModelRenderer
 {

source/scriptinterface/ScriptInterface.cpp

@@ -326 +326 @@
     return JS_TRUE;
 }
 
+JSBool logmsgrender(JSContext* cx, uintN argc, jsval* vp)
+{
+    if (argc < 1)
+    {
+        JS_SET_RVAL(cx, vp, JSVAL_VOID);
+        return JS_TRUE;
+    }
+
+    std::wstring str;
+    if (!ScriptInterface::FromJSVal(cx, JS_ARGV(cx, vp)[0], str))
+        return JS_FALSE;
+    LOGMESSAGERENDER(L"%ls", str.c_str());
+    JS_SET_RVAL(cx, vp, JSVAL_VOID);
+    return JS_TRUE;
+}
+
 JSBool warn(JSContext* cx, uintN argc, jsval* vp)
 {
     if (argc < 1)
@@ -505 +521 @@
 
     JS_DefineFunction(m_cx, m_glob, "print", ::print,  0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
     JS_DefineFunction(m_cx, m_glob, "log",   ::logmsg, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
+    JS_DefineFunction(m_cx, m_glob, "logr",  ::logmsgrender, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
     JS_DefineFunction(m_cx, m_glob, "warn",  ::warn,   1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
     JS_DefineFunction(m_cx, m_glob, "error", ::error,  1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
     JS_DefineFunction(m_cx, m_glob, "deepcopy", ::deepcopy, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);

source/simulation2/TypeList.h

@@ -114 +114 @@
 INTERFACE(ProjectileManager)
 COMPONENT(ProjectileManager)
 
+INTERFACE(RallyPoint)
+COMPONENT(RallyPoint)
+
 INTERFACE(RangeManager)
 COMPONENT(RangeManager)
 

new file source/simulation2/components/CCmpRallyPoint.cpp

@@ +1 @@
+/* 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
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "simulation2/system/Component.h"
+#include "ICmpRallyPoint.h"
+
+#include "simulation2/MessageTypes.h"
+#include "simulation2/helpers/Render.h"
+#include "simulation2/helpers/Geometry.h"
+
+#include "simulation2/components/ICmpPosition.h"
+#include "simulation2/components/ICmpPathFinder.h"
+#include "simulation2/components/ICmpFootprint.h"
+#include "simulation2/components/ICmpRangeManager.h"
+#include "simulation2/components/ICmpPlayer.h"
+#include "simulation2/components/ICmpOwnership.h"
+#include "simulation2/components/ICmpTerrain.h"
+#include "simulation2/components/ICmpPlayerManager.h"
+#include "simulation2/components/ICmpPlayer.h"
+#include "simulation2/components/ICmpObstructionManager.h"
+
+#include "ps/CLogger.h"
+#include "graphics/Overlay.h"
+#include "graphics/Terrain.h"
+#include "graphics/TextureManager.h"
+#include "maths/Fixed.h"
+#include "maths/MathUtil.h"
+#include "maths/Matrix3D.h"
+#include "maths/Vector2D.h"
+#include "maths/Vector3D.h"
+#include "renderer/Scene.h"
+#include "renderer/Renderer.h"
+#include "renderer/TerrainOverlay.h"
+
+struct SVisibilitySegment
+{
+    bool m_Visible;
+    size_t m_StartIndex;
+    size_t m_EndIndex; // inclusive
+
+    SVisibilitySegment(bool visible, size_t startIndex, size_t endIndex) 
+        : m_Visible(visible), m_StartIndex(startIndex), m_EndIndex(endIndex)
+    {}
+
+    bool operator==(const SVisibilitySegment& other) const
+    {
+        return (m_Visible == other.m_Visible && m_StartIndex == other.m_StartIndex && m_EndIndex == other.m_EndIndex);
+    }
+
+    bool operator!=(const SVisibilitySegment& other) const
+    {
+        return !(*this == other);
+    }
+
+    bool IsSinglePoint()
+    {
+        return (m_StartIndex == m_EndIndex);
+    }
+};
+
+class CCmpRallyPoint : public ICmpRallyPoint
+{
+    // import some types for less verbosity
+    typedef ICmpPathfinder::Waypoint Waypoint;
+    typedef ICmpPathfinder::Path Path;
+    typedef ICmpPathfinder::Goal Goal;
+    typedef ICmpRangeManager::CLosQuerier CLosQuerier;
+    typedef SOverlayTexturedLine::LineCap LineCap;
+
+public:
+    static void ClassInit(CComponentManager& componentManager)
+    {
+        componentManager.SubscribeToMessageType(MT_RenderSubmit);
+        componentManager.SubscribeToMessageType(MT_OwnershipChanged);
+        componentManager.SubscribeToMessageType(MT_TurnStart);
+        // TODO: should probably also listen to movement messages
+    }
+
+    DEFAULT_COMPONENT_ALLOCATOR(RallyPoint)
+
+protected:
+
+    /// Actual position of the rally point (in fixed-point world coordinates for stability)
+    RallyPointPosition m_RallyPoint;
+    /// Full path to the rally point as returned by the pathfinder, with some post-processing applied to reduce zig/zagging.
+    //Path m_FullPath;
+    std::vector<CVector2D> m_FullPath;
+    std::deque<SVisibilitySegment> m_VisibilitySegments;
+
+    bool m_Displayed; ///< Should we render the rally point and its path line? (set from JS when e.g. the unit is selected/deselected)
+    bool m_SmoothPath; ///< Smooth the path before rendering?
+
+    entity_id_t m_MarkerEntity; ///< Entity ID of the rally point marker. Allocated when first displayed.
+    std::wstring m_MarkerTemplate;  ///< Template name of the rally point marker.
+
+    /// Marker connector line settings (loaded from XML)
+    float m_LineThickness;
+    CColor m_LineColor;
+    CColor m_LineDashColor;
+    LineCap m_LineStartCap;
+    LineCap m_LineEndCap;
+    std::wstring m_LineTexturePath;
+    std::wstring m_LineTextureMaskPath;
+
+    CTexturePtr m_Texture;
+    CTexturePtr m_TextureMask;
+
+    //SOverlayTexturedLine* m_TexturedOverlayLine;
+    ///< Textured overlay lines for the marker line. There can be multiple because we need to do dashes inside the SoD.
+    std::vector<SOverlayTexturedLine> m_TexturedOverlayLines;
+
+    /// Draw little overlay circles to indicate where the exact path points are?
+    bool m_EnableDebugNodeOverlay;
+    std::vector<SOverlayLine> m_DebugNodeOverlays;
+
+public:
+
+    CCmpRallyPoint()
+    {
+        m_Displayed = false;
+        m_SmoothPath = true;
+        m_MarkerEntity = INVALID_ENTITY;
+        m_EnableDebugNodeOverlay = false;
+    }
+
+    ~CCmpRallyPoint()
+    {
+        //if(m_TexturedOverlayLine) delete m_TexturedOverlayLine;
+    }
+
+    static std::string GetSchema()
+    {
+        return
+            "<a:component />"
+            "<a:help>Displays a rally point where created units will gather when spawned.</a:help>"
+            "<a:example>"
+                "<MarkerTemplate>special/rallypoint</MarkerTemplate>"
+                "<LineThickness>0.75</LineThickness>"
+                "<LineStartCap>round</LineStartCap>"
+                "<LineEndCap>square</LineEndCap>"
+                "<LineColour r='20' g='128' b='240'></LineColour>"
+            "</a:example>"
+            "<element name='MarkerTemplate' a:help='Template name for the rally point marker entity (typically a waypoint flag actor).'>"
+                "<text/>"
+            "</element>"
+            "<optional>"
+                "<element name='LineColour'>"
+                    "<attribute name='r'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='g'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='b'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineStartCap'>"
+                    "<choice>"
+                        "<value a:help='Abrupt line ending; line endings are not closed.'>none</value>"
+                        "<value a:help='Semi-circular line end cap. The texture&quot;s left vertical edge is curved around the rim of the semicircle.'>round</value>"
+                        "<value a:help='Sharp, pointy line end. The texture&quot;s left vertical edge is mapped along the outline.'>sharp</value>"
+                        "<value a:help='Square line end cap. The texture&quot;s left vertical edge is mapped along the outline.'>square</value>"
+                    "</choice>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineEndCap'>"
+                    "<choice>"
+                        "<value a:help='Abrupt line ending; line endings are not closed.'>none</value>"
+                        "<value a:help='Semi-circular line end cap. The texture&quot;s left vertical edge is curved around the rim of the semicircle.'>round</value>"
+                        "<value a:help='Sharp, pointy line end. The texture&quot;s left vertical edge is mapped along the outline.'>sharp</value>"
+                        "<value a:help='Square line end cap. The texture&quot;s left vertical edge is mapped along the outline.'>square</value>"
+                    "</choice>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineThickness' a:help='Thickness of the marker line connecting the entity to the rally point marker.'>"
+                    "<data type='decimal'/>"
+                "</element>"
+            "</optional>"
+            "<optional>"
+                "<element name='LineDashColour'>"
+                    "<attribute name='r'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='g'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                    "<attribute name='b'>"
+                        "<data type='integer'><param name='minInclusive'>0</param><param name='maxInclusive'>255</param></data>"
+                    "</attribute>"
+                "</element>"
+            "</optional>";
+    }
+
+    virtual void Init(const CParamNode& paramNode);
+
+    virtual void Deinit()
+    {
+    }
+
+    virtual void Serialize(ISerializer& UNUSED(serialize))
+    {
+        // TODO should probably serialize the rally point location here
+    }
+
+    virtual void Deserialize(const CParamNode& paramNode, IDeserializer& UNUSED(deserialize))
+    {
+        Init(paramNode);
+    }
+
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    {
+        switch (msg.GetType())
+        {
+        case MT_RenderSubmit:
+        {
+            if(m_Displayed && IsSet())
+            {
+                const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
+                RenderSubmit(msgData.collector);
+            }
+            break;
+        }
+        case MT_OwnershipChanged:
+        {
+            CreateMarker();
+            RepositionMarker(); // the new marker doesn't have a position yet, so let's make sure to update it
+        }
+        case MT_TurnStart:
+        {
+            UpdateOverlayLines(); // check for changes to the SoD and update the overlay lines accordingly
+        }
+        }
+    }
+
+    virtual RallyPointPosition GetPosition()
+    {
+        return m_RallyPoint;
+    }
+
+    virtual void SetPosition(RallyPointPosition pos)
+    {
+        bool posChanged = (pos.X != m_RallyPoint.X || pos.Y != m_RallyPoint.Y);
+        m_RallyPoint = pos;
+
+        //LOGMESSAGERENDER(L"[entity %d] CCmpRallyPoint::SetPosition()", GetEntityId());
+        if(posChanged)
+        {
+            RecomputeRallyPointPath();
+            RepositionMarker();
+        }
+    }
+
+    virtual void Unset()
+    {
+        SetPosition(RallyPointPosition()); // reset to zero
+    }
+
+    bool IsSet()
+    {
+        return !m_RallyPoint.IsZero();
+    }
+
+    virtual void SetDisplayed(bool displayed)
+    {
+        //LOGMESSAGERENDER(L"[entity %d] CCmpRallyPoint::SetDisplayed(%s)", GetEntityId(), displayed ? L"true" : L"false");
+        bool displayChanged = (m_Displayed != displayed);
+        m_Displayed = displayed;
+
+        if(displayChanged)
+        {
+            RepositionMarker(); // move the marker out of oblivion and back into the real world, or vice-versa
+            UpdateOverlayLines(); // check for changes to the SoD and update the overlay lines accordingly
+        }
+    }
+
+private:
+
+    /**
+     * (Re)creates the rally point marker entity. Called upon initialization and whenever the ownership of this entity changes, as the marker
+     * depends on the owner's civilization. If a marker entity already exists, it will be destroyed first.
+     */
+    void CreateMarker();
+
+    /**
+     * Repositions the rally point marker; moves it outside of the world (ie. hides it), or positions it at the rally point. Executed
+     * whenever either the position of the rally point changes (including whether it is set or not), or the display flag changes.
+     *
+     * TODO: this is executed from JS-executed methods, which must not fail under any circumstances. We'd probably have to change this to
+     * detect the changes in the rendering code rather than execute them directly here.
+     **/
+    void RepositionMarker();
+
+    /**
+     * Recomputes the full path from this entity to the rally point, and does all the necessary post-processing to make it prettier.
+     * Called whenever the rally point position changes.
+     */
+    void RecomputeRallyPointPath();
+
+    /**
+     * Sets up the overlay lines for rendering according to the current full path and visibility segments. Does all the necessary splitting 
+     * of the line into solid and dashed pieces (for the SoD). Should be called whenever the SoD has changed. If no full path is currently 
+     * set, this method does nothing.
+     */
+    void ConstructOverlayLines();
+
+    /**
+     * Checks for changes to the SoD to the previously saved state, and reconstructs the overlay lines to match if necessary. Does nothing
+     * if the rally point line is not currently set to be displayed, so that we don't waste compute cycles trying to update rally point
+     * overlays for every building all the time if they're not even gonna be visible anyway.
+     */
+    void UpdateOverlayLines();
+
+    /**
+     * Removes waypoints from m_rallyPointPath that are obstructed by the originating building's footprint, and links up the rally point path
+     * nicely to the edge of the building's footprint. Only needed if the pathfinder can possibly return obstructed tile waypoints, i.e. when
+     * pathfinding is started from an obstructed tile.
+     */
+    void FixFootprintWaypoints(std::vector<CVector2D>& coords, CmpPtr<ICmpPosition> cmpPosition, CmpPtr<ICmpFootprint> cmpFootprint);
+
+    /**
+     * Removes waypoints that are inside the shroud of darkness, i.e. where the player shouldn't be able to get any information about the
+     * positions of various buildings and whatnot from the rally point path.
+     */
+    void FixInvisibleWaypoints(std::vector<CVector2D>& coords);
+
+    /**
+     * Simplifies the path by removing waypoints that lie between two points that are visible from one another. This is primarily intended to
+     * reduce some unnecessary curviness of the path; the pathfinder returns a mathematically (near-)optimal path, which will happily curve
+     * and bend to reduce costs. Visually, it doesn't make sense for a rally point path to curve and bend when it could just as well have gone
+     * in a straight line, so that's why we have this.
+     *
+     * @p coords array of path coordinates to simplify
+     * @p maxSegmentLinks if non-zero, indicates the maximum amount of consecutive node-to-node links that can be eliminated to form a single 
+     *                    link. If this value is set to e.g. 1, then no reductions will be performed. A value of 3 means that at most 3 
+     *                    consecutive node links will be joined into a single link.
+     */
+    void ReduceSegmentsByVisibility(std::vector<CVector2D>& coords, unsigned maxSegmentLinks = 0);
+
+    /**
+     * Returns a list of indices of waypoints in the current path (m_FullPath) where the LOS visibility changes, ordered from building to rally 
+     * point. Used to construct the overlay line segments and track changes to the shroud of darkness.
+     */
+    void GetVisibilitySegments(std::deque<SVisibilitySegment>& out);
+
+    /**
+     * Helper function to GetVisibilitySegments, factored out for testing. Merges single-point segments with its neighbouring segments.
+     * You should not have to call this method directly.
+     */
+    static void MergeVisibilitySegments(std::deque<SVisibilitySegment>& segments);
+
+    void RenderSubmit(SceneCollector& collector);
+
+};
+
+REGISTER_COMPONENT_TYPE(RallyPoint)
+
+void CCmpRallyPoint::Init(const CParamNode& paramNode)
+{
+    // set some defaults
+    m_LineThickness = .3f;
+    m_LineStartCap = SOverlayTexturedLine::LINECAP_FLAT;
+    m_LineEndCap = SOverlayTexturedLine::LINECAP_FLAT;
+    m_LineTexturePath = std::wstring(L"art/textures/misc/rallypoint_line.png");
+    m_LineTextureMaskPath = std::wstring(L"art/textures/misc/rallypoint_line_mask.png");
+    // implicit constructor defaults for m_LineColor and m_MarkerTemplate
+
+    // ---------------------------------------------------------------------------------------------
+    // load some XML configuration data
+
+    if (paramNode.GetChild("MarkerTemplate").IsOk())
+        m_MarkerTemplate = paramNode.GetChild("MarkerTemplate").ToString();
+
+    if (paramNode.GetChild("LineThickness").IsOk())
+        m_LineThickness = paramNode.GetChild("LineThickness").ToFixed().ToFloat();
+
+    const CParamNode& lineColor = paramNode.GetChild("LineColour");
+    if (lineColor.IsOk() && lineColor.GetChild("@r").IsOk() && lineColor.GetChild("@g").IsOk() && lineColor.GetChild("@b").IsOk())
+    {
+        m_LineColor = CColor(
+            lineColor.GetChild("@r").ToInt()/255.f,
+            lineColor.GetChild("@g").ToInt()/255.f,
+            lineColor.GetChild("@b").ToInt()/255.f,
+            1.f
+        );
+    }
+
+    const CParamNode& lineDashColor = paramNode.GetChild("LineDashColour");
+    if (lineDashColor.IsOk() && lineDashColor.GetChild("@r").IsOk() && lineDashColor.GetChild("@g").IsOk() && lineDashColor.GetChild("@b").IsOk())
+    {
+        m_LineDashColor = CColor(
+            lineDashColor.GetChild("@r").ToInt()/255.f,
+            lineDashColor.GetChild("@g").ToInt()/255.f,
+            lineDashColor.GetChild("@b").ToInt()/255.f,
+            1.f
+        );
+    }
+    else
+    {
+        m_LineDashColor = m_LineColor; // if not specified, use the same colour as the regular line segments
+    }
+
+    if (paramNode.GetChild("LineTexture").IsOk())
+        m_LineTexturePath = paramNode.GetChild("LineTexture").ToString();
+
+    if (paramNode.GetChild("LineMaskTexture").IsOk())
+        m_LineTextureMaskPath = paramNode.GetChild("LineMaskTexture").ToString();
+
+    if (paramNode.GetChild("LineStartCap").IsOk())
+    {
+        const std::wstring& xmlLineStartCap = paramNode.GetChild("LineStartCap").ToString();
+        if (!SOverlayTexturedLine::StrToLineCap(xmlLineStartCap, m_LineStartCap))
+            LOGERROR(L"Unrecognized LineStartCap value \"%s\"", xmlLineStartCap); // this shouldn't happen by virtue of the XML validation
+    }
+
+    if (paramNode.GetChild("LineEndCap").IsOk())
+    {
+        const std::wstring& xmlLineEndCap = paramNode.GetChild("LineEndCap").ToString();
+        if (!SOverlayTexturedLine::StrToLineCap(xmlLineEndCap, m_LineEndCap))
+            LOGERROR(L"Unrecognized LineEndCap value \"%s\"", xmlLineEndCap); // this shouldn't happen by virtue of the XML validation
+    }
+
+    // ---------------------------------------------------------------------------------------------
+    // load some textures
+
+    CTextureProperties texturePropsBase(m_LineTexturePath);
+    texturePropsBase.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE);
+    texturePropsBase.SetMaxAnisotropy(8.f);
+    m_Texture = g_Renderer.GetTextureManager().CreateTexture(texturePropsBase);
+
+    CTextureProperties texturePropsMask(m_LineTextureMaskPath);
+    texturePropsMask.SetWrap(GL_CLAMP_TO_BORDER, GL_CLAMP_TO_EDGE);
+    texturePropsMask.SetMaxAnisotropy(8.f);
+    m_TextureMask = g_Renderer.GetTextureManager().CreateTexture(texturePropsMask);
+
+    // ---------------------------------------------------------------------------------------------
+
+    CreateMarker(); // TODO: evaluate how much load this puts on the entity IDs, if it's too high then we can do this on-demand)
+
+}
+
+void CCmpRallyPoint::CreateMarker()
+{
+
+    CComponentManager& componentMgr = GetSimContext().GetComponentManager();
+
+    // if a marker entity already exists, kill it first
+    if (m_MarkerEntity != INVALID_ENTITY)
+    {
+        CmpPtr<ICmpPosition> markerCmpPosition(GetSimContext(), m_MarkerEntity);
+        if (!markerCmpPosition.null())
+            markerCmpPosition->MoveOutOfWorld();
+
+        componentMgr.DestroyComponentsSoon(m_MarkerEntity); // queue entity for destruction
+        m_MarkerEntity = INVALID_ENTITY; // make sure any code below doesn't try to access the soon-to-be-destroyed entity anymore
+    }
+
+    // allocate a new entity for the marker
+    if (!m_MarkerTemplate.empty())
+    {
+        m_MarkerEntity = componentMgr.AllocateNewLocalEntity();
+        if (m_MarkerEntity != INVALID_ENTITY)
+            m_MarkerEntity = componentMgr.AddEntity(m_MarkerTemplate, m_MarkerEntity);
+    }
+
+    // TODO: in the future, when variants are working properly for actors, we should set the variant corresponding to the
+    // owning player's civilization.
+    CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), GetEntityId());
+    if (!cmpOwnership.null())
+    {
+        player_id_t ownerId = cmpOwnership->GetOwner();
+        if (ownerId != INVALID_PLAYER)
+        {
+            CmpPtr<ICmpPlayerManager> cmpPlayerManager(GetSimContext(), SYSTEM_ENTITY);
+            ENSURE(!cmpPlayerManager.null());
+
+            CmpPtr<ICmpPlayer> cmpPlayer(GetSimContext(), cmpPlayerManager->GetPlayerByID(ownerId));
+            if (!cmpPlayer.null())
+            {
+                //LOGMESSAGERENDER(L"[entity %d] CCmpRallyPoint: owner civilization = %s", GetEntityId(), cmpPlayer->GetCiv());
+            }
+        }
+    }
+
+}
+
+void CCmpRallyPoint::RepositionMarker()
+{
+    if (m_MarkerEntity == INVALID_ENTITY)
+        return; // there is no valid marker entity, no use trying to position it
+
+    CmpPtr<ICmpPosition> markerCmpPosition(GetSimContext(), m_MarkerEntity);
+    if (!markerCmpPosition.null())
+    {
+        if(m_Displayed && IsSet())
+        {
+            markerCmpPosition->JumpTo(m_RallyPoint.X, m_RallyPoint.Y);
+        }
+        else
+        {
+            markerCmpPosition->MoveOutOfWorld(); // hide it
+        }
+    }
+}
+
+void CCmpRallyPoint::RecomputeRallyPointPath()
+{
+    
+    m_FullPath.clear();
+    m_VisibilitySegments.clear();
+
+    if (!IsSet())
+        return; // no use computing a path if the rally point isn't set
+
+    CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
+    if (cmpPosition.null() || !cmpPosition->IsInWorld())
+        return; // no point going on if this entity doesn't have a position or is outside of the world
+
+    CmpPtr<ICmpFootprint> cmpFootprint(GetSimContext(), GetEntityId());
+    CmpPtr<ICmpPathfinder> cmpPathFinder(GetSimContext(), SYSTEM_ENTITY);
+    //CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+
+
+    // -------------------------------------------------------------------------------------------------
+
+    entity_pos_t pathStartX = cmpPosition->GetPosition2D().X;
+    entity_pos_t pathStartY = cmpPosition->GetPosition2D().Y;
+
+    // Find a long path to the goal point -- this uses the tile-based pathfinder, which will return a
+    // list of waypoints (i.e. a Path) from the building to the goal, where each waypoint is centered
+    // at a tile. We'll have to do some post-processing on the path to get it smooth.
+    Path path;
+    std::vector<Waypoint>& waypoints = path.m_Waypoints;
+
+    Goal goal = { Goal::POINT, m_RallyPoint.X, m_RallyPoint.Y };
+    cmpPathFinder->ComputePath(
+        pathStartX,
+        pathStartY,
+        goal,
+        cmpPathFinder->GetPassabilityClass("default"),
+        cmpPathFinder->GetCostClass("default"),
+        path
+    );
+
+    if (path.m_Waypoints.size() < 2)
+        return; // not likely to happen, but can't hurt to check
+
+    // from here on, we choose to represent the waypoints as CVector2D floats to avoid to have to convert back and forth
+    // between fixed-point Waypoint/CFixedVector2D and various other float-based formats used by interpolation and whatnot.
+    // Since we'll only be further using these points for rendering purposes, using floats should be fine.
+
+    // make sure to add the actual goal point as the last point (the long pathfinder only finds paths to
+    // the tile closest to the goal, so we need to complete the last bit from the closest tile to the rally
+    // point itself)
+    // NOTE: the points are returned in reverse order (from the goal to the start point), so we need to
+    // actually insert it at the front of the coordinate list. Hence, we'll do this first before appending the rest of the
+    // fixed waypoints as CVector2Ds.
+
+    Waypoint& lastWaypoint = waypoints.back();
+    if (lastWaypoint.x != goal.x || lastWaypoint.z != goal.z)
+        m_FullPath.push_back(CVector2D(goal.x.ToFloat(), goal.z.ToFloat()));
+
+    // add the rest of the waypoints
+    for (size_t i = 0; i < waypoints.size(); ++i)
+        m_FullPath.push_back(CVector2D(waypoints[i].x.ToFloat(), waypoints[i].z.ToFloat()));
+
+    // -------------------------------------------------------------------------------------------
+    // postprocessing
+
+    // linearize the path;
+    // pass through the waypoints , averaging each waypoint with its next one except the last one. Because the path
+    // goes from the marker to this entity and we want to keep the point at the marker's exact position, loop backwards through the
+    // waypoints so that the marker waypoint is maintained.
+    // TODO: see if we can do this at the same time as the waypoint -> coord conversion above
+    for(size_t i = m_FullPath.size() - 1; i > 0; --i)
+        m_FullPath[i] = (m_FullPath[i] + m_FullPath[i-1]) / 2.0f;
+
+    // if there's a footprint, remove any points returned by the pathfinder that may be on obstructed footprint tiles
+    if (!cmpFootprint.null())
+        FixFootprintWaypoints(m_FullPath, cmpPosition, cmpFootprint);
+
+    // eliminate some consecutive waypoints that are visible from eachother.
+    ReduceSegmentsByVisibility(m_FullPath, 6); // reduce across a maximum distance of approx. 6 tiles
+
+    //// <DEBUG> ///////////////////////////////////////////////
+    if (m_EnableDebugNodeOverlay)
+        m_DebugNodeOverlays.clear();
+
+    if (m_EnableDebugNodeOverlay && m_SmoothPath)
+    {
+        // create separate control point overlays so we can differentiate when using smoothing (offset them a little higher from the
+        // terrain so we can still see them after the interpolated points are added)
+        for (size_t j = 0; j < m_FullPath.size(); ++j)
+        {
+            SOverlayLine overlayLine;
+            overlayLine.m_Color = CColor(1.0f, 0.0f, 0.0f, 1.0f);
+            overlayLine.m_Thickness = 2;
+            //SimRender::ConstructCircleOnGround(GetSimContext(), coords[j].X, coords[j].Y, 0.1f, overlayLine, true, 0.30f);
+            SimRender::ConstructSquareOnGround(GetSimContext(), m_FullPath[j].X, m_FullPath[j].Y, 0.2f, 0.2f, 1.0f, overlayLine, true);
+            m_DebugNodeOverlays.push_back(overlayLine);
+        }
+    }
+    //// </DEBUG> //////////////////////////////////////////////
+
+    if (m_SmoothPath)
+        // the number of points to interpolate goes together with the maximum amount of node links allowed to be joined together by 
+        // the visibility reduction. The more node links that can be joined together, the more interpolated points you probably need 
+        // to generate to be able to deal with terrain height changes
+        SimRender::InterpolatePointsRNS(m_FullPath, false, 0, 8); // no offset, keep line at its exact path
+
+    // -------------------------------------------------------------------------------------------
+    
+    // find which point is the last visible point before going into the SoD, so we have a point to compare to on the next turn
+    GetVisibilitySegments(m_VisibilitySegments);
+
+    // build overlay lines for the new path
+    ConstructOverlayLines();
+
+}
+
+void CCmpRallyPoint::ConstructOverlayLines()
+{
+    
+    // we need to create a new SOverlayTexturedLine every time we want to change the coordinates after having passed it to the renderer,
+    // because it does some fancy vertex buffering thing and caches them internally instead of recomputing them on every pass (which is
+    // only sensible)
+
+    m_TexturedOverlayLines.clear();
+
+    if (m_FullPath.size() < 2)
+        return;
+
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+    SOverlayTexturedLine::LineCap dashesLineCap = SOverlayTexturedLine::LINECAP_ROUND; // line caps to use for the dashed segments (and any other segment's edges that border it)
+
+    // assuming the path endpoint is in the visible LOS area (which it should be, otherwise you shouldn't have been able to set the rally point),
+    // alternate between full overlay lines (using every path point) and dashed lines in between for the SoD.
+
+    //bool dashed = false;
+    //size_t endPointIdx = m_FullPath.size() - 1;
+
+    // Move through the SoD visibility edge points, and maintain a startPointIdx and endPointIdx of each dashed/non-dashed segment along the way.
+    // It's possible that there are no visibility edge points (meaning that the entire path is inside the visible area), so let's start with -1 to 
+    // indicate "no current edge point" and then check each time whether a next one exists. If there is a next one, use its index as the end point
+    // for the segment we're drawing; otherwise, go all the way through to the end of the path (i.e. startPointIdx = 0).
+    //
+    // NOTE: this algorithm needed surprisingly little debugging, so I wouldn't be surprised if there're still some bugs in it.
+    //int currentEdgePointIdx = -1;
+    //while (currentEdgePointIdx < int(m_VisibilitySegments.size()))
+    for (std::deque<SVisibilitySegment>::const_iterator it = m_VisibilitySegments.begin(); it != m_VisibilitySegments.end(); ++it)
+    {
+        /*size_t startPointIdx = 0; // if there are no more visibility edge points after this, then the current segment should go right up until the end of the path (in reverse order, so node with idx 0; the rally point marker)
+        if (currentEdgePointIdx + 1 < int(m_VisibilitySegments.size()))
+            startPointIdx = m_VisibilitySegments[currentEdgePointIdx+1];
+
+        ENSURE(startPointIdx < m_FullPath.size()); // size_t is unsigned, so >= 0 is always true
+        ENSURE(endPointIdx < m_FullPath.size());*/
+
+        const SVisibilitySegment& segment = (*it);
+
+        if (segment.m_Visible)
+        {
+            
+            // does this segment border on the building or rally point flag on either side?
+            bool bordersBuilding = (segment.m_EndIndex == m_FullPath.size() - 1);
+            bool bordersFlag = (segment.m_StartIndex == 0);
+
+            // construct solid textured overlay line along a subset of the full path points from startPointIdx to endPointIdx
+            SOverlayTexturedLine overlayLine;
+            overlayLine.m_Thickness = m_LineThickness;
+            overlayLine.m_Terrain = cmpTerrain->GetCTerrain();
+            overlayLine.m_TextureBase = m_Texture;
+            overlayLine.m_TextureMask = m_TextureMask;
+            overlayLine.m_Color = m_LineColor;
+            overlayLine.m_Closed = false;
+            // we should take care to only use m_LineXCap for the actual end points at the building and the rally point; any intermediate
+            // end points (i.e., that border a dashed segment) should have the dashed cap
+            // the path line is actually in reverse order as well, so let's swap out the start and end caps
+            overlayLine.m_StartCap = (bordersFlag ? m_LineEndCap : dashesLineCap);
+            overlayLine.m_EndCap = (bordersBuilding ? m_LineStartCap : dashesLineCap);
+            overlayLine.m_AlwaysVisible = true;
+
+            // push overlay line coordinates
+            ENSURE(segment.m_EndIndex > segment.m_StartIndex);
+            for (size_t j = segment.m_StartIndex; j <= segment.m_EndIndex; ++j) // end index is inclusive here
+            {
+                overlayLine.m_Coords.push_back(m_FullPath[j].X);
+                overlayLine.m_Coords.push_back(m_FullPath[j].Y);
+            }
+
+            m_TexturedOverlayLines.push_back(overlayLine);
+        }
+        else
+        {
+            // construct dashed line from startPointIdx to endPointIdx, add textured overlay lines for it to the render list
+            std::vector<CVector2D> straightLine;
+            straightLine.push_back(m_FullPath[segment.m_StartIndex]);
+            straightLine.push_back(m_FullPath[segment.m_EndIndex]);
+
+            // We always want to have the dashed line end at either point with a full dash (i.e. not a cleared space), so that the dashed
+            // area is visually obvious. That implies that we want at least So, let's do some calculations to see what size we should make 
+            // the dashes and clears.
+
+            float maxDashSize = 3.f;
+            float maxClearSize = 3.f;
+            
+            float dashSize = maxDashSize;
+            float clearSize = maxClearSize;
+            float pairDashRatio = (dashSize / (dashSize + clearSize)); // ratio of the dash's length to a (dash + clear) pair's length
+
+            float distance = (m_FullPath[segment.m_StartIndex] - m_FullPath[segment.m_EndIndex]).Length(); // straight-line distance between the points
+
+            // see how many pairs (dash + clear) can fit into the distance unmodified. Then check the remaining distance; if it's not exactly
+            // a dash size's worth (and it likely won't be), then adjust the dash/clear sizes slightly so that it is.
+            int numFitUnmodified = floor(distance/(dashSize + clearSize));
+            float remainderDistance = distance - (numFitUnmodified * (dashSize + clearSize));
+
+            // Now we want to make remainderDistance equal exactly one dash size (i.e. maxDashSize) by scaling dashSize and clearSize slightly. 
+            // We have (remainderDistance - maxDashSize) of space to distribute over numFitUnmodified instances of (dashSize + clearSize) to make
+            // it fit, so each (dashSize + clearSize) pair needs to adjust its length by (remainderDistance - maxDashSize)/numFitUnmodified 
+            // (which will be positive or negative accordingly). This number can then be distributed further proportionally among the dash's 
+            // length and the clear's length.
+
+            // we always want to have at least one dash/clear pair (i.e., "|===|   |===|"); also, we need to avoid division by zero below.
+            numFitUnmodified = std::max(1, numFitUnmodified);
+
+            float pairwiseLengthDifference = (remainderDistance - maxDashSize)/numFitUnmodified; // can be either positive or negative
+            dashSize += pairDashRatio * pairwiseLengthDifference;
+            clearSize += (1 - pairDashRatio) * pairwiseLengthDifference;
+
+            // ------------------------------------------------------------------------------------------------
+
+            SDashedLine dashedLine;
+            SimRender::ConstructDashedLine(straightLine, dashedLine, dashSize, clearSize);
+
+            // build overlay lines for dashes
+            size_t numDashes = dashedLine.m_StartIndices.size();
+            for (size_t i=0; i < numDashes; i++)
+            {
+                SOverlayTexturedLine dashOverlay;
+
+                dashOverlay.m_Thickness = m_LineThickness;
+                dashOverlay.m_Terrain = cmpTerrain->GetCTerrain();
+                dashOverlay.m_TextureBase = m_Texture;
+                dashOverlay.m_TextureMask = m_TextureMask;
+                dashOverlay.m_Color = m_LineDashColor;
+                dashOverlay.m_Closed = false;
+                // the path line is actually in reverse order, so let's swap out the start and end caps too
+                dashOverlay.m_StartCap = dashesLineCap;
+                dashOverlay.m_EndCap = dashesLineCap;
+                dashOverlay.m_AlwaysVisible = true;
+                // TODO: maybe adjust the elevation of the dashes to be a little lower, so that it slides underneath the actual path
+
+                size_t dashStartIndex = dashedLine.m_StartIndices[i];
+                size_t dashEndIndex = dashedLine.GetEndIndex(i);
+                ENSURE(dashEndIndex > dashStartIndex);
+
+                for (size_t n = dashStartIndex; n < dashEndIndex; n++)
+                {
+                    dashOverlay.m_Coords.push_back(dashedLine.m_Points[n].X);
+                    dashOverlay.m_Coords.push_back(dashedLine.m_Points[n].Y);
+                }
+
+                m_TexturedOverlayLines.push_back(dashOverlay);
+            }
+            
+        }
+
+        //dashed = !dashed;
+        //endPointIdx = startPointIdx; // don't link up at the exact same point, that's gonna leave an ugly overlap between two end caps
+
+        //++currentEdgePointIdx;
+
+    }
+
+    //// <DEBUG> //////////////////////////////////////////////
+    if (m_EnableDebugNodeOverlay)
+    {
+        for (size_t j = 0; j < m_FullPath.size(); ++j)
+        {
+            SOverlayLine overlayLine;
+            overlayLine.m_Color = CColor(1.0f, 1.0f, 1.0f, 1.0f);
+            overlayLine.m_Thickness = 1;
+            SimRender::ConstructCircleOnGround(GetSimContext(), m_FullPath[j].X, m_FullPath[j].Y, 0.075f, overlayLine, true);
+            m_DebugNodeOverlays.push_back(overlayLine);
+        }
+    }
+    //// </DEBUG> //////////////////////////////////////////////
+}
+
+void CCmpRallyPoint::UpdateOverlayLines()
+{
+    
+    // we should really only do this if the rally point is currently being displayed and set inside the world, otherwise it's a massive 
+    // waste of time to calculate all this stuff every turn if there's nothing to show for it anyway
+
+    if (!m_Displayed || !IsSet())
+        return;
+
+    // see if there have been any changes to the SoD by grabbing the visibility edge points and comparing them to the previous ones
+    std::deque<SVisibilitySegment> newVisibilitySegments;
+    GetVisibilitySegments(newVisibilitySegments);
+
+    // compare the two indices vectors; as soon as an element is different (and provided the full path hasn't changed), then the SoD 
+    // has changed and we should recreate the overlay lines
+    /*bool same = (m_VisibilitySegments.size() == currentVisibilitySegments.size()); // initial check
+    if (same)
+    {
+        std::deque<SVisibilitySegment>::const_iterator oldIt = m_VisibilitySegments.begin();
+        std::deque<SVisibilitySegment>::const_iterator newIt = currentVisibilitySegments.begin();
+
+        while (newIt != currentVisibilitySegments.end())
+        {
+            same = same && (*newIt == *oldIt);
+            if (!same) break;
+
+            ++newIt;
+            ++oldIt;
+        }
+    }*/
+    bool same = (m_VisibilitySegments == newVisibilitySegments);
+
+    if (!same)
+    {
+        // the visibility segments have changed, so we want to reconstruct the overlay lines to match. Note that the path itself doesn't
+        // change, only the overlay lines we construct from them.
+        //LOGMESSAGERENDER(L"LOS visibility segments changed, updating overlays (current: %d segments, new: %d)", m_VisibilitySegments.size(), newVisibilitySegments.size());
+        m_VisibilitySegments = newVisibilitySegments; // save the new visibility segments to compare against next time
+        ConstructOverlayLines();
+    }
+
+}
+
+void CCmpRallyPoint::FixFootprintWaypoints(std::vector<CVector2D>& coords, CmpPtr<ICmpPosition> cmpPosition, CmpPtr<ICmpFootprint> cmpFootprint)
+{
+    ENSURE(!cmpPosition.null());
+    ENSURE(!cmpFootprint.null());
+
+    // -----------------------------------------------------------------------------------------------------
+
+    //std::vector<Waypoint>& waypoints = m_FullPath.m_Waypoints; // for ease of access
+    // TODO: nasty fixed/float conversions everywhere
+
+    // grab the shape and dimensions of the footprint
+    entity_pos_t footprintSize0, footprintSize1, footprintHeight;
+    ICmpFootprint::EShape footprintShape;
+    cmpFootprint->GetShape(footprintShape, footprintSize0, footprintSize1, footprintHeight);
+
+    // grab the center of the footprint
+    CFixedVector2D center = cmpPosition->GetPosition2D();
+
+    // -----------------------------------------------------------------------------------------------------
+
+    switch (footprintShape)
+    {
+    case ICmpFootprint::SQUARE:
+        {
+            // in this case, footprintSize0 and 1 respectively indicate the (unrotated) size along the X and Z axes
+
+            // the building's footprint could be rotated any which way, so let's get the rotation around the Y axis
+            // and the rotated unit vectors in the X/Z plane of the shape's footprint
+            // (the Footprint itself holds only the outline, the Position holds the orientation)
+
+            fixed s, c; // sine and cosine of the Y axis rotation angle (aka the yaw)
+            fixed a = cmpPosition->GetRotation().Y;
+            sincos_approx(a, s, c);
+            CFixedVector2D u(c, -s); // unit vector along the rotated X axis
+            CFixedVector2D v(s, c); // unit vector along the rotated Z axis
+            CFixedVector2D halfSize(footprintSize0/2, footprintSize1/2);
+
+            // starting from the start position, check if any points are within the footprint of the building
+            // (this is possible if the pathfinder was started from a point located within the footprint)
+            for(int i = (int)(coords.size() - 1); i >= 0; i--)
+            {
+                const CVector2D& wp = coords[i];
+                if (Geometry::PointIsInSquare(CFixedVector2D(fixed::FromFloat(wp.X), fixed::FromFloat(wp.Y)) - center, u, v, halfSize))
+                {
+                    coords.erase(coords.begin() + i);
+                }
+                else
+                {
+                    break; // point no longer inside footprint, from this point on neither will any of the following be
+                }
+            }
+
+            // add a point right on the edge of the footprint (nearest to the last waypoint) so that it links up nicely with the rest of the path
+            CFixedVector2D lastWaypoint(fixed::FromFloat(coords.back().X), fixed::FromFloat(coords.back().Y));
+            CFixedVector2D footprintEdgePoint = Geometry::NearestPointOnSquare(lastWaypoint - center, u, v, halfSize); // relative to the shape origin (center)
+            CVector2D footprintEdge((center.X + footprintEdgePoint.X).ToFloat(), (center.Y + footprintEdgePoint.Y).ToFloat());
+            coords.push_back(footprintEdge);
+
+        }
+        break;
+    case ICmpFootprint::CIRCLE:
+        {
+            // in this case, both footprintSize0 and 1 indicate the circle's radius
+
+            for(int i = (int)(coords.size() - 1); i >= 0; i--)
+            {
+                const CVector2D& wp = coords[i];
+                fixed pointDistance = (CFixedVector2D(fixed::FromFloat(wp.X), fixed::FromFloat(wp.Y)) - center).Length();
+                if (pointDistance <= footprintSize0)
+                {
+                    coords.erase(coords.begin() + i);
+                }
+                else
+                {
+                    break; // point no longer inside footprint, from this point on neither will any of the following be
+                }
+            }
+
+            // add a point right on the edge of the footprint so that it links up nicely with the rest of the path
+            /*CFixedVector2D radiusEdgePoint = CFixedVector2D(waypoints.back().x, waypoints.back().z) - center;
+            radiusEdgePoint.Normalize(footprintSize1); // resize vector to footprint circle radius to get point on edge in same direction
+            Waypoint footprintEdge = { center.X + radiusEdgePoint.X, center.Y + radiusEdgePoint.Y };
+            waypoints.push_back(footprintEdge);*/
+
+            CFixedVector2D radiusEdgePoint(fixed::FromFloat(coords.back().X), fixed::FromFloat(coords.back().Y));
+            radiusEdgePoint.Normalize(footprintSize1);
+            CVector2D footprintEdge((center.X + radiusEdgePoint.X).ToFloat(), (center.Y + radiusEdgePoint.Y).ToFloat());
+            coords.push_back(footprintEdge);
+
+        }
+        break;
+    }
+
+}
+
+void CCmpRallyPoint::FixInvisibleWaypoints(std::vector<CVector2D>& coords)
+{
+    CmpPtr<ICmpRangeManager> cmpRangeMgr(GetSimContext(), SYSTEM_ENTITY);
+
+    player_id_t currentPlayer = GetSimContext().GetCurrentDisplayedPlayer();
+    CLosQuerier losQuerier(cmpRangeMgr->GetLosQuerier(currentPlayer));
+
+    //for (std::vector<Waypoint>::iterator it = waypoints.begin(); it != waypoints.end();)
+    for(std::vector<CVector2D>::iterator it = coords.begin(); it != coords.end();)
+    {
+        int i = (fixed::FromFloat(it->X) / (int)CELL_SIZE).ToInt_RoundToNearest();
+        int j = (fixed::FromFloat(it->Y) / (int)CELL_SIZE).ToInt_RoundToNearest();
+
+        bool explored = losQuerier.IsExplored(i, j);
+        if (!explored)
+        {
+            it = coords.erase(it);
+        }
+        else
+        {
+            it++;
+        }
+    }
+
+}
+
+void CCmpRallyPoint::ReduceSegmentsByVisibility(std::vector<CVector2D>& coords, unsigned maxSegmentLinks)
+{
+
+    CmpPtr<ICmpPathfinder> cmpPathFinder(GetSimContext(), SYSTEM_ENTITY);
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+
+    if (coords.size() < 3)
+        return;
+
+    // the basic idea is this: starting from a base node, keep checking each individual point along the path to see if there's a visible
+    // line between it and the base point. If so, keep going, otherwise, make the last visible point the new base node and start the same
+    // process from there on until the entire line is checked. The output is the array of base nodes.
+
+    std::vector<CVector2D> newCoords;
+    StationaryObstructionFilter obstructionFilter; // TODO: is this the right one to use?
+    entity_pos_t lineRadius = fixed::FromFloat(m_LineThickness);
+    ICmpPathfinder::pass_class_t passabilityClass = cmpPathFinder->GetPassabilityClass("default");
+
+    newCoords.push_back(coords[0]); // save the first base node
+
+    size_t baseNodeIdx = 0;
+    size_t curNodeIdx = 1;
+
+// kind of ugly, but prevents code duplication below
+#define UPDATE_BASENODE_XYZ() STMT(baseNodeX = fixed::FromFloat(coords[baseNodeIdx].X);\
+                               baseNodeZ = fixed::FromFloat(coords[baseNodeIdx].Y);\
+                               baseNodeY = cmpTerrain->GetExactGroundLevel(coords[baseNodeIdx].X, coords[baseNodeIdx].Y);)
+    
+    float baseNodeY;
+    entity_pos_t baseNodeX;
+    entity_pos_t baseNodeZ;
+
+    UPDATE_BASENODE_XYZ(); // set initial base node coords
+
+    while (curNodeIdx < coords.size())
+    {
+        ENSURE(curNodeIdx > baseNodeIdx); // this needs to be true at all times, otherwise we're checking visibility between a point and itself
+
+        entity_pos_t curNodeX = fixed::FromFloat(coords[curNodeIdx].X);
+        entity_pos_t curNodeZ = fixed::FromFloat(coords[curNodeIdx].Y);
+        float curNodeY = cmpTerrain->GetExactGroundLevel(coords[curNodeIdx].X, coords[curNodeIdx].Y);
+
+        // find out whether curNode is visible from baseNode (careful; this is in 2D only; terrain height differences are ignored!)
+        bool curNodeVisible = cmpPathFinder->CheckMovement(obstructionFilter, baseNodeX, baseNodeZ, curNodeX, curNodeZ, lineRadius, passabilityClass);
+
+        // since height differences are ignored by CheckMovement, let's call two points visible from one another only if they're at roughly the same terrain elevation
+        curNodeVisible = curNodeVisible && fabsf(curNodeY - baseNodeY) < 3.f; // TODO: this could probably use some tuning
+        if (maxSegmentLinks > 0)
+            curNodeVisible = curNodeVisible && ((curNodeIdx - baseNodeIdx) <= maxSegmentLinks); // max. amount of node-to-node links to be eliminated (unsigned subtraction is valid because curNodeIdx is always > baseNodeIdx)
+
+        if (!curNodeVisible)
+        {
+            // current node is not visible from the base node, so the previous one was the last visible point from baseNode and should
+            // hence become the new base node for further iterations.
+
+            // if curNodeIdx is adjacent to the current baseNode (which is possible due to steep height differences, e.g. hills), then
+            // we should take care not to stay stuck at the current base node
+            if (curNodeIdx > baseNodeIdx + 1)
+            {
+                baseNodeIdx = curNodeIdx - 1;
+            }
+            else
+            {
+                // curNodeIdx == baseNodeIdx + 1
+                baseNodeIdx = curNodeIdx;
+                curNodeIdx++; // move the next candidate node one forward so that we don't test a point against itself in the next iteration
+            }
+
+            newCoords.push_back(coords[baseNodeIdx]); // add new base node to output list
+
+            UPDATE_BASENODE_XYZ();
+
+        }
+
+        curNodeIdx++;
+
+    }
+
+#undef UPDATE_BASENODE_XYZ
+
+    // we always need to add the last point back to the array; if e.g. all the points up to the last one are all visible from the current
+    // base node, then the loop above just ends and no endpoint is ever added to the list.
+    ENSURE(curNodeIdx == coords.size());
+    newCoords.push_back(coords[coords.size() - 1]);
+
+    coords.swap(newCoords);
+
+}
+
+void CCmpRallyPoint::GetVisibilitySegments(std::deque<SVisibilitySegment>& out)
+{
+    
+    out.clear();
+
+    if (m_FullPath.size() < 2)
+        return;
+
+    CmpPtr<ICmpRangeManager> cmpRangeMgr(GetSimContext(), SYSTEM_ENTITY);
+
+    player_id_t currentPlayer = GetSimContext().GetCurrentDisplayedPlayer();
+    CLosQuerier losQuerier(cmpRangeMgr->GetLosQuerier(currentPlayer));
+
+    // temporary storage for the raw segments (we need to do some post-processing before writing to @p out)
+    //std::vector<SVisibilitySegment> workingSegments;
+
+    // go through the path node list, comparing each node's visibility with the previous one. If it changes, end the current segment and start
+    // a new one at the next point.
+
+    bool lastVisible = losQuerier.IsExplored(
+        (fixed::FromFloat(m_FullPath[0].X) / (int) CELL_SIZE).ToInt_RoundToNearest(),
+        (fixed::FromFloat(m_FullPath[0].Y) / (int) CELL_SIZE).ToInt_RoundToNearest()
+    );
+    size_t curSegmentStartIndex = 0; // starting node index of the current segment
+
+    for (size_t k = 1; k < m_FullPath.size(); ++k)
+    {
+        // grab tile indices for this coord
+        int i = (fixed::FromFloat(m_FullPath[k].X) / (int)CELL_SIZE).ToInt_RoundToNearest();
+        int j = (fixed::FromFloat(m_FullPath[k].Y) / (int)CELL_SIZE).ToInt_RoundToNearest();
+
+        bool nodeVisible = losQuerier.IsExplored(i, j);
+        if (nodeVisible != lastVisible)
+        {
+            // visibility changed; write out the segment that was just completed and get ready for the new one
+            out.push_back(SVisibilitySegment(lastVisible, curSegmentStartIndex, k - 1));
+
+            //curSegmentStartIndex = k; // new segment starts here
+            curSegmentStartIndex = k - 1;
+            lastVisible = nodeVisible;
+        }
+
+    }
+
+    // terminate the last segment
+    out.push_back(SVisibilitySegment(lastVisible, curSegmentStartIndex, m_FullPath.size() - 1));
+
+    //ENSURE(out[0].m_StartIndex == 0);
+    //ENSURE(out[out.size()-1].m_EndIndex == m_FullPath.size()-1);
+
+    // ---------------------------------------------------------------------------------------------------
+    MergeVisibilitySegments(out);
+
+}
+
+void CCmpRallyPoint::MergeVisibilitySegments(std::deque<SVisibilitySegment>& segments)
+{
+    // now scan for single-point segments; if they are inbetween two other segments, delete it and merge the surrounding segments;
+    // if they're at either end of the path, include them in their bordering segment (but only if those bordering segments aren't also themselves
+    // single-point segments, because then we would want those to get absorbed by its surrounding ones).
+
+    // first scan for absorptions of single-point surrounded segments (i.e. excluding edge segments)
+    size_t numSegments = segments.size();
+
+    // YE BE WARNED: HERE BE FOR LOOP TRICKERY
+    for (size_t i = 1; i < numSegments - 1;)
+    {
+        SVisibilitySegment& segment = segments[i];
+        if (segment.IsSinglePoint())
+        {
+            ENSURE(segments[i-1].m_Visible == segments[i+1].m_Visible); // since the segments' visibility alternates, the surrounding ones should have the same visibility
+            segments[i-1].m_EndIndex = segments[i+1].m_EndIndex; // make previous segment span all the way across to the next
+            segments.erase(segments.begin() + i); // erase this segment ...
+            segments.erase(segments.begin() + i); // and the next (note; since we removed [i], [i+1] is now at position [i])
+            numSegments -= 2; // we removed 2 segments, so update the loop condition
+            // in the next iteration, i should still point to this index (which will now be the index of the segment right after the one that got expanded),
+            // so don't increment i here
+        }
+        else
+        {
+            ++i;
+        }
+    }
+
+    ENSURE(numSegments == segments.size());
+
+    // check to see if the first segment needs to be merged with its neighbour
+    if (segments.size() >= 2 && segments[0].IsSinglePoint())
+    {
+        int firstSegmentStartIndex = segments.front().m_StartIndex;
+        ENSURE(firstSegmentStartIndex == 0);
+        ENSURE(!segments[1].IsSinglePoint()); // at this point, the second segment should never be a single-point segment
+        
+        segments.erase(segments.begin());
+        segments.front().m_StartIndex = firstSegmentStartIndex;
+
+    }
+
+    // check to see if the last segment needs to be merged with its neighbour
+    if (segments.size() >= 2 && segments[segments.size()-1].IsSinglePoint())
+    {
+        int lastSegmentEndIndex = segments.back().m_EndIndex;
+        ENSURE(!segments[segments.size()-2].IsSinglePoint()); // at this point, the second-to-last segment should never be a single-point segment
+
+        segments.erase(segments.end());
+        segments.back().m_EndIndex = lastSegmentEndIndex;
+    }
+
+    // --------------------------------------------------------------------------------------------------------
+    // at this point, every segment should have at least 2 points
+    for (size_t i = 0; i < segments.size(); ++i)
+    {
+        ENSURE(!segments[i].IsSinglePoint());
+        ENSURE(segments[i].m_EndIndex > segments[i].m_StartIndex);
+    }
+
+}
+
+void CCmpRallyPoint::RenderSubmit(SceneCollector& collector)
+{
+
+    // we only get here if the rally point is set and should be displayed
+    for (size_t i = 0; i < m_TexturedOverlayLines.size(); ++i)
+    {
+        if (!m_TexturedOverlayLines[i].m_Coords.empty())
+            collector.Submit(&m_TexturedOverlayLines[i]);
+    }
+
+    if (m_EnableDebugNodeOverlay && !m_DebugNodeOverlays.empty())
+    {
+        for (size_t i = 0; i < m_DebugNodeOverlays.size(); i++)
+            collector.Submit(&m_DebugNodeOverlays[i]);
+    }
+
+}

source/simulation2/components/CCmpSelectable.cpp

@@ -1 @@
-/* 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
@@ -22 +22 @@
 
 #include "ICmpPosition.h"
 #include "ICmpFootprint.h"
+#include "ICmpVisual.h"
 #include "simulation2/MessageTypes.h"
 #include "simulation2/helpers/Render.h"
 
@@ -155 +156 @@
         // (This is only called if a > 0)
 
         collector.Submit(&m_Overlay);
+
+        // TODO: use this to draw debug overlays for the bounding boxes
+        /*CmpPtr<ICmpVisual> cmpVisual(GetSimContext(), GetEntityId());
+        if (!cmpVisual.null())
+        {
+            CBound bound = cmpVisual->GetBounds();
+            CVector3D tmin = bound[0];
+            CVector3D tmax = bound[1];
+
+            static SOverlayLine* overlayLine = new SOverlayLine();
+            overlayLine->m_Thickness = 2;
+            overlayLine->m_Color = CColor(1.0, 0.0, 0.0, 1.0);
+            overlayLine->m_Coords.clear();
+            // floor square
+            overlayLine->m_Coords.push_back(tmin.X); overlayLine->m_Coords.push_back(tmin.Y); overlayLine->m_Coords.push_back(tmin.Z);
+            overlayLine->m_Coords.push_back(tmax.X); overlayLine->m_Coords.push_back(tmin.Y); overlayLine->m_Coords.push_back(tmin.Z);
+            overlayLine->m_Coords.push_back(tmax.X); overlayLine->m_Coords.push_back(tmin.Y); overlayLine->m_Coords.push_back(tmax.Z);
+            overlayLine->m_Coords.push_back(tmin.X); overlayLine->m_Coords.push_back(tmin.Y); overlayLine->m_Coords.push_back(tmax.Z);
+            overlayLine->m_Coords.push_back(tmin.X); overlayLine->m_Coords.push_back(tmin.Y); overlayLine->m_Coords.push_back(tmin.Z);
+            // roof square
+            overlayLine->m_Coords.push_back(tmin.X); overlayLine->m_Coords.push_back(tmax.Y); overlayLine->m_Coords.push_back(tmin.Z);
+            overlayLine->m_Coords.push_back(tmax.X); overlayLine->m_Coords.push_back(tmax.Y); overlayLine->m_Coords.push_back(tmin.Z);
+            overlayLine->m_Coords.push_back(tmax.X); overlayLine->m_Coords.push_back(tmax.Y); overlayLine->m_Coords.push_back(tmax.Z);
+            overlayLine->m_Coords.push_back(tmin.X); overlayLine->m_Coords.push_back(tmax.Y); overlayLine->m_Coords.push_back(tmax.Z);
+            overlayLine->m_Coords.push_back(tmin.X); overlayLine->m_Coords.push_back(tmax.Y); overlayLine->m_Coords.push_back(tmin.Z);
+            // supports
+            collector.Submit(overlayLine);
+        }*/
+
     }
 };
 

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -103 +103 @@
 
     TerritoryOverlay* m_DebugOverlay;
 
+    bool m_EnableLineDebugOverlays; ///< Enable node debugging overlays for boundary lines?
+    std::vector<SOverlayLine> m_DebugBoundaryLineNodes;
+
     virtual void Init(const CParamNode& UNUSED(paramNode))
     {
         m_Territories = NULL;
@@ -110 +113 @@
 //      m_DebugOverlay = new TerritoryOverlay(*this);
         m_BoundaryLinesDirty = true;
         m_TriggerEvent = true;
-
+        m_EnableLineDebugOverlays = false;
         m_DirtyID = 1;
 
         m_AnimTime = 0.0;
@@ -742 +745 @@
     PROFILE("update boundary lines");
 
     m_BoundaryLines.clear();
+    m_DebugBoundaryLineNodes.clear();
 
     std::vector<CCmpTerritoryManager::TerritoryBoundary> boundaries = ComputeBoundaries();
 
@@ -777 +781 @@
         m_BoundaryLines.push_back(SBoundaryLine());
         m_BoundaryLines.back().connected = boundaries[i].connected;
         m_BoundaryLines.back().color = color;
-
         m_BoundaryLines.back().overlay.m_Terrain = terrain;
         m_BoundaryLines.back().overlay.m_TextureBase = textureBase;
         m_BoundaryLines.back().overlay.m_TextureMask = textureMask;
         m_BoundaryLines.back().overlay.m_Color = color;
         m_BoundaryLines.back().overlay.m_Thickness = m_BorderThickness;
+        m_BoundaryLines.back().overlay.m_Closed = true;
 
-        SimRender::SmoothPointsAverage(boundaries[i].points, true);
+        SimRender::SmoothPointsAverage(boundaries[i].points, m_BoundaryLines.back().overlay.m_Closed);
 
-        SimRender::InterpolatePointsRNS(boundaries[i].points, true, m_BorderSeparation);
+        SimRender::InterpolatePointsRNS(boundaries[i].points, m_BoundaryLines.back().overlay.m_Closed, m_BorderSeparation);
 
         std::vector<float>& points = m_BoundaryLines.back().overlay.m_Coords;
         for (size_t j = 0; j < boundaries[i].points.size(); ++j)
         {
             points.push_back(boundaries[i].points[j].X);
             points.push_back(boundaries[i].points[j].Y);
+
+            if (m_EnableLineDebugOverlays)
+            {
+                SOverlayLine overlayNode;
+                if (j > boundaries[i].points.size() - 1 - 7)
+                    overlayNode.m_Color = CColor(1.f, 0.f, 0.f, 1.f);
+                else if (j < 7)
+                    overlayNode.m_Color = CColor(0.f, 1.f, 0.f, 1.f);
+                else
+                    overlayNode.m_Color = CColor(1.0f, 1.0f, 1.0f, 1.0f);
+
+                overlayNode.m_Thickness = 1;
+                SimRender::ConstructCircleOnGround(GetSimContext(), boundaries[i].points[j].X, boundaries[i].points[j].Y, 0.1f, overlayNode, true);
+                m_DebugBoundaryLineNodes.push_back(overlayNode);
+            }
         }
+
     }
 }
 
@@ -822 +842 @@
 {
     for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
         collector.Submit(&m_BoundaryLines[i].overlay);
+    
+    for( size_t i = 0; i < m_DebugBoundaryLineNodes.size(); ++i)
+        collector.Submit(&m_DebugBoundaryLineNodes[i]);
+
 }
 
 player_id_t CCmpTerritoryManager::GetOwner(entity_pos_t x, entity_pos_t z)

new file source/simulation2/components/ICmpRallyPoint.cpp

@@ +1 @@
+/* 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
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "ICmpRallyPoint.h"
+#include "simulation2/system/InterfaceScripted.h"
+
+BEGIN_INTERFACE_WRAPPER(RallyPoint)
+DEFINE_INTERFACE_METHOD_0("GetPosition", RallyPointPosition, ICmpRallyPoint, GetPosition)
+DEFINE_INTERFACE_METHOD_1("SetPosition", void, ICmpRallyPoint, SetPosition, RallyPointPosition)
+DEFINE_INTERFACE_METHOD_0("IsSet", bool, ICmpRallyPoint, IsSet)
+DEFINE_INTERFACE_METHOD_0("Unset", void, ICmpRallyPoint, Unset)
+DEFINE_INTERFACE_METHOD_1("SetDisplayed", void, ICmpRallyPoint, SetDisplayed, bool)
+//DEFINE_INTERFACE_METHOD_0("GetMarkerEntityId", entity_id_t, ICmpRallyPoint, GetMarkerEntityId)
+END_INTERFACE_WRAPPER(RallyPoint)

new file source/simulation2/components/ICmpRallyPoint.h

@@ +1 @@
+/* Copyright (C) 2010 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_ICMPRALLYPOINT
+#define INCLUDED_ICMPRALLYPOINT
+
+#include "simulation2/system/Interface.h"
+#include "simulation2/helpers/Position.h"
+
+#include "maths/FixedVector2D.h"
+
+// trivial position subclass for JS conversions (so we can use x and z instead of x and y)
+class RallyPointPosition : public CFixedVector2D {};
+
+/**
+ * Rally Point.
+ * Holds the position of a unit's rally point, and renders it to screen.
+ */
+class ICmpRallyPoint : public IComponent
+{
+public:
+
+    virtual RallyPointPosition GetPosition() = 0;
+    virtual void SetPosition(RallyPointPosition pos) = 0;
+    virtual void SetDisplayed(bool displayed) = 0;
+    //virtual entity_id_t GetMarkerEntityId() = 0;
+    virtual void Unset() = 0;
+    virtual bool IsSet() = 0;
+
+    DECLARE_INTERFACE_TYPE(RallyPoint)
+};
+
+#endif // INCLUDED_ICMPRALLYPOINT

source/simulation2/helpers/Geometry.h

@@ -1 @@
-/* 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
@@ -30 +30 @@
 namespace Geometry
 {
 
+/**
+ * Returns true if @p point is inside the square with rotated X axis unit vector @p u and rotated Z axis unit vector @p v,
+ * and half dimensions specified by @p halfSizes. Currently assumes the @p u and @p v vectors are perpendicular. Can also
+ * be used for rectangles.
+ *
+ * @param point point vector of the point that is to be tested relative to the origin (center) of the shape.
+ * @param u rotated X axis unit vector relative to the absolute XZ plane. Indicates the orientation of the rectangle. If not rotated,
+ *          this value is the absolute X axis unit vector (1,0). If rotated by angle theta, this should be (cos theta, -sin theta), as
+ *          the absolute Z axis points down in the unit circle.
+ * @param v rotated Z axis unit vector relative to the absolute XZ plane. Indicates the orientation of the rectangle. If not rotated,
+ *          this value is the absolute Z axis unit vector (0,1). If rotated by angle theta, this should be (sin theta, cos theta), as
+ *          the absolute Z axis points down in the unit circle.
+ * @param halfSizes Holds half the dimensions of the shape along the u and v vectors, respectively.
+ */
 bool PointIsInSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 CFixedVector2D GetHalfBoundingBox(CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 fixed DistanceToSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
+/**
+ * Returns the point that is closest to @p point on the edge of the square specified by orientation unit vectors @p u and @p v and half
+ * dimensions @p halfSize, relative to the center of the square. Currently assumes the @p u and @p v vectors are perpendicular.
+ * Can also be used for rectangles.
+ *
+ * @param point point vector of the point we want to get the nearest edge point for, relative to the origin (center) of the shape.
+ * @param u rotated X axis unit vector, relative to the absolute XZ plane. Indicates the orientation of the shape. If not rotated,
+ *          this value is the absolute X axis unit vector (1,0). If rotated by angle theta, this should be (cos theta, -sin theta).
+ * @param v rotated Z axis unit vector, relative to the absolute XZ plane. Indicates the orientation of the shape. If not rotated,
+ *          this value is the absolute Z axis unit vector (0,1). If rotated by angle theta, this should be (sin theta, cos theta).
+ * @param halfSizes Holds half the dimensions of the shape along the u and v vectors, respectively.
+ */
 CFixedVector2D NearestPointOnSquare(CFixedVector2D point, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);
 
 bool TestRaySquare(CFixedVector2D a, CFixedVector2D b, CFixedVector2D u, CFixedVector2D v, CFixedVector2D halfSize);

source/simulation2/helpers/Render.cpp

@@ -1 @@
-/* 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
@@ -201 +201 @@
     return p + CVector2D(dp.Y*-offset, dp.X*offset);
 }
 
-void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset)
+void SimRender::InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples)
 {
     PROFILE("InterpolatePointsRNS");
+    ENSURE(segmentSamples > 0);
 
     std::vector<CVector2D> newPoints;
+    const float fSegmentSamples = (float) segmentSamples;
 
     // (This does some redundant computations for adjacent vertices,
     // but it's fairly fast (<1ms typically) so we don't worry about it yet)
@@ -215 +217 @@
     // curve with fewer points
 
     size_t n = points.size();
+
+    if (closed)
+    {
     if (n < 1)
-        return; // can't do anything unless we have two points
+            return; // we need at least a single point to not crash
+    }
+    else
+    {
+        if (n < 2)
+            return; // in non-closed mode, we need at least n=2 to not crash
+    }
 
-    size_t imax = closed ? n : n-1; // TODO: we probably need to do a bit more to handle non-closed paths
+    size_t imax = closed ? n : n-1;
+    newPoints.reserve(imax*segmentSamples);
 
-    newPoints.reserve(imax*4);
+    // these are primarily used inside the loop, but for open paths we need them outside the loop once to compute the last point
+    CVector2D a0;
+    CVector2D a1;
+    CVector2D a2;
+    CVector2D a3;
 
     for (size_t i = 0; i < imax; ++i)
     {
-        // Get the relevant points for this spline segment
-        CVector2D p0 = points[(i-1+n)%n];
+
+        // Get the relevant points for this spline segment; each step interpolates the segment between p1 and p2; p0 and p3 are the points
+        // before p1 and after p2, respectively; they're needed to compute tangents and whatnot.
+        CVector2D p0; // normally points[(i-1+n)%n], but it's a bit more complicated due to open/closed paths -- see below
         CVector2D p1 = points[i];
         CVector2D p2 = points[(i+1)%n];
-        CVector2D p3 = points[(i+2)%n];
+        CVector2D p3; // normally points[(i+2)%n], but it's a bit more complicated due to open/closed paths -- see below
+
+        if (!closed && (i == 0))
+            // p0's point index is out of bounds, and we can't wrap around because we're in non-closed mode -- create an artificial point
+            // that extends p1 -> p0 (i.e. the first segment's direction)
+            p0 = points[0] + (points[0] - points[1]);
+        else
+            // standard wrap-around case
+            p0 = points[(i-1+n)%n]; // careful; don't use (i-1)%n here, as the result is machine-dependent for negative operands (e.g. if i==0, the result could be either -1 or n-1)
+
+
+        if (!closed && (i == n-2))
+            // p3's point index is out of bounds; create an artificial point that extends p_(n-2) -> p_(n-1) (i.e. the last segment's direction)
+            // (note that p2's index should not be out of bounds, because in non-closed mode imax is reduced by 1)
+            p3 = points[n-1] + (points[n-1] - points[n-2]);
+        else
+            // standard wrap-around case
+            p3 = points[(i+2)%n];
+
 
         // Do the RNS computation (based on GPG4 "Nonuniform Splines")
         float l1 = (p2 - p1).Length(); // length of spline segment (i)..(i+1)
@@ -239 +275 @@
         CVector2D v2 = (s1 + s2).Normalized() * l1; // spline velocity at i+1
 
         // Compute standard cubic spline parameters
-        CVector2D a0 = p1*2 + p2*-2 + v1 + v2;
-        CVector2D a1 = p1*-3 + p2*3 + v1*-2 + v2*-1;
-        CVector2D a2 = v1;
-        CVector2D a3 = p1;
+        a0 = p1*2 + p2*-2 + v1 + v2;
+        a1 = p1*-3 + p2*3 + v1*-2 + v2*-1;
+        a2 = v1;
+        a3 = p1;
+
+        // Interpolate at regular points across the interval
+        for (int sample = 0; sample < segmentSamples; sample++)
+            newPoints.push_back(EvaluateSpline(sample/fSegmentSamples, a0, a1, a2, a3, offset));
 
-        // Interpolate at various points
-        newPoints.push_back(EvaluateSpline(0.f, a0, a1, a2, a3, offset));
-        newPoints.push_back(EvaluateSpline(1.f/4.f, a0, a1, a2, a3, offset));
-        newPoints.push_back(EvaluateSpline(2.f/4.f, a0, a1, a2, a3, offset));
-        newPoints.push_back(EvaluateSpline(3.f/4.f, a0, a1, a2, a3, offset));
     }
 
+    if (!closed)
+        // if the path is open, we should take care to include the last control point
+        // NOTE: we can't just do push_back(points[n-1]) here because that ignores the offset
+        newPoints.push_back(EvaluateSpline(1.f, a0, a1, a2, a3, offset));
+
     points.swap(newPoints);
 }
+
+void SimRender::ConstructDashedLine(const std::vector<CVector2D>& keyPoints, SDashedLine& dashedLineOut, const float dashLength, const float blankLength)
+{
+    // sanity checks
+    if (dashLength <= 0)
+        return;
+
+    if (blankLength <= 0)
+        return;
+
+    if (keyPoints.size() < 2)
+        return;
+
+    dashedLineOut.m_Points.clear();
+    dashedLineOut.m_StartIndices.clear();
+
+    // walk the line, counting the total length so far at each node point. When the length exceeds dashLength, cut the last segment at the
+    // required length and continue for blankLength along the line to start a new dash segment.
+
+    // TODO: we should probably extend this function to also allow for closed lines. I was thinking of slightly scaling the dash/blank length
+    // so that it fits the length of the curve, but that requires knowing the length of the curve upfront which is sort of expensive to compute
+    // (O(n) and lots of square roots).
+
+    bool buildingDash = true; // true if we're building a dash, false if a blank
+    float curDashLength = 0; // builds up the current dash/blank's length as we walk through the line nodes
+    CVector2D dashLastPoint = keyPoints[0]; // last point of the current dash/blank being built.
+
+    // register the first starting node of the first dash
+    dashedLineOut.m_Points.push_back(keyPoints[0]);
+    dashedLineOut.m_StartIndices.push_back(0);
+
+    // index of the next key point on the path. Must always point to a node that is further along the path than dashLastPoint, so we can
+    // properly take a direction vector along the path.
+    size_t i = 0;
+
+    while(i < keyPoints.size() - 1)
+    {
+        // get length of this segment
+        CVector2D segmentVector = keyPoints[i + 1] - dashLastPoint; // vector from our current point along the path to nextNode
+        float segmentLength = segmentVector.Length();
+
+        float targetLength = (buildingDash ? dashLength : blankLength);
+        if (curDashLength + segmentLength > targetLength)
+        {
+            // segment is longer than the dash length we still have to go, so we'll need to cut it; create a cut point along the segment
+            // line that is of just the required length to complete the dash, then make it the base point for the next dash/blank.
+            float cutLength = targetLength - curDashLength;
+            CVector2D cutPoint = dashLastPoint + (segmentVector.Normalized() * cutLength);
+
+            // start a new dash or blank in the next iteration
+            curDashLength = 0;
+            buildingDash = !buildingDash; // flip from dash to blank and vice-versa
+            dashLastPoint = cutPoint;
+
+            // don't increment i, we haven't fully traversed this segment yet so we still need to use the same point to take the
+            // direction vector with in the next iteration
+
+            // this cut point is either the end of the current dash or the beginning of a new dash; either way, we're gonna need it
+            // in the points array.
+            dashedLineOut.m_Points.push_back(cutPoint);
+
+            if (buildingDash)
+            {
+                // if we're gonna be building a new dash, then cutPoint is now the base point of that new dash, so let's register its
+                // index as a start index of a dash.
+                dashedLineOut.m_StartIndices.push_back(dashedLineOut.m_Points.size() - 1);
+            }
+
+        }
+        else
+        {
+            // the segment from lastDashPoint to keyPoints[i+1] doesn't suffice to complete the dash, so we need to add keyPoints[i+1]
+            // to this dash's points and continue from there
+
+            if (buildingDash)
+                // still building the dash, add it to the output (we don't need to store the blanks)
+                dashedLineOut.m_Points.push_back(keyPoints[i+1]);
+
+            curDashLength += segmentLength;
+            dashLastPoint = keyPoints[i+1];
+            i++;
+
+        }
+
+    }
+
+}

source/simulation2/helpers/Render.h

@@ -23 +23 @@
  * Helper functions related to rendering
  */
 
+#include "maths/Vector2D.h"
+
 class CSimContext;
-class CVector2D;
 struct SOverlayLine;
 
+
+
+struct SDashedLine
+{
+    std::vector<CVector2D> m_Points; ///< Packed array of consecutive dashes' points. Use m_StartIndices to navigate it.
+
+    /**
+     * Start indices in m_Points of each dash. Dash n starts at point m_StartIndices[n] and ends at the point with index 
+     * m_StartIndices[n+1] - 1, or at the end of the m_Points vector. Use the GetEndIndex(n) convenience method to abstract away the
+     * difference and get the (exclusive) end index of dash n.
+     */
+    std::vector<size_t> m_StartIndices;
+
+    /// Returns the (exclusive) end point index (i.e. index within m_Points) of dash n.
+    size_t GetEndIndex(size_t i)
+    {
+        // for the last dash, there is no next starting index, so we need to use the end index of the m_Points array instead
+        return (i < m_StartIndices.size() - 1 ? m_StartIndices[i+1] : m_Points.size());
+    }
+};
+
 namespace SimRender
 {
 
@@ -68 +90 @@
  * the direction of the curve.
  * If @p closed then the points are treated as a closed path (the last is connected
  * to the first).
+ * @param segmentSamples Amount of intermediate points to sample between every two control points.
+ */
+void InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples = 4);
+
+/**
+ * Creates a dashed line from the line specified by @points so that each dash is of length
+ * @p dashLength, and each blank inbetween is of length @p blankLength. The dashed line returned as a list of smaller lines
+ * in @p dashedLineOut.
+ *
+ * @param dashLength Length of a single dash. Must be strictly positive.
+ * @param blankLength Length of a single blank between dashes. Must be strictly positive.
  */
-void InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset);
+void ConstructDashedLine(const std::vector<CVector2D>& linePoints, SDashedLine& dashedLineOut, const float dashLength, const float blankLength);
 
 } // namespace
 

source/simulation2/scripting/EngineScriptConversions.cpp

@@ -29 +29 @@
 #include "simulation2/helpers/Grid.h"
 #include "simulation2/system/IComponent.h"
 #include "simulation2/system/ParamNode.h"
+#include "simulation2/components/ICmpRallyPoint.h"
 
 #define FAIL(msg) STMT(JS_ReportError(cx, msg); return false)
 
@@ -210 +211 @@
     return OBJECT_TO_JSVAL(obj);
 }
 
+// rally point conversion; a RallyPointPosition is merely a simple CFixedVector2D with a custom name so that we
+// can create this convertor for it. This is the same thing as the CFixedVector2D conversion, except that it
+// renames the y component to z in javascript to prevent breaking any code that relies on it (and vice-versa for
+// FromJSVal below)
+template<> jsval ScriptInterface::ToJSVal<RallyPointPosition>(JSContext* cx, const RallyPointPosition& val)
+{
+    JSObject* obj = JS_NewObject(cx, NULL, NULL, NULL);
+    if (!obj)
+        return JSVAL_VOID;
+
+    jsval x = ToJSVal(cx, val.X);
+    jsval z = ToJSVal(cx, val.Y);
+
+    JS_SetProperty(cx, obj, "x", &x);
+    JS_SetProperty(cx, obj, "z", &z); // rename "y" to "z" for JavaScript
+
+    return OBJECT_TO_JSVAL(obj);
+}
+
+template<> bool ScriptInterface::FromJSVal<RallyPointPosition>(JSContext* cx, jsval v, RallyPointPosition& out)
+{
+    if (!JSVAL_IS_OBJECT(v))
+        return false; // TODO: report type error
+    JSObject* obj = JSVAL_TO_OBJECT(v);
+
+    jsval p;
+
+    if (!JS_GetProperty(cx, obj, "x", &p)) return false; // TODO: report type errors
+    if (!FromJSVal(cx, p, out.X)) return false;
+
+    if (!JS_GetProperty(cx, obj, "z", &p)) return false; // rename "z" to "y" from javascript
+    if (!FromJSVal(cx, p, out.Y)) return false;
+
+    return true;
+}
+
 template<> jsval ScriptInterface::ToJSVal<Grid<u16> >(JSContext* cx, const Grid<u16>& val)
 {
     JSObject* obj = JS_NewObject(cx, NULL, NULL, NULL);