Ticket #999: #999-2012-02-23.patch

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

@@ -66 +66 @@
         });
         break;
 
+  case "heal":
+    //TODO fix this and UnitAI.CanHeal when healing allies is implemented
+    if (g_DebugCommands && !IsOwnedByPlayer(player, cmd.target))
+    {
+      // This check is for debugging only!
+      warn("Invalid command: heal target is not owned by player "+player+": "+uneval(cmd));
+    }
+    
+    // See UnitAI.CanHeal for target checks
+    var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
+    GetFormationUnitAIs(entities).forEach(function(cmpUnitAI) {
+      cmpUnitAI.Heal(cmd.target, cmd.queued);
+    });
+    break;
+
     case "repair":
         // This covers both repairing damaged buildings, and constructing unfinished foundations
         if (g_DebugCommands && !IsOwnedByAllyOfPlayer(player, cmd.target))

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

@@ -264 +264 @@
         ret.barterMarket = { "prices": cmpBarter.GetPrices() };
     }
 
+  // TODO change ret.Healer to ret.Ability (see TODO-comment in unit-command.js
+  var cmpHeal = Engine.QueryInterface(ent, IID_Heal);
+  if (cmpHeal)
+  {
+    ret.Healer = { "healableClasses": cmpHeal.GetHealableClasses() };
+  }
+
     var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     ret.visibility = cmpRangeManager.GetLosVisibility(ent, player, false);
 

0ad/binaries/data/mods/public/simulation/components/interfaces/Heal.js

@@ +1 @@
+Engine.RegisterInterface("Heal");
+
+//TODO register message type healed?

0ad/binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js

@@ -5 +5 @@
 Engine.LoadComponentScript("interfaces/DamageReceiver.js");
 Engine.LoadComponentScript("interfaces/Foundation.js");
 Engine.LoadComponentScript("interfaces/GarrisonHolder.js");
+Engine.LoadComponentScript("interfaces/Heal.js");
 Engine.LoadComponentScript("interfaces/Health.js");
 Engine.LoadComponentScript("interfaces/Promotion.js");
 Engine.LoadComponentScript("interfaces/RallyPoint.js");

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

@@ -282 +282 @@
         // so abandon this attack order
         this.FinishOrder();
     },
+  
+  "Order.Heal": function(msg) {
+    // Check the target is alive
+    if (!this.TargetIsAlive(this.order.data.target))
+    {
+            this.FinishOrder();
+            return;
+    }
+    
+    // Check if the target is in range
+    if (this.CheckTargetRange(this.order.data.target, IID_Heal))
+    {
+            this.StopMoving();
+            this.SetNextState("INDIVIDUAL.HEAL.HEALING");
+            return;
+    }
+    
+    // TODO Should we adhere to stances?
+    // check if standing ground stance -> abandon
 
+    // Try to move within heal range
+    if (this.MoveToTargetRange(this.order.data.target, IID_Heal))
+    {
+            // We've started walking to the given point
+            this.SetNextState("INDIVIDUAL.HEAL.APPROACHING");
+            return;
+    }
+
+    // We can't reach the target, and can't move towards it,
+    // so abandon this heal order
+    this.FinishOrder();
+  },
+
     "Order.Gather": function(msg) {
         
         // If the target is still alive, we need to kill it first
@@ -995 +1027 @@
             },
         },
 
