Ticket #3280: formation_pathfinding.diff

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

@@ -548 +548 @@
         xMin = Math.min(xMin, offset.x);
         yMin = Math.min(yMin, offset.y);
     }
-    this.width = xMax - xMin;
-    this.depth = yMax - yMin;
+    this.width = xMax - xMin + 4;// TODO take formation width + passClass clearance
+    this.depth = yMax - yMin + 4;
+
+    // set an obstruction size to calculate collisions
+    var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
+    if (cmpObstruction)
+        cmpObstruction.SetSize(this.depth, this.width);
+    var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    if (cmpUnitMotion)
+        cmpUnitMotion.SetAllowedDeviation(this.width);
 };
 
 Formation.prototype.MoveToMembersCenter = function()

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

@@ +1 @@
+function UnitMotionFormation() {}
+
+UnitMotionFormation.prototype.Schema =
+    "<empty/>";
+
+UnitMotionFormation.prototype.Init = function()
+{
+    this.goal = null;
+    this.pathTicket = 0;
+    this.passClass = 0;
+    this.path = [];
+    this.speed = 1;
+    this.pathIdx = -1;
+    this.state = "IDLE";
+    this.allowedDeviation = 8;
+
+    var cmpPathfinder = Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder);
+    this.passClass = cmpPathfinder.GetPassabilityClass("default");
+};
+
+UnitMotionFormation.prototype.SetPassabilityClassName = function(name)
+{
+    var cmpPathfinder = Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder);
+    this.passClass = cmpPathfinder.GetPassabilityClass(name);
+};
+
+// Ignore, unit radius is not important anymore, only the passability class is
+UnitMotionFormation.prototype.SetUnitRadius = function() {};
+
+UnitMotionFormation.prototype.SetAllowedDeviation = function(allowedDeviation)
+{
+    this.allowedDeviation = allowedDeviation;
+};
+
+UnitMotionFormation.prototype.IsMoving = function()
+{
+    return this.pathIdx >= 0;
+};
+UnitMotionFormation.prototype.SetSpeed = function(speed)
+{
+    this.speed = speed;
+};
+
+UnitMotionFormation.prototype.MoveToPointRange = function(x, z, minRange, maxRange)
+{
+    this.goal = {
+        "type": 0,
+        "x": x, // target x
+        "z": z, // target z
+        "u": {"x": 1, "y": 0}, // first unit axis
+        "v": {"x": 0, "y": 1}, // second unit axis
+        "hw": maxRange, // for a circle, hw is range
+        "hh": maxRange,
+        "maxdist": 0 // maxdist between waypoints, 0 -> unlimited
+    }
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return false;
+
+    var pos = cmpPosition.GetPosition2D();
+
+    var cmpPathfinder = Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder);
+    this.pathTicket = cmpPathfinder.ComputePathAsync(pos.x, pos.y, this.goal, this.passClass, this.entity);
+
+    this.state = "PATH_REQUESTED";
+    return true;
+};
+
+UnitMotionFormation.prototype.OnPathResult = function(msg)
+{
+    if (msg.ticket != this.pathTicket)
+        return;
+
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return;
+
+    // TODO path generalisation
+    this.path = msg.path;
+    this.pathIdx = this.path.length -1;
+    // add the current position for reference
+    var pos = cmpPosition.GetPosition2D();
+    this.path.push({"x" : pos.x, "y": pos.y});
+
+    var direction = Vector2D.clone(this.path[this.pathIdx]).sub(pos);
+    cmpPosition.TurnTo(Math.atan2(direction.x, direction.y));
+
+    this.state = "FOLLOW_LINE";
+    Engine.PostMessage(this.entity, MT_MotionChanged, { "starting": true, "error": false });
+};
+
+UnitMotionFormation.prototype.OnUpdate = function(msg)
+{
+    if (!this.IsMoving())
+        return;
+    if (this.state == "FOLLOW_LINE")
+        this.FollowLine(msg.turnLength);
+    else if (this.state == "TAKE_TURN")
+        this.TakeTurn(msg.turnLength);
+};
+
+UnitMotionFormation.prototype.FollowLine = function(turnLength)
+{
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return;
+
+    var pos = cmpPosition.GetPosition2D();
+
+    // project current position to original path
+    var target = this.path[this.pathIdx];
+    var source = this.path[this.pathIdx + 1];
+    var direction = Vector2D.clone(target).sub(source);
+    var posVec = Vector2D.clone(pos).sub(source);
+    var pathPosition = Vector2D.clone(direction).mult(posVec.dot(direction) / direction.lengthSquared());
+
+    // Get the distance on the original path
+    var pathToWalk = Vector2D.clone(direction).sub(pathPosition);
+    var distanceToTarget = pathToWalk.length();
+    var distanceToWalk = this.speed * turnLength;
+
+    if (distanceToTarget < distanceToWalk) // just walk straight on, and start turning
+    {
+        pos.add(pathToWalk);
+        cmpPosition.MoveTo(pos.x, pos.y);
+        // if this is the last target, stop moving
+        if (this.pathIdx)
+        {
+            // else, take a turn
+            var usedTime = distanceToTarget / this.speed;
+            this.state = "TAKE_TURN";
+            this.TakeTurn(turnLength - usedTime);
+        }
+        else
+        {
+            this.pathIdx--;
+            Engine.PostMessage(this.entity, MT_MotionChanged, { "starting": false, "error": false });
+            this.state = "IDLE";
+        }
+        return;
+    }
+
+    var currentDeviation = posVec.distanceTo(pathPosition);
+    if (this.pathIdx == 0 && distanceToTarget <= currentDeviation)
+    {
+        var pathToTarget = Vector2D.clone(target).sub(pos).normalize().mult(distanceToWalk);
+        pos.add(pathToTarget);
+        cmpPosition.MoveTo(pos.x, pos.y);
+        return;
+    }
+
+    // Find the next position
+    // scale the path to walk to include the walkable distance
+    var centerPathToWalk = Vector2D.clone(pathToWalk).mult(distanceToWalk / distanceToTarget);
+    // expand the rotation matrix for the 45deg rotations
+    var leftPathToWalk = new Vector2D(centerPathToWalk.x - centerPathToWalk.y, centerPathToWalk.x + centerPathToWalk.y);
+    var rightPathToWalk = new Vector2D(centerPathToWalk.x + centerPathToWalk.y, -centerPathToWalk.x + centerPathToWalk.y);
+    
+    var newCenterPosVec = Vector2D.clone(posVec).add(centerPathToWalk);
+    var newLeftPosVec = Vector2D.clone(posVec).add(leftPathToWalk);
+    var newRightPosVec = Vector2D.clone(posVec).add(rightPathToWalk);
+
+    // project the center to the original path
+    var centerPathPosition = Vector2D.clone(direction).mult(newCenterPosVec.dot(direction) / direction.lengthSquared());
+
+    var allowLeft = newLeftPosVec.distanceToSquared(centerPathPosition) < this.allowedDeviation * this.allowedDeviation;
+    var allowRight = newRightPosVec.distanceToSquared(centerPathPosition) < this.allowedDeviation * this.allowedDeviation;
+
+    // compare the obstructions
+    var cmpPathfinder = Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder);
+    var centerObstructedTiles = cmpPathfinder.GetObstructedTiles(centerPathToWalk, this.entity, this.passClass);
+    var leftObstructedTiles = Infinity;
+    var rightObstructedTiles = Infinity;
+    if (allowLeft)
+        leftObstructedTiles = cmpPathfinder.GetObstructedTiles(leftPathToWalk, this.entity, this.passClass);
+    if (allowRight)
+        rightObstructedTiles = cmpPathfinder.GetObstructedTiles(rightPathToWalk, this.entity, this.passClass);
+
+    // choose the best of the three positions
+    var min = Math.min(centerObstructedTiles, leftObstructedTiles, rightObstructedTiles);
+    if (min == centerObstructedTiles)
+        pos.add(centerPathToWalk);
+    else if (min == leftObstructedTiles)
+        pos.add(leftPathToWalk);
+    else if (min == rightObstructedTiles)
+        pos.add(rightPathToWalk);
+
+    cmpPosition.MoveTo(pos.x, pos.y);
+};
+
+UnitMotionFormation.prototype.TakeTurn = function(turnLength)
+{
+    // TODO take time to make a nice turn
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return;
+    var newSource = Vector2D.clone(this.path[this.pathIdx]);
+    var newTarget = Vector2D.clone(this.path[--this.pathIdx]);
+    var newDirection = Vector2D.clone(newTarget).sub(newSource);
+
+    cmpPosition.TurnTo(Math.atan2(newDirection.x, newDirection.y));
+    this.state = "FOLLOW_LINE";
+    this.FollowLine(turnLength);
+};
+
+Engine.RegisterComponentType(IID_UnitMotion, "UnitMotionFormation", UnitMotionFormation);

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

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity>
-  <!--
+  <!---->
   <VisualActor>
     <Actor>props/special/common/waypoint_flag.xml</Actor>
