Ticket #2357: idle_worker_blink.patch

binaries/data/mods/public/gui/common/colorFades.js

@@ -1 +1 @@
 /*
-    DESCRIPTION : Some functions to make colour fades on GUI elements (f.e. used for hero and group icons)
+    DESCRIPTION : Some functions to make color fades on GUI elements (f.e. used for hero and group icons)
     NOTES       :
 */
 
-// Used for storing object names of running color fades in order to stop them, if the fade is restarted before the old ended
-var g_colorFade = {};
-g_colorFade["id"] = {};
-g_colorFade["tick"] = {};
+// Used for storing information about color fades
+var g_colorFade = {}; 
 
 /**
- * starts fading a colour of a GUI object using the sprite argument
- * name: name of the object which colour should be faded
- * changeInterval: interval in ms when the next colour change should be made
- * duration: maximal duration of the complete fade
- * colour: RGB + opacity object with keys r,g,b and o
+ * starts fading a color of a GUI object using the sprite argument
+ * name: name of the object which color should be faded
+ * tickInterval: interval in ms when the next color change should be made
+ * duration: maximal duration of the complete fade (if 0 it runs until it is stopped)
  * fun_colorTransform: function which transform the colors; 
- *                    arguments: [colour object, tickCounter] 
+ *                    arguments: [color object, tickCounter] 
+ * restartAble [optional: if false, the fade can not be restarted; default: true
  * fun_smoothRestart [optional]: a function, which returns a smooth tick counter, if the fade should be started; 
  *                              arguments: [tickCounter of current fade; not smaller than 1 or it restarts at 0] returns: smooth tick counter value
- * tickCounter [optional]: should not be set by hand! - how often the function was called recursively
  */
-function fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter)
+function startColorFade(name, tickInterval, duration, fun_colorTransform, restartAble, fun_smoothRestart)
 {
     // get the overlay
     var overlay = Engine.GetGUIObjectByName(name);
@@ -28 +25 @@
         return;
 
     // check, if fade overlay was started just now
-    if (!tickCounter)
+    if (!isColorFadeRunning(name))
     {
-        tickCounter = 1;
         overlay.hidden = false;
-                    
-        // check, if another animation is running and restart it, if it's the case
-        if (isColourFadeRunning(name)) 
-        {
-            restartColourFade(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, g_colorFade.tick[name]);
-            return;
-        }
+        
+        // store the values into a var to make it more flexible (can be changed from every function)
+        var data = {};
+        data.timerId = -1;
+        data.tickInterval = tickInterval;
+        data.duration = duration;
+        data.fun_colorTransform = fun_colorTransform;
+        data.restartAble = restartAble !== false;
+        data.fun_smoothRestart = fun_smoothRestart;
+        data.tickCounter = 1;
+        data.runsUntilStop = duration == 0;
+        data.stopFade = false;
+        var rgb = {"r": 255,"g": 255,"b": 255,"o": 100};
+        data.rgb = rgb;
+        // store it!
+        g_colorFade[name] = data;
+
+        // start with fading
+        fadeColorTick(name);
     }
-    
-    // get colors
-    fun_colorTransform(colour, tickCounter);
-    
-    // set new colour
-    overlay.sprite="colour: "+colour.r+" "+colour.g+" "+colour.b+" "+colour.o;
+    else if (restartAble)
+    {
+        restartColorFade(name, tickInterval, duration, fun_colorTransform, restartAble, fun_smoothRestart);
+        return;
+    }
+}
 
+/**
+ * makes the color changes in a tick
+ * name: name of the object which color should be faded
+ */
+function fadeColorTick(name)
+{
+    // make some checks
+    if (!isColorFadeRunning(name))
+        return;
+        
+    var overlay = Engine.GetGUIObjectByName(name);
+    if (!overlay)
+        return;
+        
+    var data = g_colorFade[name];
+        
+    // change the color
+    data.fun_colorTransform(data);
+
+    // set new color
+    var rgb = data.rgb;
+    overlay.sprite="colour: "+rgb.r+" "+rgb.g+" "+rgb.b+" "+rgb.o;
+
     // recusive call, if duration is positive
-    duration-= changeInterval; 
-    if (duration > 0 && colour.o > 0)
+    if (!data.stopFade && (data.runsUntilStop || data.duration - (data.tickInterval * data.tickCounter) > 0))
     {
-        var id = setTimeout(function() { fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, ++tickCounter); }, changeInterval);
-        g_colorFade.id[name] = id;
-        g_colorFade.tick[name] = tickCounter;
+        var id = setTimeout(function() { fadeColorTick(name); }, data.tickInterval);
+        data.timerId = id;
+        data.tickCounter++;
     }
     else 
     {
         overlay.hidden = true;
-        stopColourFade(name);
+        stopColorFade(name);
     }
 }
 