+    "HEAL": {
+      // TODO How should we handle being attacked? maybe ignore attack like in COMBAT
+      "APPROACHING": {
+        "enter": function () {
+          this.SelectAnimation("move");
+          this.StartTimer(1000, 1000);
+        },
+
+        "leave": function() {
+          this.StopTimer();
+        },
+
+        "Timer": function(msg) {
+          if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force))
+          {
+            this.StopMoving();
+            this.FinishOrder();
+
+            // TODO stances?
+          }
+        },
+
+        "MoveCompleted": function() {
+          this.SetNextState("HEALING");
+        },
+
+//        "Attacked": function(msg) {
+          //Should we ignore close enemys? 
+//        },
+      },
+
+      "HEALING": {
+        "enter": function() {
+          var cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
+          this.healTimers = cmpHeal.GetTimers();
+//          this.SelectAnimation("heal", false, 1.0, "heal"); // TODO needs animation
+//          this.SetAnimationSync(this.healTimers.prepare, this.healTimers.repeat);
+          this.StartTimer(this.healTimers.prepare, this.healTimers.repeat);
+          this.FaceTowardsTarget(this.order.data.target);
+        },
+
+        "leave": function() {
+          this.StopTimer();
+        },
+
+        "Timer": function(msg) {
+          var target = this.order.data.target;
+          // Check the target is still alive and healable
+          if (this.TargetIsAlive(target) && this.CanHeal(target))
+          {
+            // Check if we can still reach the target
+            if (this.CheckTargetRange(target, IID_Heal))
+            {
+              this.FaceTowardsTarget(target);
+              var cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
+              cmpHeal.PerformHeal(target);
+              return;
+            }
+            // Can't reach it - chase it
+            if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
+            {
+              if (this.MoveToTargetRange(target, IID_Heal))
+              {
+                this.SetNextState("HEAL.CHASING");
+                return;
+              }
+            }
+          }
+          // Can't reach it, healed to max hp or doesn't exist any more - give up
+          if (this.FinishOrder())
+            return;
+
+          // TODO implement autoheal next (like in ATTACK FindNewTargets())
+          // needs FindNewHealTargets() and maybe a something like RespondToTargetedEntities() ; figure out how SortEntitiesByPriority is working
+//          if (this.FindNewHealTargets())
+//            return;
+
+          return;
+        },
+        // TODO "Attacked" - what behaviour?
+        // Should we ignore being attacked while healing?
+      },
+      "CHASING": {
+        "enter": function () {
+          this.SelectAnimation("move");
+          this.StartTimer(1000, 1000);
+        },
+
+        "leave": function () {
+          this.StopTimer();
+        },
+        "Timer": function(msg) {
+          if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force))
+          {
+            this.StopMoving();
+            this.FinishOrder();
+
+          }
+        },
+        "MoveCompleted": function () {
+          this.SetNextState("HEALING");
+        },
+      },  
+    },
+
         // Returning to dropsite
         "RETURNRESOURCE": {
             "APPROACHING": {
@@ -1746 +1883 @@
 };
 
 /**
+ * Returns true if the target exists and the current hitpoints are at maximum.
+ */
+UnitAI.prototype.TargetIsAtMaxHitpoints = function(ent)
+{
+  var cmpHealth = Engine.QueryInterface(ent, IID_Health);
+  if(!cmpHealth)
+    return false;
+
+  return (cmpHealth.GetHitpoints() == cmpHealth.GetMaxHitpoints());
+};
+
+/**
  * Returns true if the target exists and needs to be killed before
  * beginning to gather resources from it.
  */
@@ -2359 +2508 @@
     this.AddOrder("GatherNearPosition", { "type": type, "x": position[0], "z": position[1] }, queued);
 }
 
+UnitAI.prototype.Heal = function(target, queued)
+{
+  if (!this.CanHeal(target))
+  {
+    // TODO should we really walk there if we can't heal
+    // If resource for healing is implemented check if we have insufficient
+    // resources and walk there.
+    this.WalkToTarget(target, queued);
+    return;
+  }
+  // We don't want to chase units that leave our visibility -> force = false
+  this.AddOrder("Heal", { "target": target, "force": false }, queued);
+};
+
 UnitAI.prototype.ReturnResource = function(target, queued)
 {
     if (!this.CanReturnResource(target, true))
@@ -2555 +2718 @@
     return true;
 };
 