+    <SilhouetteDisplay>false</SilhouetteDisplay>
+    <SilhouetteOccluder>true</SilhouetteOccluder>
+    <VisibleInAtlasOnly>false</VisibleInAtlasOnly>
   </VisualActor>
-  -->
+  <!---->
   <Formation>
     <RequiredMemberCount>1</RequiredMemberCount>
     <DisabledTooltip></DisabledTooltip>
@@ -21 +24 @@
   <FormationAttack>
     <CanAttackAsFormation>false</CanAttackAsFormation>
   </FormationAttack>
+  <Obstruction>
+    <Active>false</Active>
+    <BlockMovement>false</BlockMovement>
+    <BlockPathfinding>false</BlockPathfinding>
+    <BlockFoundation>false</BlockFoundation>
+    <BlockConstruction>false</BlockConstruction>
+    <DisableBlockMovement>true</DisableBlockMovement>
+    <DisableBlockPathfinding>true</DisableBlockPathfinding>
+    <Static width="30.0" depth="30.0"/>
+  </Obstruction>
   <Ownership/>
   <Position>
     <Altitude>0</Altitude>
@@ -35 +48 @@
     <FormationController>true</FormationController>
     <CanGuard>true</CanGuard>
   </UnitAI>
-  <UnitMotion>
-    <FormationController>true</FormationController>
-    <WalkSpeed>1.0</WalkSpeed>
-    <PassabilityClass>siege-large</PassabilityClass>
-  </UnitMotion>
+  <UnitMotionFormation/>
   <Trader>
     <GainMultiplier>1.0</GainMultiplier>
   </Trader>

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

