Ticket #563: AnimalAIm-06-02-2010.patch

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

@@ -5 +5 @@
     "<a:example/>" +
     "<element name='FormationController'>" +
         "<data type='boolean'/>" +
+    "</element>" +
+    "<element name='IsAnimal'>" +
+        "<data type='boolean'/>" +
     "</element>";
 
 // Very basic stance support (currently just for test maps where we don't want
@@ -44 +47 @@
         // ignore attacker
     },
 
+    "HealthChanged": function(msg) {
+        // ignore
+    },
 
     // Formation handlers:
 
@@ -788 +794 @@
         },
 
     },
+
+    "ANIMAL": {
+        "MoveCompleted": function() {
+            // ignore spurious movement messages
+            // (these can happen when stopping moving at the same time
+            // as switching states)
+        },
+
+        "MoveStarted": function() {
+            // ignore spurious movement messages
+        },
+
+        "HealthChanged": function(msg) {
+            // If we died (got reduced to 0 hitpoints), stop the AI and act like a corpse
+            if (msg.to == 0)
+                this.SetNextState("CORPSE");
+        },
+
+        "ResourceGather": function(msg) {
+            // If someone's carving chunks of meat off us, then run away
+            if(this.behavior == "SKITTISH" || this.behavior == "PASSIVE")
+            {
+                this.MoveAwayFrom(msg.gatherer, +this.FleeDistance);
+                this.SetNextState("FLEEING");
+                this.PlaySound("panic");
+            }
+            else if(this.behavior == "VIOLENT" || this.behavior == "AGGRESSIVE"
+            || this.behavior == "DEFENSIVE")
+            {
+                this.Riposte(msg.gatherer);
+            }
+        },
+
+        "Attacked": function(msg) {
+            if(this.behavior == "SKITTISH" || this.behavior == "PASSIVE")
+            {
+                this.MoveAwayFrom(msg.data.attacker, +this.FleeDistance);
+                this.SetNextState("FLEEING");
+                this.PlaySound("panic");
+            }
+            else if(this.behavior == "VIOLENT" || this.behavior == "AGGRESSIVE" || this.behavior == "DEFENSIVE")
+            {
+                this.Riposte(msg.data.attacker);
+            }
+        },
+
+
+        "LosRangeUpdate": function(msg) {
+            if(this.behavior == "SKITTISH")
+            {
+                if(msg.data.added.length>0)
+                {
+                    this.MoveAwayFrom(msg.data.added[0], +this.FleeDistance);
+                    this.SetNextState("FLEEING");
+                    this.PlaySound("panic");
+                    return;
+                }
+            }
+            // Start attacking one of the newly-seen enemy (if any)
+            else if(this.behavior == "VIOLENT")
+                this.AttackVisibleEntity(msg.data.added);
+        },
+
+        "CORPSE": {
+            "enter": function() {
+                this.StopMoving();
+            },
+
+            "Attacked": function(msg) {
+                // Do nothing, because we're dead already
+            },
+        },
+
+        "ROAMING": {
+            "enter": function() {
+                // Walk in a random direction
+                this.SelectAnimation("walk", false, this.GetWalkSpeed());
+                this.MoveRandomly(+this.RoamDistance);
+                // Set a random timer to switch to feeding state
+                this.StartTimer(RandomInt(+this.RoamTimeMin, +this.RoamTimeMax));
+            },
+
+            "leave": function() {
+                this.StopTimer();
+            },
+
+            "Timer": function(msg) {
+                this.SetNextState("FEEDING");
+            },
+
+            "MoveCompleted": function() {
+                this.MoveRandomly(+this.RoamDistance);
+            },
+        },
+
+        "FEEDING": {
+            "enter": function() {
+                // Stop and eat for a while
+                this.SelectAnimation("feeding");
+                this.StopMoving();
+
+                if (this.behavior == "AGGRESSIVE" && this.losRangeQuery)
+                {
+                    var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+                    this.residEnts = rangeMan.ResetActiveQuery(this.losRangeQuery);
+                }
+
+                this.StartTimer(RandomInt(+this.FeedTimeMin, +this.FeedTimeMax));
+            },
+
+            "leave": function() {
+                this.StopTimer();
+            },
+
+            "MoveCompleted": function() { },
+
+            "Timer": function(msg) {
+                if (this.behavior == "AGGRESSIVE" && this.losRangeQuery)
+                {
+                    var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+                    var ents = rangeMan.ResetActiveQuery(this.losRangeQuery);
+                    for each (var ent in this.residEnts)
+                    {
+                        for each (var tent in ents)
+                        {
+                            if (ent == tent)
+                            {
+                                this.Riposte(ent);
+                                this.StopTimer();
+                                return;
+                            }
+                        }
+                    }
+                }
+                this.SetNextState("ROAMING");
+            },
+        },
+
+        "FLEEING": {
+            "enter": function() {
+                // Run quickly
+                var speed = this.GetRunSpeed();
+                this.SelectAnimation("run", false, speed);
+                this.SetMoveSpeed(speed);
+            },
+
+            "leave": function() {
+                // Reset normal speed
+                this.SetMoveSpeed(this.GetWalkSpeed());
+            },
+
+            "MoveCompleted": function() {
+                // When we've run far enough, go back to the roaming state
+                this.SetNextState("ROAMING");
+            },
+
+            "Timer": function(msg) {
+            }
+        },
+
+        "Order.Attack": function(msg) {
+            // Work out how to attack the given target
+            var type = this.GetBestAttack();
+            if (!type)
+            {
+                // Oops, we can't attack at all
+                return;
+            }
+            this.attackType = type;
+
+            // Try to move within attack range
+            if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+            {
+                // We've started walking to the given point
+                this.SetNextState("COMBAT.APPROACHING");
+            }
+            else
+            {
+                // We are already at the target, or can't move at all,
+                // so try attacking it from here.
+                // TODO: need better handling of the can't-reach-target case
+                this.SetNextState("COMBAT.ATTACKING");
+            }
+        },
+
+        "COMBAT": {
+            "Attacked": function(msg) {
+            },
+
+            "LosRangeUpdate": function(msg) {
+            },
+
+            "APPROACHING": {
+                "enter": function() {
+                    this.SelectAnimation("walk", false, this.GetWalkSpeed());
+                },
+                "MoveCompleted": function() {
+                    this.SetNextState("ATTACKING");
+                },
+            },
+
+            "ATTACKING": {
+                "enter": function() {
+                    var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+                    this.attackTimers = cmpAttack.GetTimers(this.attackType);
+                    this.SelectAnimation("melee", false, 1.0, "attack");
+                    //this.SetAnimationSync(this.attackTimers.prepare, this.attackTimers.repeat);
+                    this.StartTimer(this.attackTimers.prepare, this.attackTimers.repeat);
+                    // TODO: we should probably only bother syncing projectile attacks, not melee
+                },
+                "leave": function() {
+                    this.StopTimer();
+                },
+                "Timer": function(msg) {
+                    // Check we can still reach the target
+                    if (this.CheckTargetRange(this.order.data.target, IID_Attack, this.attackType))
+                    {
+                        var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+                        cmpAttack.PerformAttack(this.attackType, this.order.data.target);
+                    }
+                    else
+                    {
+                        if (this.losRangeQuery)
+                        {
+                            // check if the raget is still in sight
+                            var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+                            var ents = rangeMan.ResetActiveQuery(this.losRangeQuery);
+                            for each (var ent in ents)
+                            {
+                                if (ent == this.order.data.target)
+                                {
+                                    // Try to chase after it
+                                    if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+                                    {
+                                        this.SetNextState("CHASING");
+                                        this.StopTimer();
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                        this.SetNextState("ANIMAL.ROAMING");
+                    }
+                },
+            }, //end ANIMAL.COMBAT.ATTACKING
+
+            "CHASING": {
+                "enter": function() {
+                    this.SelectAnimation("walk", false, this.GetWalkSpeed());
+                },
+                "MoveCompleted": function() {
+                    this.SetNextState("ATTACKING");
+                },
+            },
+
+        }, //end ANIMAL.COMBAT
+    }, //end ANIMAL
 };
 
 var UnitFsm = new FSM(UnitFsmSpec);
@@ -814 +1077 @@
 
 UnitAI.prototype.OnCreate = function()
 {
-    if (this.IsFormationController())
-        UnitFsm.Init(this, "FORMATIONCONTROLLER.IDLE");
+    if (this.template.IsAnimal == "true")
+    {
+        this.InitAnimalAI();
+        var startingState = this.NaturalBehaviour.toUpperCase(this.NaturalBehaviour);
+        this.behavior = startingState;
+
+        startingState = "ANIMAL.FEEDING";
+        UnitFsm.Init(this, startingState);
+    }
     else
-        UnitFsm.Init(this, "INDIVIDUAL.IDLE");
+    {
+        if (this.IsFormationController())
+            UnitFsm.Init(this, "FORMATIONCONTROLLER.IDLE");
+        else
+            UnitFsm.Init(this, "INDIVIDUAL.IDLE");
+    }
 };
 
 UnitAI.prototype.OnOwnershipChanged = function(msg)
@@ -854 +1129 @@
     var range = cmpVision.GetRange();
     
     var players = [];
-    
-    if (owner != -1)
+
+if (owner != -1)
     {
         // If unit not just killed, get enemy players via diplomacy
         var player = Engine.QueryInterface(playerMan.GetPlayerByID(owner), IID_Player);
@@ -863 +1138 @@
         // Get our diplomacy array
         var diplomacy = player.GetDiplomacy();
         var numPlayers = playerMan.GetNumPlayers();
-        
+
         for (var i = 1; i < numPlayers; ++i)
         {
             // Exclude gaia, allies, and self
             // TODO: How to handle neutral players - Special query to attack military only?
-            if (i != owner && diplomacy[i - 1] < 0)
+            if (i != owner && (diplomacy[i - 1] < 0 || owner == 0))
                 players.push(i);
         }
     }
@@ -1546 +1821 @@
     return true;
 };
 
+//Animal specific functions
 
+UnitAI.prototype.OnHealthChanged = function(msg)
+{
+    UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
+};
+
+UnitAI.prototype.MoveRandomly = function(distance)
+{
+    // 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
+    // moving in random directions (if there's nothing in the way)
+    var tx = pos.x + (2*Math.random()-1)*jitter;
+    var tz = pos.z + (2*Math.random()-1)*jitter;
+
+    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpMotion.MoveToPointRange(tx, tz, distance, distance);
+};
+
+UnitAI.prototype.MoveAwayFrom = function(ent, distance)
+{
+    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpMotion.MoveToTargetRange(ent, distance, distance);
+};
+
+UnitAI.prototype.SetMoveSpeed = function(speed)
+{
+    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    cmpMotion.SetSpeed(speed);
+};
+
+UnitAI.prototype.InitAnimalAI = function()
+{
+    var cmpAnimalAI = Engine.QueryInterface(this.entity, IID_AnimalAI);
+    if (!cmpAnimalAI)
+        return;
+
+    this.NaturalBehaviour = cmpAnimalAI.GetNaturalBehaviour();
+    this.RoamDistance = cmpAnimalAI.GetRoamDistance();
+    this.FleeDistance = cmpAnimalAI.GetFleeDistance();
+    this.RoamTimeMin = cmpAnimalAI.GetRoamTimeMin();
+    this.RoamTimeMax = cmpAnimalAI.GetRoamTimeMax();
+    this.FeedTimeMin = cmpAnimalAI.GetFeedTimeMin();
+    this.FeedTimeMax = cmpAnimalAI.GetFeedTimeMax();
+};
+
+UnitAI.prototype.Riposte = function(attacker)
+{
+  // Default behaviour: attack back at our attacker
+  if (this.CanAttack(attacker))
+  {
+    this.order = { "type": "Attack", "data": { "target": attacker }};
+    UnitFsm.ProcessMessage(this, {"type": "Order.Attack", "data": this.order.data});
+    return true;
+  }
+  return false;
+};
+
 Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);

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

@@ -30 +30 @@
         "<ref name='positiveDecimal'/>" +
     "</element>";
 
-var AnimalFsmSpec = {
-
-    "MoveCompleted": function() {
-        // ignore spurious movement messages
-        // (these can happen when stopping moving at the same time
-        // as switching states)
-    },
-
-    "MoveStarted": function() {
-        // ignore spurious movement messages
-    },
-
-    "HealthChanged": function(msg) {
-        // If we died (got reduced to 0 hitpoints), stop the AI and act like a corpse
-        if (msg.to == 0)
-            this.SetNextState("CORPSE");
-    },
-
-    "CORPSE": {
-        "enter": function() {
-            this.StopMoving();
-        },
-
-        "Attacked": function(msg) {
-            // Do nothing, because we're dead already
-        },
-    },
-
-    "SKITTISH": {
-
-        "Attacked": function(msg) {
-            // If someone's attacking us, then run away
-            this.MoveAwayFrom(msg.data.attacker, +this.template.FleeDistance);
-            this.SetNextState("FLEEING");
-            this.PlaySound("panic");
-        },
-
-        "ROAMING": {
-            "enter": function() {
-                // Walk in a random direction
-                this.SelectAnimation("walk", false, this.GetWalkSpeed());
-                this.MoveRandomly(+this.template.RoamDistance);
-                // Set a random timer to switch to feeding state
-                this.StartTimer(RandomInt(+this.template.RoamTimeMin, +this.template.RoamTimeMax));
-            },
-
-            "leave": function() {
-                this.StopTimer();
-            },
-
-            "Timer": function(msg) {
-                this.SetNextState("FEEDING");
-            },
-
-            "MoveCompleted": function() {
-                this.MoveRandomly(+this.template.RoamDistance);
-            },
-        },
-
-        "FEEDING": {
-            "enter": function() {
-                // Stop and eat for a while
-                this.SelectAnimation("feeding");
-                this.StopMoving();
-                this.StartTimer(RandomInt(+this.template.FeedTimeMin, +this.template.FeedTimeMax));
-            },
-            
-            "leave": function() {
-                this.StopTimer();
-            },
-
-            "MoveCompleted": function() { },
-
-            "Timer": function(msg) {
-                this.SetNextState("ROAMING");
-            },
-        },
-
-        "FLEEING": {
-            "enter": function() {
-                // Run quickly
-                var speed = this.GetRunSpeed();
-                this.SelectAnimation("run", false, speed);
-                this.SetMoveSpeed(speed);
-            },
-
-            "leave": function() {
-                // Reset normal speed
-                this.SetMoveSpeed(this.GetWalkSpeed());
-            },
-
-            "MoveCompleted": function() {
-                // When we've run far enough, go back to the roaming state
-                this.SetNextState("ROAMING");
-            },
-        },
-    },
-
-    "PASSIVE": {
-
-        "Attacked": function(msg) {
-            // Do nothing, just let them kill us
-        },
-    
-        "ROAMING": {
-            "enter": function() {
-                // Walk in a random direction
-                this.SelectAnimation("walk", false, this.GetWalkSpeed());
-                this.MoveRandomly(+this.template.RoamDistance);
-                // Set a random timer to switch to feeding state
-                this.StartTimer(RandomInt(+this.template.RoamTimeMin, +this.template.RoamTimeMax));
-            },
-
-            "leave": function() {
-                this.StopTimer();
-            },
-
-            "Timer": function(msg) {
-                this.SetNextState("FEEDING");
-            },
-
-            "MoveCompleted": function() {
-                this.MoveRandomly(+this.template.RoamDistance);
-            },
-        },
-
-        "FEEDING": {
-            "enter": function() {
-                // Stop and eat for a while
-                this.SelectAnimation("feeding");
-                this.StopMoving();
-                this.StartTimer(RandomInt(+this.template.FeedTimeMin, +this.template.FeedTimeMax));
-            },
-            
-            "leave": function() {
-                this.StopTimer();
-            },
-
-            "MoveCompleted": function() { },
-
-            "Timer": function(msg) {
-                this.SetNextState("ROAMING");
-            },
-        },
-    },
-
-};
-
-var AnimalFsm = new FSM(AnimalFsmSpec);
-
 AnimalAI.prototype.Init = function()
 {
 };
 
-// FSM linkage functions:
-
-AnimalAI.prototype.OnCreate = function()
+AnimalAI.prototype.GetNaturalBehaviour = function()
 {
-    var startingState = this.template.NaturalBehaviour;
-    startingState = startingState.toUpperCase(startingState);
-
-    if (startingState == "SKITTISH")
-        startingState = startingState + ".FEEDING";
-    else
-        startingState = "PASSIVE.FEEDING";
-
-    AnimalFsm.Init(this, startingState);
+    return this.template.NaturalBehaviour;
 };
 
-AnimalAI.prototype.SetNextState = function(state)
+AnimalAI.prototype.GetRoamDistance = function()
 {
-    AnimalFsm.SetNextState(this, state);
+    return this.template.RoamDistance;
 };
 
-AnimalAI.prototype.DeferMessage = function(msg)
+AnimalAI.prototype.GetFleeDistance = function()
 {
-    AnimalFsm.DeferMessage(this, msg);
+    return this.template.FleeDistance;
 };
 
-AnimalAI.prototype.OnMotionChanged = function(msg)
+AnimalAI.prototype.GetRoamTimeMin = function()
 {
-    if (msg.starting && !msg.error)
-    {
-        AnimalFsm.ProcessMessage(this, {"type": "MoveStarted", "data": msg});
-    }
-    else if (!msg.starting || msg.error)
-    {
-        AnimalFsm.ProcessMessage(this, {"type": "MoveCompleted", "data": msg});
-    }
+    return this.template.RoamTimeMin;
 };
 
-AnimalAI.prototype.OnAttacked = function(msg)
+AnimalAI.prototype.GetRoamTimeMax = function()
 {
-    AnimalFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
+    return this.template.RoamTimeMax;
 };
 
-AnimalAI.prototype.OnHealthChanged = function(msg)
+AnimalAI.prototype.GetFeedTimeMin = function()
 {
-    AnimalFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
+    return this.template.FeedTimeMin;
 };
 
-AnimalAI.prototype.TimerHandler = function(data, lateness)
+AnimalAI.prototype.GetFeedTimeMax = function()
 {
-    AnimalFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
+    return this.template.FeedTimeMax;
 };
 
-// Functions to be called by the FSM:
-
-AnimalAI.prototype.GetWalkSpeed = function()
-{
-    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpMotion.GetWalkSpeed();
-};
-
-AnimalAI.prototype.GetRunSpeed = function()
-{
-    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    return cmpMotion.GetRunSpeed();
-};
-
-AnimalAI.prototype.PlaySound = function(name)
-{
-    PlaySound(name, this.entity);
-};
-
-AnimalAI.prototype.SelectAnimation = function(name, once, speed, sound)
-{
-    var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
-    if (!cmpVisual)
-        return;
-
-    var soundgroup;
-    if (sound)
-    {
-        var cmpSound = Engine.QueryInterface(this.entity, IID_Sound);
-        if (cmpSound)
-            soundgroup = cmpSound.GetSoundGroup(sound);
-    }
-
-    // Set default values if unspecified
-    if (typeof once == "undefined")
-        once = false;
-    if (typeof speed == "undefined")
-        speed = 1.0;
-    if (typeof soundgroup == "undefined")
-        soundgroup = "";
-
-    cmpVisual.SelectAnimation(name, once, speed, soundgroup);
-};
-
-AnimalAI.prototype.MoveRandomly = function(distance)
-{
-    // 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
-    // moving in random directions (if there's nothing in the way)
-    var tx = pos.x + (2*Math.random()-1)*jitter;
-    var tz = pos.z + (2*Math.random()-1)*jitter;
-
-    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    cmpMotion.MoveToPointRange(tx, tz, distance, distance);
-};
-
-AnimalAI.prototype.MoveAwayFrom = function(ent, distance)
-{
-    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    cmpMotion.MoveToTargetRange(ent, distance, distance);
-};
-
-AnimalAI.prototype.StopMoving = function()
-{
-    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    cmpMotion.StopMoving();
-};
-
-AnimalAI.prototype.SetMoveSpeed = function(speed)
-{
-    var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
-    cmpMotion.SetSpeed(speed);
-};
-
-AnimalAI.prototype.StartTimer = function(interval, data)
-{
-    if (this.timer)
-        error("Called StartTimer when there's already an active timer");
-
-    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-    this.timer = cmpTimer.SetTimeout(this.entity, IID_AnimalAI, "TimerHandler", interval, data);
-};
-
-AnimalAI.prototype.StopTimer = function()
-{
-    if (!this.timer)
-        return;
-
-    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-    cmpTimer.CancelTimer(this.timer);
-    this.timer = undefined;
-};
-
 Engine.RegisterComponentType(IID_AnimalAI, "AnimalAI", AnimalAI);

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

@@ -5 +5 @@
   <AnimalAI>
     <NaturalBehaviour>aggressive</NaturalBehaviour>
   </AnimalAI>
+  <Attack>
+    <Melee>
+      <Hack>1.0</Hack>
+      <Pierce>1.0</Pierce>
+      <Crush>0.0</Crush>
+      <MaxRange>4.0</MaxRange>
+      <RepeatTime>1000</RepeatTime>
+    </Melee>
+  </Attack>
 </Entity>

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

@@ -5 +5 @@
   <AnimalAI>
     <NaturalBehaviour>violent</NaturalBehaviour>
   </AnimalAI>
+  <Attack>
+    <Melee>
+      <Hack>1.0</Hack>
+      <Pierce>1.0</Pierce>
+      <Crush>0.0</Crush>
+      <MaxRange>4.0</MaxRange>
+      <RepeatTime>1000</RepeatTime>
+    </Melee>
+  </Attack>
 </Entity>

binaries/data/mods/public/simulation/templates/special/formation.xml

@@ -8 +8 @@
   <Formation/>
   <UnitAI>
     <FormationController>true</FormationController>
+    <IsAnimal>false</IsAnimal>
   </UnitAI>
   <UnitMotion>
     <FormationController>true</FormationController>

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

@@ -5 +5 @@
   <AnimalAI>
     <NaturalBehaviour>violent</NaturalBehaviour>
   </AnimalAI>
+  <Attack>
+    <Melee>
+      <Hack>1.0</Hack>
+      <Pierce>1.0</Pierce>
+      <Crush>0.0</Crush>
+      <MaxRange>4.0</MaxRange>
+      <RepeatTime>1000</RepeatTime>
+    </Melee>
+  </Attack>
 </Entity>

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

@@ -3 +3 @@
   <Identity>
   </Identity>
   <AnimalAI>
-    <NaturalBehaviour>violent</NaturalBehaviour>
+    <NaturalBehaviour>aggressive</NaturalBehaviour>
   </AnimalAI>
+  <Attack>
+    <Melee>
+      <Hack>1.0</Hack>
+      <Pierce>1.0</Pierce>
+      <Crush>0.0</Crush>
+      <MaxRange>4.0</MaxRange>
+      <RepeatTime>1000</RepeatTime>
+    </Melee>
+  </Attack>
 </Entity>

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

@@ -25 +25 @@
       <Speed>6.0</Speed>
     </Run>
   </UnitMotion>
-  <UnitAI disable=""/>
+  <UnitAI>
+    <FormationController>false</FormationController>
+    <IsAnimal>true</IsAnimal>
+  </UnitAI>
   <AnimalAI>
     <RoamDistance>8.0</RoamDistance>
     <FleeDistance>32.0</FleeDistance>

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

@@ -16 +16 @@
     <Floating>true</Floating>
   </Position>
   <UnitMotion disable=""/>
+  <UnitAI disable=""/>
   <AnimalAI disable=""/>
   <ResourceSupply>
     <KillBeforeGather>false</KillBeforeGather>

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

@@ -9 +9 @@
   </Minimap>
   <UnitAI>
     <FormationController>false</FormationController>
+    <IsAnimal>false</IsAnimal>
   </UnitAI>
   <Cost>
     <Population>1</Population>