Ticket #1724: collectiveBehavior-v3.patch

binaries/data/mods/public/simulation/templates/gaia/fauna_elephant.xml

@@ -11 +11 @@
   <Identity>
     <Civ>gaia</Civ>
     <Classes datatype="tokens">Elephant</Classes>
+    <Species>Elephant</Species>
     <SpecificName>Elephant</SpecificName>
     <Icon>gaia/fauna_elephant.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_lion.xml

@@ -15 +15 @@
   </Footprint>
   <Identity>
     <Civ>gaia</Civ>
+    <Species>Panthera leo</Species>
     <SpecificName>Lion</SpecificName>
     <Icon>gaia/fauna_lion.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_wolf_snow.xml

@@ -15 +15 @@
   </Footprint>
   <Identity>
     <Civ>gaia</Civ>
+    <Species>Canis lupus</Species>
     <SpecificName>Snow Wolf</SpecificName>
     <Icon>gaia/fauna_wolf_snow.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_elephant_african_bush.xml

@@ -44 +44 @@
   <Identity>
     <Civ>gaia</Civ>
     <Classes datatype="tokens">Elephant</Classes>
+    <Species>Elephant</Species>
     <SpecificName>African Bush Elephant</SpecificName>
     <Icon>gaia/fauna_elephant_african_bush.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_wolf.xml

@@ -15 +15 @@
   </Footprint>
   <Identity>
     <Civ>gaia</Civ>
+    <Species>Canis lupus</Species>
     <SpecificName>Wolf</SpecificName>
     <Icon>gaia/fauna_wolf.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_elephant_north_african.xml

@@ -31 +31 @@
   <Identity>
     <Civ>gaia</Civ>
     <Classes datatype="tokens">Elephant</Classes>
+    <Species>Elephant</Species>
     <SpecificName>North African Elephant</SpecificName>
     <Icon>gaia/fauna_elephant_north_african.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_lioness.xml

@@ -15 +15 @@
   </Footprint>
   <Identity>
     <Civ>gaia</Civ>
+    <Species>Panthera leo</Species>
     <SpecificName>Lion</SpecificName>
     <Icon>gaia/fauna_lion.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_elephant_asian.xml

@@ -44 +44 @@
   <Identity>
     <Civ>gaia</Civ>
     <Classes datatype="tokens">Elephant</Classes>
+    <Species>Elephant</Species>
     <SpecificName>Asian Elephant</SpecificName>
     <Icon>gaia/fauna_elephant_african_bush.png</Icon>
   </Identity>

binaries/data/mods/public/simulation/templates/gaia/fauna_elephant_african_infant.xml

@@ -12 +12 @@
   <Identity>
     <Civ>gaia</Civ>
     <Classes datatype="tokens">Elephant</Classes>
+    <Species>Elephant</Species>
     <SpecificName>African Elephant (Infant)</SpecificName>
     <Icon>gaia/fauna_elephant_african_infant.png</Icon>
   </Identity>

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

@@ +1 @@
+//range of influence for flee
+const fleeInfluence = 28;  // TODO find best value
+
 function UnitAI() {}
 
 UnitAI.prototype.Schema =
@@ -306 +309 @@
     },
 
     "Order.Flee": function(msg) {
-        // We use the distance between the enities to account for ranged attacks
-        var distance = DistanceBetweenEntities(this.entity, this.order.data.target) + (+this.template.FleeDistance);
-        var ok = this.MoveToTargetRangeExplicit(this.order.data.target, distance, -1);
+        var ok = this.PerformFlee(this.order.data);
         if (ok)
         {
             // We've started fleeing from the given target
@@ -318 +319 @@
                 this.SetNextState("INDIVIDUAL.FLEEING");
         }
         else
-        {
-            // We are already at the target, or can't move at all
-            this.StopMoving();
             this.FinishOrder();
-        }
     },
 
     "Order.Attack": function(msg) {
@@ -1218 +1215 @@
                         // Return to our original position
                         if (this.GetStance().respondHoldGround)
                             this.WalkToHeldPosition();
+                        // If wild animal, roam in case we are far from our territory
+                        else if (this.territory)
+                            this.SetNextState("ROAMING");
                     }
                 },
 