@@ -37 +37 @@
   <Identity>
     <GenericName>Unit</GenericName>
     <Classes datatype="tokens">Unit ConquestCritical</Classes>
-        <Formations datatype="tokens">
-            formations/null
-        </Formations>
+    <Formations datatype="tokens">
+      formations/null
+      formations/box
+      formations/column_closed
+      formations/line_closed
+      formations/column_open
+      formations/line_open
+      formations/flank
+      formations/battle_line 
+    </Formations>
   </Identity>
   <Looter/>
   <Minimap>

source/scriptinterface/ScriptConversions.cpp

@@ -20 +20 @@
 #include "ScriptInterface.h"
 
 #include "graphics/Entity.h"
+#include "simulation2/helpers/PathGoal.h" // to convert path goals
 #include "ps/utf16string.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
@@ -205 +206 @@
     JS::RootedValue position(cx);
     JS::RootedValue rotation(cx);
 
-    // TODO: Report type errors
+    // TODO: Report type errors when loading attributes
     if (!JS_GetProperty(cx, obj, "player", &player) || !FromJSVal(cx, player, out.playerID))
         FAIL("Failed to read Entity.player property");
     if (!JS_GetProperty(cx, obj, "templateName", &templateName) || !FromJSVal(cx, templateName, out.templateName))
@@ -220 +221 @@
     return true;
 }
 
