Ticket #13: diffFormation-13-03-2011.patch

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

@@ -1062 +1062 @@
 // Performs the specified formation
 function performFormation(entity, formationName)
 {
-    submitChatDirectly("FORMATIONS are not implemented yet.");
-
     if (entity)
     {
         console.write(formationName);
+
+        var selection = g_Selection.toList();
+        Engine.PostNetworkCommand({
+            "type": "formation",
+            "entities": selection,
+            "name": formationName
+        });
+
     }
 }
 

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

@@ -236 +236 @@
         
         var cmpGarrisonHolder = Engine.QueryInterface(cmd.garrisonHolder, IID_GarrisonHolder);
         cmpGarrisonHolder.UnloadAll();
+        break;      
+
+    case "formation":
+        var cmpUnitAI = GetFormationUnitAI(cmd.entities);
+        if(!cmpUnitAI)
+            break;
+        var cmpFormation = Engine.QueryInterface(cmpUnitAI.entity, IID_Formation);
+        if (!cmpFormation)
+            break;
+        cmpFormation.LoadFormation(cmd.name);
+        cmpFormation.MoveMembersIntoFormation(true);
         break;
         
     default:

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

@@ -68 +68 @@
                         "<value>Infantry</value>" +
                         "<value>Cavalry</value>" +
                         "<value>Ranged</value>" +
+                        "<value>Melee</value>" +
                         "<value>Mechanical</value>" +
                         "<value>Ship</value>" +
                         "<value>Siege</value>" +

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

@@ -9 +9 @@
 {
     this.members = []; // entity IDs currently belonging to this formation
     this.columnar = false; // whether we're travelling in column (vs box) formation
+    this.formationName = "default";
 };
 
 Formation.prototype.GetMemberCount = function()
@@ -114 +115 @@
     var active = [];
     var positions = [];
 
-    var types = { "Unknown": 0 }; // TODO: make this work so we put ranged behind infantry etc
-
     for each (var ent in this.members)
     {
         var cmpPosition = Engine.QueryInterface(ent, IID_Position);
@@ -124 +123 @@
 
         active.push(ent);
         positions.push(cmpPosition.GetPosition());
-
-        types["Unknown"] += 1; // TODO
     }
 
     // Work out whether this should be a column or box formation
@@ -133 +130 @@
     var walkingDistance = cmpUnitAI.ComputeWalkingDistance();
     this.columnar = (walkingDistance > g_ColumnDistanceThreshold);
 
-    var offsets = this.ComputeFormationOffsets(types, this.columnar);
+    var offsets = this.ComputeFormationOffsets(active, this.columnar);
 
     var avgpos = this.ComputeAveragePosition(positions);
     var avgoffset = this.ComputeAveragePosition(offsets);
@@ -143 +140 @@
     if (moveCenter || !cmpPosition.IsInWorld())
         cmpPosition.JumpTo(avgpos.x, avgpos.z);
 