-
 /**
- * checks, if a colour fade on that object is running
- * name: name of the object which colour fade should be checked
+ * checks, if a color fade on that object is running
+ * name: name of the object which color fade should be checked
  * return: true a running fade was found
  */
-function isColourFadeRunning(name)
+function isColorFadeRunning(name)
 {
-    return name in g_colorFade.id;
+    return name in g_colorFade;
 }
 
 /**
- * stops fading a colour
- * name: name of the object which colour fade should be stopped
- * hideOverlay: hides the overlay, if true
+ * stops fading a color
+ * name: name of the object which color fade should be stopped
+ * hideOverlay [optional]: hides the overlay, if true [default: true]
  * return: true a running fade was stopped
  */
-function stopColourFade(name, hideOverlay)
+function stopColorFade(name, hideOverlay)
 {
-    // check, if a colour fade is running
-    if (!isColourFadeRunning(name))
+    // check, if a color fade is running
+    if (!isColorFadeRunning(name))
         return false;
 
     // delete the timer
-    clearTimeout(g_colorFade.id[name]);
-    delete g_colorFade.id[name];
-    delete g_colorFade.tick[name];
-    
+    clearTimeout(g_colorFade[name].timerId);
+    delete g_colorFade[name];
+
+    hideOverlay = hideOverlay !== false;
     // get the overlay and hide it
     if (hideOverlay)
     {
         var overlay = Engine.GetGUIObjectByName(name);
-        if(overlay) 
+        if (overlay) 
             overlay.hidden = true;
     }
     return true;
@@ -101 +130 @@
 }
 
 /**
- * restarts a colour fade
- * see paramter in fadeColour function
+ * restarts a color fade
+ * see paramter in startColorFade function
  */
-function restartColourFade(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter)
+function restartColorFade(name)
 {
-    // check, if a colour fade is running
-    if (!isColourFadeRunning(name))
+    // check, if a color fade is running
+    if (!isColorFadeRunning(name))
         return false;
     
+    var data = g_colorFade[name];
     // check, if fade can be restarted smoothly
-    if (fun_smoothRestart)
+    if (data.fun_smoothRestart)
     {
-        tickCounter = fun_smoothRestart(colour, tickCounter);
-        // set new function to existing timer
-        var fun = function() { fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter); };
-        setNewTimerFunction(g_colorFade.id[name], fun);
+        data.fun_smoothRestart(data);
     }
     // stop it and restart it
     else
     {
-        stopColourFade(name, true);
-        fadeColour(name, changeInterval, duration, colour, fun_colorTransform);
+        stopColorFade(name, false);
+        startColorFade(name, data.changeInterval, data.duration, data.fun_colorTransform, data.restartAble, data.fun_smoothRestart);
     }
     return true;
 }
@@ -133 +160 @@
 
 var g_fadeAttackUnit = {};
 g_fadeAttackUnit.blinkingTicks = 50; // how many ticks should first blinking phase be
-g_fadeAttackUnit.blinkingChangeInterval = 5; // how often should the colour be changed during the blinking phase
-g_fadeAttackUnit.gbColourChangeRate = 3; // how fast should blue and green part of the colour change
+g_fadeAttackUnit.blinkingChangeInterval = 5; // how often should the color be changed during the blinking phase
+g_fadeAttackUnit.gbcolorChangeRate = 3; // how fast should blue and green part of the color change
 g_fadeAttackUnit.fadeOutStart = 100; // when should the fade out start using the opacity
 g_fadeAttackUnit.opacityChangeRate = 3; // how fast should opacity change
 