+// TODO this doesn't work (probably always uses POINT)
+template<> bool ScriptInterface::FromJSVal<PathGoal::Type>(JSContext* cx, JS::HandleValue v, PathGoal::Type& out)
+{
+    std::string strVal;
+    ScriptInterface::FromJSVal(cx, v, static_cast<std::string&>(strVal));
+    if (strVal == "CIRCLE")
+        out = PathGoal::CIRCLE;
+    if (strVal == "INVERTED_CIRCLE")
+        out = PathGoal::INVERTED_CIRCLE;
+    else if (strVal == "SQUARE")
+        out = PathGoal::SQUARE;
+    else if (strVal == "INVERTED_SQUARE")
+        out = PathGoal::INVERTED_SQUARE;
+    else
+        out = PathGoal::POINT;
+    return true;
+}
+
+template<> bool ScriptInterface::FromJSVal<PathGoal>(JSContext* cx, JS::HandleValue val, PathGoal& out)
+{
+    JSAutoRequest rq(cx);
+    if (!val.isObject())
+        FAIL("Argument must be an object");
+
+    JS::RootedObject obj(cx, &val.toObject());
+    JS::RootedValue type(cx);
+    JS::RootedValue x(cx);
+    JS::RootedValue z(cx);
+    JS::RootedValue u(cx);
+    JS::RootedValue v(cx);
+    JS::RootedValue hw(cx);
+    JS::RootedValue hh(cx);
+
+    
+    // TODO: Report type errors
+    if (!JS_GetProperty(cx, obj, "type", &type) || !FromJSVal(cx, type, out.type))
+        FAIL("Failed to read goal.type property");
+    if (!JS_GetProperty(cx, obj, "x", &x) || !FromJSVal(cx, x, out.x))
+        FAIL("Failed to read goal.x property");
+    if (!JS_GetProperty(cx, obj, "z", &z) || !FromJSVal(cx, z, out.z))
+        FAIL("Failed to read goal.z property");
+    if (!JS_GetProperty(cx, obj, "u", &u) || !FromJSVal(cx, u, out.u))
+        FAIL("Failed to read goal.u property");
+    if (!JS_GetProperty(cx, obj, "v", &v) || !FromJSVal(cx, v, out.v))
+        FAIL("Failed to read goal.v property");
+    if (!JS_GetProperty(cx, obj, "hw", &hw) || !FromJSVal(cx, hw, out.hw))
+        FAIL("Failed to read goal.hw property");
+    if (!JS_GetProperty(cx, obj, "hh", &hh) || !FromJSVal(cx, hh, out.hh))
+        FAIL("Failed to read goal.hh property");
+    return true;
+}
+
 ////////////////////////////////////////////////////////////////
 // Primitive types:
 

source/simulation2/components/CCmpObstruction.cpp

@@ -493 +493 @@
             return CFixedVector2D(m_Size0 / 2, m_Size1 / 2).Length();
     }
 
+    virtual void SetSize(entity_pos_t width, entity_pos_t height)
+    {
+        // require this to be inactive, so we don't have to force grid updates
+        ENSURE(m_Active == false);
+        m_Size0 = width;
+        m_Size0 = height;
+    }
+
     virtual bool IsControlPersistent()
     {
         return m_ControlPersist;

source/simulation2/components/CCmpPathfinder.cpp

@@ -188 +188 @@
 }
 
 
-pass_class_t CCmpPathfinder::GetPassabilityClass(const std::string& name)
+pass_class_t CCmpPathfinder::GetPassabilityClass(std::string name)
 {
     if (m_PassClassMasks.find(name) == m_PassClassMasks.end())
     {
@@ -611 +611 @@
 
 // Async path requests:
 
-u32 CCmpPathfinder::ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const PathGoal& goal, pass_class_t passClass, entity_id_t notify)
+u32 CCmpPathfinder::ComputePathAsync(entity_pos_t x0, entity_pos_t z0, PathGoal goal, pass_class_t passClass, entity_id_t notify)
 {
     AsyncLongPathRequest req = { m_NextAsyncTicket++, x0, z0, goal, passClass, notify };
     m_AsyncLongPathRequests.push_back(req);
@@ -807 +807 @@
     return ICmpObstruction::FOUNDATION_CHECK_SUCCESS;
 }
 
+u32 CCmpPathfinder::GetObstructedTiles(CFixedVector2D offset, entity_id_t id, pass_class_t passClass)
+{
+    // Test against terrain:
+    ICmpObstructionManager::ObstructionSquare square;
+    CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), id);
+    if (!cmpObstruction || !cmpObstruction->GetObstructionSquare(square))
+        return 0;
+
+    square.x += offset.X;
+    square.z += offset.Y;
+
+    UpdateGrid();
+
+    entity_pos_t expand;
+    const PathfinderPassability* passability = GetPassabilityFromMask(passClass);
+    if (passability && passability->m_HasClearance)
+        expand = passability->m_Clearance;
+
+    SimRasterize::Spans spans;
+    SimRasterize::RasterizeRectWithClearance(spans, square, expand, Pathfinding::NAVCELL_SIZE);
+    u32 obstructedTiles = 0;
+    for (SimRasterize::Span& span : spans)
+    {
+        i16 i0 = span.i0;
+        i16 i1 = span.i1;
+        i16 j = span.j;
+
+        // Fail if any span includes an impassable tile
+        for (i16 i = i0; i < i1; ++i)
+            if (i < 0 || i > m_Grid->m_W || j < 0 || j > m_Grid->m_H || !IS_PASSABLE(m_Grid->get(i, j), passClass))
+                ++obstructedTiles;
+    }
+
+    return obstructedTiles;
+}