-    // TODO: assign to minimise worst-case distances or whatever
-
-    for (var i = 0; i < active.length; ++i)
+    for (var i = 0; i < offsets.length; ++i)
     {
         var offset = offsets[i];
 
-        var cmpUnitAI = Engine.QueryInterface(active[i], IID_UnitAI);
+        var cmpUnitAI = Engine.QueryInterface(offset.ent, IID_UnitAI);
         cmpUnitAI.ReplaceOrder("FormationWalk", {
             "target": this.entity,
             "x": offset.x - avgoffset.x,
@@ -177 +172 @@
     cmpPosition.JumpTo(avgpos.x, avgpos.z);
 };
 
-Formation.prototype.ComputeFormationOffsets = function(types, columnar)
+Formation.prototype.ComputeFormationOffsets = function(active, columnar)
 {
     var separation = 4; // TODO: don't hardcode this
 
-    var count = types["Unknown"];
+    var types = {   "Hero" : [],
+                                    "Melee" : [],
+                                    "Ranged" : [],
+                                    "Support" : [],
+                                    "Unknown": []
+                                    }; // TODO: make this work so we put ranged behind infantry etc
 
+    for each (var ent in active)
+    {
+        var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
+        var classes = cmpIdentity.GetClassesList();
+        var done = false;
+        for each (var cla in classes)
+        {
+            if(cla in types)
+            {
+                types[cla].push(ent);
+                done = true;
+                break;
+            }
+        }
+        if (!done)
+        {
+            types["Unknown"].push(ent);
+        }
+    }
+
+    var count = active.length;
+
+    var shape = undefined;
+    var ordering = "default";
+
+    var offsets = [];
+
     // Choose a sensible width for the basic default formation
     var cols;
-    if (columnar)
+    if (columnar || this.formationName == "Formation2") // Column
     {
         // Have at most 3 files
         if (count <= 3)
             cols = count;
         else
             cols = 3;
+        shape = "square";
     }
-    else
+    else if (this.formationName == "default" || this.formationName == "Formation9") // Square
     {
         // Try to have at least 5 files (so batch training gives a single line),
         // and at most 8
         if (count <= 5)
             cols = count;
-        if (count <= 10)
+        else if (count <= 10)
             cols = 5;
         else if (count <= 16)
             cols = Math.ceil(count / 2);
         else
             cols = 8;
+        shape = "square";
     }
+    else if (this.formationName == "Formation3") // Line
+    {
+        if (count <= 3)
+            cols = count;
+        else if(count < 30)
+            cols = Math.ceil(count/2);
+        else
+            cols = Math.ceil(count/3);
+        shape = "square";
+    }
+    else if (this.formationName == "Formation4") // OpenColumn
+    {
+        cols = 2
+        shape = "opensquare";
+    }
+    else if (this.formationName == "Formation5") // OpenSquare
+    {
+        if (count <= 5)
+            cols = 3;
+        else if (count <= 11)
+            cols = 4;
+        else if (count <= 18)
+            cols = 5;
+        else
+            cols = 6;
+        shape = "opensquare";
+    }
+    else if (this.formationName == "Formation0") // Circle
+    {
+        var depth;
+        if (count < 5 || count > 36)
+        {
+            this.LoadFormation("default");
+            return offsets;
+        }
+        depth = Math.ceil(count / 12);
 
-    var ranks = Math.ceil(count / cols);
+        var left = count;
+        var radius = Math.min(left,12) * separation / (2 * Math.PI);
+        for (var c = 0; c < depth; ++c)
+        {
+            var ctodo = Math.min(left,12);
+            var cradius = radius - c * separation / 2;
+            var delta = 2 * Math.PI / ctodo;
+            for (var alpha = 0; ctodo; alpha+=delta)
+            {
+                var x = Math.cos(alpha) * cradius;
+                var z = Math.sin(alpha) * cradius;
+                offsets.push({"x": x, "z": z});
+                ctodo--;
+                left--;
+            }
+        }
+    }
+    else if (this.formationName == "Formation1") // Box
+    {
+        var root;
+        if (count > 49)
+        {
+            this.LoadFormation("default");
+            return offsets;
+        }
+        if (count <= 9)
+            root = 3;
+        else if (count > 9 && count <= 25)
+            root = 5;
+        else if (count > 25 && count <= 49)
+            root = 7;
 
-    var offsets = [];
+        var left = count;
+        var meleeleft = types["Melee"].length;
+        for (var sq = Math.floor(root/2); sq >= 0; --sq)
+        {
+            var width = sq * 2 + 1;
+            var stodo;
+            if (sq == 0)
+            {
+                stodo = left;
+            }
+            else
+            {
+                if (meleeleft >= width*width - (width-2)*(width-2)) // form a complete box
+                {
+                    stodo = width*width - (width-2)*(width-2);
+                    meleeleft -= stodo;
+                }
+                else    // compact
+                    stodo = Math.max(0,left - (width-2)*(width-2));
+            }
 
-    var left = count;
-    for (var r = 0; r < ranks; ++r)
+            for (var r = -sq; r <= sq && stodo; ++r)
+            {
+                for (var c = -sq; c <= sq && stodo; ++c)
+                {
+                    if (Math.abs(r) == sq || Math.abs(c) == sq)
+                    {
+                        var x = c * separation;
+                        var z = -r * separation;
+                        offsets.push({"x": x, "z": z});
+                        stodo--;
+                        left--;
+                    }
+                }
+            }
+        }
+    }
+    else if (this.formationName == "Formation7") // Skirmish
     {
-        var n = Math.min(left, cols);
-        for (var c = 0; c < n; ++c)
+        if (count < 9 || count > 25)
         {
-            var x = ((n-1)/2 - c) * separation;
-            var z = -r * separation;
-            offsets.push({"x": x, "z": z});
+            this.LoadFormation("default");
+            return offsets;
         }
-        left -= n;
+        cols = Math.ceil(count/2);
+        shape = "opensquare";
     }
+    else if (this.formationName == "Formation8") // Wedge
+    {
+        var depth;
+        if (count > 49)
+        {
+            this.LoadFormation("default");
+            return offsets;
+        }
+        if (count <= 9)
+            depth = 3;
+        else if (count > 9 && count <= 16)
+            depth = 4;
+        else if (count > 16 && count <= 25)
+            depth = 5;
+        else if (count > 25 && count <= 49)
+            depth = 7;
 
+        var left = count;
+        var width = 2 * depth - 1;
+        for (var p = 0; p < depth && left; ++p)
+        {
+            for (var r = p; r < depth && left; ++r)
+            {
+                var c1 = depth - r + p;
+                var c2 = depth + r - p;
+
+                if (left)
+                {
+                        var x = c1 * separation;
+                        var z = -r * separation;
+                        offsets.push({"x": x, "z": z});
+                        left--;
+                }
+                if (left && c1 != c2)
+                {
+                        var x = c2 * separation;
+                        var z = -r * separation;
+                        offsets.push({"x": x, "z": z});
+                        left--;
+                }
+            }
+        }
+    }
+
+    if (shape == "square")
+    {
+        var ranks = Math.ceil(count / cols);
+
+        var left = count;
+        for (var r = 0; r < ranks; ++r)
+        {
+            var n = Math.min(left, cols);
+            for (var c = 0; c < n; ++c)
+            {
+                var x = ((n-1)/2 - c) * separation;
+                var z = -r * separation;
+                offsets.push({"x": x, "z": z});
+            }
+            left -= n;
+        }
+    }
+    else if (shape == "opensquare")
+    {
+        var left = count;
+        for (var r = 0; left; ++r)
+        {
+            var n = Math.min(left, cols - (r&1?1:0));
+            for (var c = 0; c < 2*n; c+=2)
+            {
+                var x = (- c - (r&1)) * separation;
+                var z = -r * separation;
+                offsets.push({"x": x, "z": z});
+            }
+            left -= n;
+        }
+    }
+
+    // TODO: assign to minimise worst-case distances or whatever
+    if (ordering == "default")
+    {
+        for each (var offset in offsets)
+        {
+            var ent = undefined;
+            for (var t in types)
+            {
+                if (types[t].length)
+                {
+                    ent = types[t].pop();
+                    offset.ent = ent
+                    break;
+                }
+            }
+        }
+    }
+
     return offsets;
 };
 
@@ -286 +508 @@
         this.RemoveMembers([msg.entity]);
 };
 
+Formation.prototype.LoadFormation = function(formationName)
+{
+    this.formationName = formationName;
+}
+
 Engine.RegisterComponentType(IID_Formation, "Formation", Formation);

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

@@ -2 +2 @@
 <Entity parent="template_unit_infantry">
   <Identity>
     <GenericName>Ranged</GenericName>
+    <Classes datatype="tokens">Ranged Infantry</Classes>
   </Identity>
   <Health>
     <Max>90</Max>

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

@@ -2 +2 @@
 <Entity parent="template_unit_infantry">
   <Identity>
     <GenericName>Melee Infantry</GenericName>
+    <Classes datatype="tokens">Melee Infantry</Classes>
   </Identity>
   <Health>
     <Max>100</Max>