+UnitAI.prototype.CanHeal = function(target)
+{
+  // Formation controllers should always respond to commands
+  // (then the individual units can make up their own minds)
+  if (this.IsFormationController())
+    return true;
+
+  // Verify that we're able to respond to Heal commands
+  var cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
+  if (!cmpHeal)
+    return false;
+
+  // Verify that the target is alive
+  if (!this.TargetIsAlive(target))
+    return false;
+
+  // Verify that the target is owned by the same player as the entity
+  // TODO or of an ally
+  var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+  if (!cmpOwnership || !IsOwnedByPlayer(cmpOwnership.GetOwner(), target))
+    return false;
+
+  // Verify that the target is a healable class
+  // We could also use cmpIdentity.GetClassesList but this way is cleaner
+  var cmpIdentity = Engine.QueryInterface(target, IID_Identity);
+  if (!cmpIdentity)
+    return false;
+  var healable = false;
+  for each (var healableClass in cmpHeal.GetHealableClasses())
+  {
+    if (cmpIdentity.HasClass(healableClass) != -1)
+    {
+      healable = true;
+    }
+  }
+  if (!healable)
+    return false;
+
+  // Check that the target is not at MaxHealth
+  if (this.TargetIsAtMaxHitpoints(target))
+    return false; 
+
+  return true;
+};
+
 UnitAI.prototype.CanReturnResource = function(target, checkCarriedResource)
 {
     // Formation controllers should always respond to commands

0ad/binaries/data/mods/public/simulation/components/Heal.js

@@ +1 @@
+function Heal() {}
+
+Heal.prototype.Schema = 
+      "<a:help>Controls the healing abilities of the unit.</a:help>" +
+      "<a:example>" +
+         "<Range>20</Range>" +
+         "<Speed>5</Speed>" +
+         "<HealableClasses datatype=\"tokens\">Support Infantry</HealableClasses>" +
+      "</a:example>" +
+      "<element name='Range' a:help='Range (in metres) where healing is possible'>" +
+        "<ref name='nonNegativeDecimal'/>" +
+      "</element>" +
+      "<element name='Speed' a:help='Hp healed per second'>" +
+        "<ref name='nonNegativeDecimal'/>" +
+      "</element>" +
+      "<element name='HealableClasses'>" +
+        "<attribute name='datatype'>" +
+          "<value>tokens</value>" +
+        "</attribute>" +
+        "<text/>" +
+      "</element>";
+
+Heal.prototype.Init = function()
+{
+};
+
+Heal.prototype.Serialize = null; // we have no dynamic state to save
+
+Heal.prototype.GetTimers = function(type)
+{
+        var prepare = 1000;
+        var repeat = 1000;
+        return { "prepare": prepare, "repeat": repeat };
+}
+
+Heal.prototype.GetRange = function()
+{
+        var max = +this.template.Range;
+        var min = 0;
+        return { "max": max, "min": min };
+};
+
+Heal.prototype.GetHealableClasses = function()
+{
+        var classes = this.template.HealableClasses._string;
+        return classes.split(/\s+/);
+};
+
+/**
+ * Heal the target entity. This should only be called after a successful range 
+ * check, and should only be called after GetTimers().repeat msec has passed 
+ * since the last call to PerformHeal.
+ */
+Heal.prototype.PerformHeal = function(target)
+{
+          this.CauseHeal({"target": target});
+};
+
+/**
+ * Heal target
+ */
+Heal.prototype.CauseHeal = function(data)
+{
+        var cmpHealth = Engine.QueryInterface(data.target, IID_Health);
+        if(!cmpHealth)
+              return;
+        var targetState = cmpHealth.Increase(Math.max(0,this.template.Speed));
+        //TODO add some Engine.PostMessage? - shouldn't be needed as Increase already posts a message
+        //TODO we need a sound file
+//        PlaySound("heal_impact", this.entity);
+};
+
+Engine.RegisterComponentType(IID_Heal, "Heal", Heal);

0ad/binaries/data/mods/public/simulation/templates/template_unit_support_healer.xml

@@ -5 +5 @@
     <Pierce>2.0</Pierce>
     <Crush>2.0</Crush>
   </Armour>
-  <Auras>
+<!--  <Auras>
     <Heal>
       <Radius>20</Radius>
       <Speed>2000</Speed>
     </Heal>
-  </Auras>
+  </Auras>-->
+  <Heal>
+    <Range>30</Range>
+    <Speed>5</Speed>
+    <HealableClasses datatype="tokens">Support Infantry</HealableClasses>
+  </Heal>
   <Cost>
     <Resources>
       <metal>120</metal>

0ad/binaries/data/mods/public/gui/session/session.xml

@@ -725 +725 @@
                     </object>
                 </object>
 
+        <object name="unitAbilityPanel"
+          size="14 12 100% 100%"
+        >
+          <object size="0 0 100% 100%">
+            <repeat count="24">
+              <object name="unitAbilityButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
+                <object name="unitAbilityIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
+              </object>
+            </repeat>
+          </object>
+        </object>
+
                 <object name="unitResearchPanel"
                     style="TranslucentPanelThinBorder"
                     size="0 100%-56 100% 100%"

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

@@ -15 +15 @@
 const ACTION_NONE = 0;
 const ACTION_GARRISON = 1;
 const ACTION_REPAIR = 2;
+const ACTION_HEAL = 3;
 var preSelectedAction = ACTION_NONE;
 
 var INPUT_NORMAL = 0;
@@ -255 +256 @@
                 }
             }
             break;
+    case "heal": //TODO add something like && targetState.needsheal ?
+      if (isUnit(targetState) && playerOwned) //TODO fix for allies allyOwned
+      {
+        // TODO fix this for entState.Ability see unit_command.js and GuiInterface.js
+        var healableClasses = entState.Healer.healableClasses;
+        for each (var unitClass in targetState.identity.classes)
+        {
+          if (healableClasses.indexOf(unitClass) != -1)
+          {
+            return {"possible": true};
+          }
+        }
+      }
+      break;
         case "gather":
             if (targetState.resourceSupply && (playerOwned || gaiaOwned))
             {
@@ -350 +365 @@
             else
                 return {"type": "none", "cursor": "action-repair-disabled", "target": undefined};
             break;
+    case ACTION_HEAL: //TODO change disabled cursor
+      if (getActionInfo("heal", target).possible){
+        return {"type": "heal", "cursor": "action-heal", "target": target};
+      }else
+        return {"type": "none", "cursor": "action-repair-disabled", "target": undefined};
+      break;
         }
     }
     else if (Engine.HotkeyIsPressed("session.garrison"))