@@ -1397 +1397 @@
                         // Return to our original position
                         if (this.GetStance().respondHoldGround)
                             this.WalkToHeldPosition();
+                        // If wild animal, roam in case we are far from our territory
+                        else if (this.territory)
+                            this.SetNextState("ROAMING");
                     }
                 },
 
@@ -2127 +2130 @@
                 this.template.NaturalBehaviour == "passive")
             {
                 this.Flee(msg.data.attacker, false);
+                this.NearbyAnimalsRespondToAttack(msg.data.attacker);
             }
             else if (this.IsDangerousAnimal() || this.template.NaturalBehaviour == "defensive")
             {
                 if (this.CanAttack(msg.data.attacker))
                     this.Attack(msg.data.attacker, false);
+                this.NearbyAnimalsRespondToAttack(msg.data.attacker);
             }
             else if (this.template.NaturalBehaviour == "domestic")
             {
@@ -2210 +2215 @@
 
             "leave": function() {
                 this.StopTimer();
+                // If not yet done, setup territory (initialize here as animals start in feeding state)
+                this.SetUpTerritory();
             },
 
             "LosRangeUpdate": function(msg) {
@@ -3271 +3278 @@
 
     if (this.GetStance().respondFlee)
     {
-        this.PushOrderFront("Flee", { "target": ents[0], "force": false });
+        this.PushOrderFront("Flee", { "attacker": ents[0], "target": undefined, "force": false });
         return true;
     }
 
@@ -3750 +3757 @@
 /**
  * Adds flee order to the queue, not forced, so it can be
  * interrupted by attacks.
+ * (target is undefined when the unit is the target of the attack)
  */
-UnitAI.prototype.Flee = function(target, queued)
+UnitAI.prototype.Flee = function(attacker, queued, target)
 {
-    this.AddOrder("Flee", { "target": target, "force": false }, queued);
+    this.AddOrder("Flee", { "attacker": attacker, "target": target, "force": false }, queued);
 };
 
 /**
+ * Internal function to abstract the details of the runaway
+ * data.attacker is the attacker
+ * data.target is the real target of the attack when it is not the unit itself, otherwise undefined
+ */
+UnitAI.prototype.PerformFlee = function(data)
+{
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return false;
+    var cmpAttackerPosition = Engine.QueryInterface(data.attacker, IID_Position);
+    if (!cmpAttackerPosition || !cmpAttackerPosition.IsInWorld())
+        return false;
+
+    var pos = cmpPosition.GetPosition();
+    var posAttacker = cmpAttackerPosition.GetPosition();
+    var dx = posAttacker.x - pos.x;
+    var dz = posAttacker.z - pos.z;
+    var fleeDistance = (+this.template.FleeDistance);
+    // allow for a small random flee direction :
+    // take a distribution flat in sin between about -pi/4 and pi/4
+    // and approximate cos by 1-sin*sin/2 for these small angles
+    var sinmin = -0.7;
+    var sinmax =  0.7;
+    var sina = sinmin + (sinmax-sinmin)*Math.random();
+    var cosa = 1 - sina*sina/2;
+    if (data.target)
+    {
+        // if the unit is not the target of the attack, it will escape preferentially on the left
+        // or on the right depending on its position with respect to the target,
+        // and its fleeDistance will be reduced.
+        var cmpTargetPosition = Engine.QueryInterface(data.target, IID_Position);
+        if (cmpTargetPosition && cmpTargetPosition.IsInWorld())
+        {
+            var posTarget = cmpTargetPosition.GetPosition();
+            var ex = posAttacker.x - posTarget.x;
+            var ez = posAttacker.z - posTarget.z;
+            var crossprod = ex*dz - ez*dx;
+            var cosn = cosa;
+            if (crossprod > 0)
+            {
+                cosa = 0.866*cosn - 0.500*sina;
+                sina = 0.866*sina + 0.500*cosn;
+            }
+            else
+            {
+                cosa = 0.866*cosn + 0.500*sina;
+                sina = 0.866*sina - 0.500*cosn;
+            }
+            // Decrease the fleeDistance according to the distance between the unit and the target
+            ex = posTarget.x - pos.x;
+            ez = posTarget.z - pos.z;
+            fleeDistance *= (1 - Math.min(1, (ex*ex+ez*ez)/(fleeInfluence*fleeInfluence)));
+        }
+    }
+    var tx = cosa*dx - sina*dz + pos.x;
+    var tz = sina*dx + cosa*dz + pos.z;
+    // We add the distance between the unit and the attacker to account for ranged attacks
+       var distance = fleeDistance + Math.sqrt(dx*dx + dz*dz);
+       var ok = this.MoveToPointRange(tx, tz, distance, -1);
+       if (!ok) this.StopMoving();
+       return ok;
+};
+
+/**
  * Adds cheer order to the queue. Forced so it won't be interrupted by attacks.
  */
 UnitAI.prototype.Cheer = function()
@@ -4180 +4252 @@
 
 UnitAI.prototype.MoveRandomly = function(distance)
 {
-    // We want to walk in a random direction, but avoid getting stuck
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return;
+    var pos = cmpPosition.GetPosition();
+
+    // If we are far away from our starting position, we try to move closer
+    // with a probability increasing with the distance
+    if (this.territory)
+    {
+        var dx = this.territory.x - pos.x;
+        var dz = this.territory.z - pos.z;
+        var dist = Math.sqrt(dx*dx + dz*dz);
+        var proba = RandomInt(0, 100);
+        if (20*dist/distance > Math.max(proba,30))
+        {
+            dist -= distance;
+            var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+            if (!cmpMotion.MoveToPointRange(this.territory.x, this.territory.z, dist, dist))
+                this.territory = pos;
+            return;
+        }
+    }
+
+    // Otherwise we want to walk in a random direction, but avoid getting stuck
     // in obstacles or narrow spaces.
     // So pick a circular range from approximately our current position,
     // and move outwards to the nearest point on that circle, which will
     // lead to us avoiding obstacles and moving towards free space.
 
-    // TODO: we probably ought to have a 'home' point, and drift towards
-    // that, so we don't spread out all across the whole map
-
-    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
-    if (!cmpPosition)
-        return;
-
-    if (!cmpPosition.IsInWorld())
-        return;
-
-    var pos = cmpPosition.GetPosition();
-
     var jitter = 0.5;
 
     // Randomly adjust the range's center a bit, so we tend to prefer
@@ -4238 +4321 @@
     );
 };
 
+UnitAI.prototype.SetUpTerritory = function()
+{
+    if (!this.IsAnimal() || this.IsDomestic())
+        return;
+    if (this.territory)
+        return;
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (cmpPosition && cmpPosition.IsInWorld())
+        this.territory = cmpPosition.GetPosition();
+};
+
+/**
+ * All wild animals in a given distance respond to the attack :
+ * If skittish behaviour, they flee
+ * If defensive behaviour, they attack if it is a member of their species which is involved
+ */
+UnitAI.prototype.NearbyAnimalsRespondToAttack = function(attacker)
+{
+    var cmpOwnIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    // Get other animals ; range = fleeInfluence, players = [0] (gaia only)
+    var nearby = cmpRangeManager.ExecuteQuery(this.entity, 0, fleeInfluence, [0], IID_UnitAI);
+    for each (var ent in nearby)
+    {
+        var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+        if (cmpUnitAI.template.NaturalBehaviour == "skittish" ||
+            cmpUnitAI.template.NaturalBehaviour == "passive")
+        {
+            cmpUnitAI.Flee(attacker, false, this.entity);
+        }
+        else if (cmpOwnIdentity && cmpOwnIdentity.template.Species &&
+                 (cmpUnitAI.IsDangerousAnimal() || cmpUnitAI.template.NaturalBehaviour == "defensive"))
+        {
+            var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
+            if (cmpIdentity && cmpIdentity.template.Species &&
+                cmpIdentity.template.Species == cmpOwnIdentity.template.Species)
+            {
+                if(cmpUnitAI.CanAttack(attacker))
+                    cmpUnitAI.Attack(attacker, false);
+            }
+        }
+    }
+};
+
 Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);

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

@@ -15 +15 @@
         "<text/>" +
     "</element>" +
     "<optional>" +
+        "<element name='Species' a:help='Species this unit belongs to'>" +
+            "<text/>" +
+        "</element>" +
+    "</optional>" +
+    "<optional>" +
         "<element name='SpecificName' a:help='Specific native-language name for this unit type'>" +
             "<text/>" +
         "</element>" +