source/simulation2/components/CCmpPathfinder_Common.h

@@ -139 +139 @@
 
     virtual void HandleMessage(const CMessage& msg, bool global);
 
-    virtual pass_class_t GetPassabilityClass(const std::string& name);
+    virtual pass_class_t GetPassabilityClass(std::string name);
 
     virtual std::map<std::string, pass_class_t> GetPassabilityClasses();
 
@@ -156 +156 @@
         m_LongPathfinder.ComputePath(x0, z0, goal, passClass, ret);
     }
 
-    virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const PathGoal& goal, pass_class_t passClass, entity_id_t notify);
+    virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, PathGoal goal, pass_class_t passClass, entity_id_t notify);
 
     virtual void ComputeShortPath(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t r, entity_pos_t range, const PathGoal& goal, pass_class_t passClass, WaypointPath& ret);
 
@@ -191 +191 @@
 
     virtual ICmpObstruction::EFoundationCheck CheckBuildingPlacement(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h, entity_id_t id, pass_class_t passClass, bool onlyCenterPoint);
 
+    virtual u32 GetObstructedTiles(CFixedVector2D offset, entity_id_t id, pass_class_t passClass);
+
     virtual void FinishAsyncRequests();
 
     void ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests);

source/simulation2/components/ICmpObstruction.cpp

@@ -47 +47 @@
 
 BEGIN_INTERFACE_WRAPPER(Obstruction)
 DEFINE_INTERFACE_METHOD_0("GetUnitRadius", entity_pos_t, ICmpObstruction, GetUnitRadius)
+DEFINE_INTERFACE_METHOD_2("SetSize", void, ICmpObstruction, SetSize, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_2("CheckFoundation", std::string, ICmpObstruction, CheckFoundation_wrapper, std::string, bool)
 DEFINE_INTERFACE_METHOD_0("CheckDuplicateFoundation", bool, ICmpObstruction, CheckDuplicateFoundation)
 DEFINE_INTERFACE_METHOD_2("GetEntityCollisions", std::vector<entity_id_t>, ICmpObstruction, GetEntityCollisions, bool, bool)

source/simulation2/components/ICmpObstruction.h

@@ -54 +54 @@
 
     virtual entity_pos_t GetSize() = 0;
 
+    /**
+     * Passively set the size of this obstruction
+     * This must only be used on inactive obstructions, as it won't update any grids
+     */
+    virtual void SetSize(entity_pos_t width, entity_pos_t height) = 0;
+
     virtual entity_pos_t GetUnitRadius() = 0;
 
     virtual bool IsControlPersistent() = 0;

source/simulation2/components/ICmpPathfinder.cpp

@@ -24 +24 @@
 BEGIN_INTERFACE_WRAPPER(Pathfinder)
 DEFINE_INTERFACE_METHOD_1("SetDebugOverlay", void, ICmpPathfinder, SetDebugOverlay, bool)
 DEFINE_INTERFACE_METHOD_1("SetHierDebugOverlay", void, ICmpPathfinder, SetHierDebugOverlay, bool)
+DEFINE_INTERFACE_METHOD_1("GetPassabilityClass", pass_class_t, ICmpPathfinder, GetPassabilityClass, std::string)
+DEFINE_INTERFACE_METHOD_3("GetObstructedTiles", u32, ICmpPathfinder, GetObstructedTiles, CFixedVector2D, entity_id_t, pass_class_t)
+DEFINE_INTERFACE_METHOD_5("ComputePathAsync", u32, ICmpPathfinder, ComputePathAsync, entity_pos_t, entity_pos_t, PathGoal, pass_class_t, entity_id_t)
 END_INTERFACE_WRAPPER(Pathfinder)

source/simulation2/components/ICmpPathfinder.h

@@ -59 +59 @@
      * Get the tag for a given passability class name.
      * Logs an error and returns something acceptable if the name is unrecognised.
      */
-    virtual pass_class_t GetPassabilityClass(const std::string& name) = 0;
+    virtual pass_class_t GetPassabilityClass(std::string name) = 0;
 
     virtual const Grid<u16>& GetPassabilityGrid() = 0;
 
@@ -87 +87 @@
      * Returns a unique non-zero number, which will match the 'ticket' in the result,
      * so callers can recognise each individual request they make.
      */
-    virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, const PathGoal& goal, pass_class_t passClass, entity_id_t notify) = 0;
+    virtual u32 ComputePathAsync(entity_pos_t x0, entity_pos_t z0, PathGoal goal, pass_class_t passClass, entity_id_t notify) = 0;
 
     /**
      * If the debug overlay is enabled, render the path that will computed by ComputePath.
@@ -143 +143 @@
      */
     virtual ICmpObstruction::EFoundationCheck CheckBuildingPlacement(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h, entity_id_t id, pass_class_t passClass, bool onlyCenterPoint) = 0;
 