@@ -992 +1013 @@
         Engine.GuiInterfaceCall("PlaySound", { "name": "order_attack", "entity": selection[0] });
         return true;
 
+  case "heal":
+    Engine.PostNetworkCommand({"type": "heal", "entities": selection, "target": action.target, "queued": queued});
+    //TODO play sound
+//    Engine.GuiInterfaceCall("PlaySound", { "name": "order_heal", "entity": selection[0] });
+    return true;
+
     case "build": // (same command as repair)
     case "repair":
         Engine.PostNetworkCommand({"type": "repair", "entities": selection, "target": action.target, "autocontinue": true, "queued": queued});
@@ -1204 +1231 @@
                 inputState = INPUT_PRESELECTEDACTION;
                 preSelectedAction = ACTION_REPAIR;
                 break;
+      case "heal":
+        inputState = INPUT_PRESELECTEDACTION;
+        preSelectedAction = ACTION_HEAL;
+        break;
             case "unload-all":
                 unloadAll(entity);
                 break;

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

@@ -5 +5 @@
 const FORMATION = "Formation";
 const TRAINING = "Training";
 const CONSTRUCTION = "Construction";
+const ABILITY = "Ability";
 const COMMAND = "Command";
 const STANCE = "Stance";
 
@@ -20 +21 @@
 const BARTER_ACTIONS = ["Sell", "Buy"];
 
 // The number of currently visible buttons (used to optimise showing/hiding)
-var g_unitPanelButtons = {"Selection": 0, "Queue": 0, "Formation": 0, "Garrison": 0, "Barter": 0, "Training": 0, "Construction": 0, "Command": 0, "Stance": 0};
+var g_unitPanelButtons = {"Selection": 0, "Queue": 0, "Formation": 0, "Garrison": 0, "Barter": 0, "Training": 0, "Construction": 0, "Ability": 0, "Command": 0, "Stance": 0};
 
 // Unit panels are panels with row(s) of buttons
-var g_unitPanels = ["Selection", "Queue", "Formation", "Garrison", "Barter", "Training", "Construction", "Research", "Stance", "Command"];
+var g_unitPanels = ["Selection", "Queue", "Formation", "Garrison", "Barter", "Training", "Construction", "Ability", "Research", "Stance", "Command"];
 
 // Indexes of resources to sell and buy on barter panel
 var g_barterSell = 0;
@@ -174 +175 @@
                 numberOfItems =  24;
             break;
 
+    case ABILITY:
+      if (numberOfItems > 24)
+        numberOfItems = 24;
+      break;
+
         case COMMAND:
             if (numberOfItems > 6)
                 numberOfItems = 6;
@@ -190 +196 @@
         var item = items[i];
         var entType = ((guiName == "Queue")? item.template : item);
         var template;
-        if (guiName != "Formation" && guiName != "Command" && guiName != "Stance")
+        if (guiName != "Formation" && guiName != "Command" && guiName != "Stance" && guiName != "Ability")
         {
             template = GetTemplateData(entType);
             if (!template)
@@ -269 +275 @@
 
                 break;
 
+      case ABILITY: //TODO get some good tooltip
+        var tooltip = "abilitytooltip_unit_command.js";
+        break;
+
             case COMMAND:
                 // here, "item" is an object with properties .name (command name), .tooltip and .icon (relative to session/icons/single)
                 if (item.name == "unload-all")
@@ -338 +348 @@
             icon.sprite = "stretched:session/icons/single/" + item.icon;
 
         }
+    else if (guiName == "Ability")
+    {
+      //TODO fix so that each ability has an icon with its name
+      icon.sprite = "stretched:session/portraits/abilities/heal.png";
+    }
         else if (template.icon)
         {
             icon.sprite = "stretched:session/portraits/" + template.icon;
@@ -511 +526 @@
             setupUnitBarterPanel(entState);
         }
 
+    // TODO change this to entState.Ability? to just have GuiInterface.js
+    // build the Ability list and use entState.Ability instead of ["heal]
+    if (entState.Healer)
+    {
+      setupUnitPanel("Ability", usedPanels, entState, ["heal"], function (item) { performCommand(entState.id, "heal"); });//item.name); });
+    }
+
         if (entState.buildEntities && entState.buildEntities.length)
         {
             setupUnitPanel("Construction", usedPanels, entState, entState.buildEntities, startBuildingPlacement);

0ad/binaries/data/mods/public/art/textures/cursors/action-heal.txt

@@ +1 @@
+1 1