-/**
- * rgb: colour object with keys r,g,b and o
- * tickCounter: how often the fade was executed
- */
-function colourFade_attackUnit(rgb, tickCounter)
+function colorFade_attackUnit(data)
 {
+    var rgb = data.rgb;
+    // init color
+    if (data.tickCounter == 1)
+        rgb.r = 175;
     // blinking
-    if (tickCounter < g_fadeAttackUnit.blinkingTicks) 
+    if (data.tickCounter < g_fadeAttackUnit.blinkingTicks) 
     {
         // slow that process down
-        if (tickCounter % g_fadeAttackUnit.blinkingChangeInterval != 0) 
+        if (data.tickCounter % g_fadeAttackUnit.blinkingChangeInterval != 0) 
             return;
             
-        rgb.g = rgb.g == 0 ? 255 : rgb.g = 0;
-        rgb.b = rgb.b == 0 ? 255 : rgb.b = 0;
+        rgb.g = rgb.g == 0 ? 255 : 0;
     }
-    // wait a short time and then colour fade from red to grey to nothing
-    else if ( tickCounter >= g_fadeAttackUnit.blinkingTicks + g_fadeAttackUnit.blinkingChangeInterval) 
+    // wait a short time and then color fade from red to grey to nothing
+    else if ( data.tickCounter >= g_fadeAttackUnit.blinkingTicks + g_fadeAttackUnit.blinkingChangeInterval) 
     {
-        rgb.g = rgb.g < 255 ? rgb.g += g_fadeAttackUnit.gbColourChangeRate * Math.sqrt(tickCounter - g_fadeAttackUnit.blinkingTicks) : 255;
-        rgb.b = rgb.g;
+        rgb.g = rgb.g < 255 ? rgb.g += g_fadeAttackUnit.gbcolorChangeRate * Math.sqrt(data.tickCounter - g_fadeAttackUnit.blinkingTicks) : 255;
         
         // start with fading it out
         if (rgb.g > g_fadeAttackUnit.fadeOutStart) 
             rgb.o = rgb.o > g_fadeAttackUnit.opacityChangeRate ? rgb.o -= g_fadeAttackUnit.opacityChangeRate : 0;
+        // check for end
+        if (rgb.o == 0)
+            data.stopFade = true;
     }
+    rgb.b = rgb.g;
 }
 
-/**
- * makes a smooth fade, if the attack on the unit has not stopped yet
- * rgb: colour object with keys r,g,b and o
- * tickCounter: how often the fade was executed
- */
-function smoothColourFadeRestart_attackUnit(rgb, tickCounter)
+function smoothColorFadeRestart_attackUnit(data)
 {
     // check, if in blinking phase
-    if (tickCounter < g_fadeAttackUnit.blinkingTicks) 
+    if (data.tickCounter < g_fadeAttackUnit.blinkingTicks) 
     {
-        // get rgb to current state
-        for (var i = 1; i <= tickCounter; i++)
-            colourFade_attackUnit(rgb, i);
-        // set the tick counter back to start
-        return (tickCounter % (g_fadeAttackUnit.blinkingChangeInterval * 2)) + 1;
+        // set the tick counter back to a smooth position
+        data.tickCounter = (data.tickCounter % (g_fadeAttackUnit.blinkingChangeInterval * 2)) + 1;
     }
-    return 1;
+    data.tickCounter = 1;
 }
 
-//[END] of hero fade functions
- No newline at end of file
+//[END] of hero fade functions
+//[START] idle workers icon
+
+//var g_fadeIdleWorker = {};
+
+function colorFade_IdleWorker(data)
+{
+    var rgb = data.rgb;
+    rgb.g = rgb.g == 0 ? 255 : 0;
+    rgb.b = rgb.g;
+    if (rgb.g == 0)
+        rgb.o = 0;
+    else
+        rgb.o = 100;
+}
+
+//[END] of idle workers icon functions
+ No newline at end of file

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

@@ -478 +478 @@
 
     updateHero();
     updateGroups();
+    updateIdleWorkerButton();
     updateDebug();
     updatePlayerDisplay();
     updateSelectionDetails();
@@ -491 +492 @@
     if (battleState)
         global.music.setState(global.music.states[battleState]);
     
+};
+
+function updateIdleWorkerButton()
+{
+    var idleUnitsCounter = Engine.GuiInterfaceCall("getNumberOfIdleUnits");
+
+    if (idleUnitsCounter != 0)
+        startColorFade("idleWorkerOverlay", 500, 0, colorFade_IdleWorker, false);
+    else
+        stopColorFade("idleWorkerOverlay");
+    
 }
 