+    /**
+     * Get the number of obstructed tiles that are under an obstruction of a
+     * certain entity. Allow an offset to easily test alternative positions.
+     */
+    virtual u32 GetObstructedTiles(CFixedVector2D offset, entity_id_t id, pass_class_t passClass) = 0;
 
     /**
      * Toggle the storage and rendering of debug info.

source/simulation2/scripting/EngineScriptConversions.cpp

@@ -27 +27 @@
 #include "ps/Shapes.h"
 #include "ps/utf16string.h"
 #include "simulation2/helpers/Grid.h"
+#include "simulation2/helpers/Pathfinding.h"
 #include "simulation2/system/IComponent.h"
 #include "simulation2/system/ParamNode.h"
 
@@ -247 +248 @@
     ret.setObject(*obj);
 }
 
+template<> void ScriptInterface::ToJSVal<Waypoint>(JSContext* cx, JS::MutableHandleValue ret, const Waypoint& val)
+{
+    JSAutoRequest rq(cx);
+
+    // apply the Vector2D prototype to the return value
+    ScriptInterface::CxPrivate* pCxPrivate = ScriptInterface::GetScriptInterfaceAndCBData(cx);
+    JS::RootedObject proto(cx, &pCxPrivate->pScriptInterface->GetCachedValue(ScriptInterface::CACHE_VECTOR2DPROTO).toObject());
+    JS::RootedObject obj(cx, JS_NewObject(cx, nullptr, proto, JS::NullPtr()));
+    if (!obj)
+    {
+        ret.setUndefined();
+        return;
+    }
+
+    JS::RootedValue x(cx);
+    JS::RootedValue y(cx);
+    ToJSVal(cx, &x, val.x);
+    ToJSVal(cx, &y, val.z);
+
+    JS_SetProperty(cx, obj, "x", x);
+    JS_SetProperty(cx, obj, "y", y);
+
+    ret.setObject(*obj);
+}
+
 template<> void ScriptInterface::ToJSVal<Grid<u8> >(JSContext* cx, JS::MutableHandleValue ret, const Grid<u8>& val)
 {
     JSAutoRequest rq(cx);
@@ -309 +335 @@
     }
     ret.setObject(*obj);
 }
+
+template<> void ScriptInterface::ToJSVal<WaypointPath>(JSContext* cx, JS::MutableHandleValue ret, const WaypointPath& val)
+{
+    JSAutoRequest rq(cx);
+    JS::RootedObject obj(cx, JS_NewArrayObject(cx, 0));
+    if (!obj)
+    {
+        ret.setUndefined();
+        return;
+    }
+    const std::vector<Waypoint>& waypointList = val.m_Waypoints;
+    for (size_t i = 0; i < waypointList.size(); ++i)
+    {
+        JS::RootedValue el(cx);
+        ScriptInterface::ToJSVal<Waypoint>(cx, &el, waypointList[i]);
+        JS_SetElement(cx, obj, i, el);
+    }
+    ret.setObject(*obj);
+}

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -385 +385 @@
 
 ////////////////////////////////
 
-JS::Value CMessagePathResult::ToJSVal(ScriptInterface& UNUSED(scriptInterface)) const
+JS::Value CMessagePathResult::ToJSVal(ScriptInterface& scriptInterface) const
 {
-    LOGWARNING("CMessagePathResult::ToJSVal not implemented");
-    return JS::UndefinedValue();
+    TOJSVAL_SETUP();
+    SET_MSG_PROPERTY(ticket);
+    SET_MSG_PROPERTY(path);
+    return JS::ObjectValue(*obj);
 }
 
 CMessage* CMessagePathResult::FromJSVal(ScriptInterface& UNUSED(scriptInterface), JS::HandleValue UNUSED(val))