Ticket #799: patch_backtowork.2.diff

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

@@ -1848 +1848 @@
                     Engine.CameraMoveTo(focusTarget.x, focusTarget.z);
                 
                 break;
+            case "back-to-work":
+                backToWork();
+                break;
             default:
                 break;
             }
@@ -2110 +2113 @@
     Engine.PostNetworkCommand({"type": "unload-all", "garrisonHolders": garrisonHolders});
 }
 
+function backToWork()
+{
+    // Filter out all entities that can't go back to work.
+    var workers = g_Selection.toList().filter(function(e) {
+        var state = GetEntityState(e);
+        if (state && hasClass(state, "Worker"))
+            return true;
+        return false;
+    });
+    
+    Engine.PostNetworkCommand({"type": "back-to-work", "workers": workers});
+    
+}
+
 function clearSelection()
 {
     if(inputState==INPUT_BUILDING_PLACEMENT || inputState==INPUT_BUILDING_WALL_PATHING)

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

@@ -293 +293 @@
             "icon": "focus-rally.png"
         });
     }
+    
+    if (hasClass(entState, "Worker"))
+    {
+        commands.push({
+            "name": "back-to-work",
+            "tooltip": "Back to Work",
+            "icon": "production.png"
+        });
+    }
 
     return commands;
 }

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

@@ -63 +63 @@
     // each with an independent capacity, but the rest of the game currently
     // ensures and assumes we'll only be carrying one type at once)
 
-    // The last exact type gathered, so we can render appropriate props
-    this.lastCarriedType = undefined; // { generic, specific }
+    // Informations needed to go back to work later and render appropriate props
+    this.lastWorkInformation = undefined;
 };
 
 /**
@@ -119 +119 @@
  */
 ResourceGatherer.prototype.GetLastCarriedType = function()
 {
-    if (this.lastCarriedType && this.lastCarriedType.generic in this.carrying)
-        return this.lastCarriedType;
+    if (this.lastWorkInformation && this.lastWorkInformation.type && this.lastWorkInformation.type.generic in this.carrying)
+        return this.lastWorkInformation.type;
     else
         return undefined;
 };
@@ -194 +194 @@
 
     var gatherAmount = 1;
 
+    // Remember what we are gathering to go back to it later    
     var cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
     var type = cmpResourceSupply.GetType();
-
+    
+    var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+    var template = cmpTemplateManager.GetCurrentTemplateName(target);
+    
+    if (template.indexOf("resource|") != -1)
+        template = template.slice(9);
+    
+    var lastPos = undefined;
+    var cmpPosition = Engine.QueryInterface(target, IID_Position);
+    if (cmpPosition && cmpPosition.IsInWorld())
+        lastPos = cmpPosition.GetPosition();
+    
+    // "force" will be used when giving the "back to work" order
+    // We don't want to remember treasure collecting since it's not a work we can 'go back to'
+    if (type.generic != "treasure")
+        this.lastWorkInformation = {"target" : target, "type" : type, "template" : template, "lastPos" : lastPos, "force" : true};
+    
     // Initialise the carried count if necessary
     if (!this.carrying[type.generic])
         this.carrying[type.generic] = 0;
@@ -208 +225 @@
 
     this.carrying[type.generic] += status.amount;
 
-    this.lastCarriedType = type;
-
     // Update stats of how much the player collected.
     // (We have to do it here rather than at the dropsite, because we
     // need to know what subtype it was)
@@ -339 +354 @@
     Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
+/**
+ * Re-gather the last type of resource we carried
+ */
+ResourceGatherer.prototype.BackToWork = function()
+{
+    var cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
+    
+    if(cmpUnitAI && this.lastWorkInformation)
+    {
+        cmpUnitAI.AddOrder("Gather", this.lastWorkInformation, false);
+        return true;
+    }
+    else
+        return false;
+}
+    
+
 Engine.RegisterComponentType(IID_ResourceGatherer, "ResourceGatherer", ResourceGatherer);

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

@@ -390 +390 @@
                 notifyUnloadFailure(player, garrisonHolder)
         }
         break;
+        
+    case "back-to-work":
+        var entities = FilterEntityList(cmd.workers, player, controlAllUnits);
+        for each (var worker in entities)
+        {
+            var cmpResourceGatherer = Engine.QueryInterface(worker, IID_ResourceGatherer);
+            if (!cmpResourceGatherer || !cmpResourceGatherer.BackToWork())
+                notifyBackToWorkFailure(player, worker)
+        }
+        break;
 
     case "formation":
         GetFormationUnitAIs(entities, player, cmd.name).forEach(function(cmpUnitAI) {
@@ -518 +528 @@
 }
 
 /**
+ * Sends a GUI notification about worker(s) that failed to go back to work.
+ */
+function notifyBackToWorkFailure(player, worker)
+{
+    var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
+    var notification = {"player": cmpPlayer.GetPlayerID(), "message": "This worker can't go back to work" };
+    var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+    cmpGUIInterface.PushNotification(notification);
+}
+
+/**
  * Get some information about the formations used by entities.
  * The entities must have a UnitAI component.
  */