+
 /**
 * updates a status bar on the GUI
 * nameOfBar: name of the bar
@@ -587 +600 @@
     {   
         g_previousHeroHitPoints = heroState.hitpoints;
         // trigger the animation
-        fadeColour("heroHitOverlay", 100, 10000, {"r": 175,"g": 0,"b": 0,"o": 100}, colourFade_attackUnit, smoothColourFadeRestart_attackUnit);
+        startColorFade("heroHitOverlay", 100, 0, colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
         return;
     }
 }

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

@@ -951 +951 @@
             >
             <!-- TODO: should highlight the button if there's non-zero idle workers -->
             <object size="0 0 100% 100%" type="image" sprite="idleWorker" ghost="true" />
+            <object name="idleWorkerOverlay" hidden="true" type="image" ghost="true" size="2 2 100%-2 100%-2"/> 
             <action on="Press">findIdleUnit(["Female", "Trade", "FishingBoat", "CitizenSoldier", "Healer"]);</action>
             </object>
         </object>

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

@@ -1709 +1709 @@
     PlaySound(data.name, data.entity);
 };
 
+GuiInterface.prototype.getNumberOfIdleUnits = function(player)
+{
+    var entities = this.GetPlayerEntities(player);
+    var cmpUnitAI = Engine.QueryInterface(entities[0], IID_UnitAI);
+    if (!cmpUnitAI)
+        return 0;
+    return cmpUnitAI.getNumberOfIdleUnits();
+}
+
 function isIdleUnit(ent, idleClass)
 {
     var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
@@ -1946 +1955 @@
     "SetWallPlacementPreview": 1,
     "GetFoundationSnapData": 1,
     "PlaySound": 1,
+    "getNumberOfIdleUnits": 1,
     "FindIdleUnits": 1,
     "GetTradingRouteGain": 1,
     "GetTradingDetails": 1,

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

@@ -169 +169 @@
     "GuardedAttacked": function(msg) {
         // ignore
     },
+    
+    "UnitIdleChanged": function(msg) {
+        // check if this are units which can be selected by the workes idle button
+        if(this.IsUsedForIdleWorkerButton())
+        {
+            if(msg.idle)
+                increaseIdleCount(msg.player);
+            else
+                decreaseIdleCount(msg.player);
+        }
+    },
 
     // Formation handlers:
 
@@ -3036 +3047 @@
     return Engine.QueryInterface(this.entity, IID_Heal);
 };
 
+UnitAI.prototype.IsUsedForIdleWorkerButton = function()
+{
+    var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+    if (!cmpIdentity)
+        return false;
+    // check idle class names   
+    for each(var className in g_idleClassNames)
+        if (cmpIdentity.HasClass(className)) {
+            return true;
+        }
+    // return false because all checks where negative
+    return false;
+};
+
 UnitAI.prototype.IsIdle = function()
 {
     return this.isIdle;
@@ -3100 +3125 @@
         if(!this.isGarrisoned)
             this.Stop(false);
     }
+    // check for idleWorks
+    else if (this.isIdle)
+    {
+        // idle worker gone 
+        if (msg.to == -1)
+        {
+            decreaseIdleCount(msg.from);
+            increaseIdleCount(msg.to);
+        }
+        // new idle worker
+        else
+        {
+            decreaseIdleCount(msg.to);
+            increaseIdleCount(msg.from);
+        }
+    }
 };
 
 UnitAI.prototype.OnDestroy = function()
@@ -3682 +3723 @@
     UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
 };
 
+UnitAI.prototype.OnUnitIdleChanged = function(msg)
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (!cmpOwnership)
+        return;
+    UnitFsm.ProcessMessage(this, {"type": "UnitIdleChanged", "idle": msg.idle, "player": cmpOwnership.GetOwner()});
+}
+
 //// Helper functions to be called by the FSM ////
 
 UnitAI.prototype.GetWalkSpeed = function()
@@ -5481 +5530 @@
     );
 };
 
+UnitAI.prototype.getNumberOfIdleUnits = function()
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (!cmpOwnership)
+        return 0;
+    if (!isIdleCountDefined(cmpOwnership.GetOwner()))
+        return 0;
+    return getIdleCount(cmpOwnership.GetOwner());
+}
+
+var g_idleClassNames = ["Female", "Trade", "FishingBoat", "CitizenSoldier", "Healer"];
+var g_idleUnitsCounter = {};
+
+function increaseIdleCount(player)
+{
+    if (player == -1)
+        return;
+    if (!isIdleCountDefined(player))
+        g_idleUnitsCounter[player] = 1;
+    else
+        g_idleUnitsCounter[player]++;
+}
+
+function decreaseIdleCount(player)
+{
+    if (player == -1)
+        return;
+    // should not happen
+    if (!isIdleCountDefined(player))
+        error("Negative idle worker count for player '" + player + "'");
+    else
+        g_idleUnitsCounter[player]--;
+}
+
+function isIdleCountDefined(player)
+{
+    return (player in g_idleUnitsCounter);
+}
+
+function getIdleCount(player)
+{
+    if (!isIdleCountDefined(player))
+        return 0;
+    else
+        return g_idleUnitsCounter[player];
+}
+
 Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);