Ticket #2162: group_health_patch_v2.2.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
+ * returns the init RGB color setting
+ */
+function getInitColorFadeRGB()
+{
+    var rgb = {};
+    rgb.r = 0;
+    rgb.g = 0;
+    rgb.b = 0;
+    rgb.o = 100;
+    return rgb;
+}
+
+/**
+ * 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: [var data] 
+ * 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
+ *                               arguments: [var data]; must return false, if smooth restart was not possible and true, if it was ok
  */
-function fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter)
+function startColorFade(name, tickInterval, duration, fun_colorTransform, restartAble, fun_smoothRestart) // TODO: replace restartAble = true, fun_smoothRestart = null when it is supported (spiderMonkey upgrade #1886)
 {
     // get the overlay
     var overlay = Engine.GetGUIObjectByName(name);
@@ -28 +38 @@
         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;  // TODO: ' !== false' and add default parameter
+        data.fun_smoothRestart = fun_smoothRestart;
+        data.tickCounter = 0;
+        data.runsUntilStop = duration == 0;
+        data.stopFade = false;
+        data.rgb = getInitColorFadeRGB();
+
+        // store it!
+        g_colorFade[name] = data;
+
+        // start with fading
+        fadeColorTick(name);
     }
+    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);
     
-    // get colors
-    fun_colorTransform(colour, tickCounter);
-    
-    // set new colour
-    overlay.sprite="colour: "+colour.r+" "+colour.g+" "+colour.b+" "+colour.o;
+    // 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) //TODO: add 'hideOverlay = true' when its supported (spiderMonkey upgrade #1886)
 {
-    // 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; // TODO: remove this line and add default value for hideOverlay
     // get the overlay and hide it
     if (hideOverlay)
     {
         var overlay = Engine.GetGUIObjectByName(name);
-        if(overlay) 
+        if (overlay)
             overlay.hidden = true;
     }
     return true;
@@ -101 +142 @@
 }
 
 /**
- * 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);
+        // if call was too late
+        if (!data.fun_smoothRestart(data))
+        {
+            data.rgb = getInitColorFadeRGB(); // set RGB start values
+            data.tickCounter = 0;
+        }
     }
     // 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 +177 @@
 
 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 == 0)
+        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;
+        data.tickCounter = data.tickCounter % (g_fadeAttackUnit.blinkingChangeInterval * 2);
+        data.rgb.o = getInitColorFadeRGB().o;
+        return true;
     }
-    return 1;
+    return false;
 }
 
 //[END] of hero fade functions
+ No newline at end of file

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

@@ -106 +106 @@
     return this.groups[templateName];
 };
 
+EntityGroups.prototype.hasMembers = function()
+{
+    return Object.keys(this.groups).length != 0;
+};
+
 EntityGroups.prototype.getTotalCount = function()
 {
     var totalCount = 0;
@@ -442 +447 @@
 function EntityGroupsContainer()
 {
     this.groups = [];
+    this.info = [];
+    // init groups 0 to 9
     for (var i = 0; i < 10; ++i)
     {
         this.groups[i] = new EntityGroups();
+        var data = {}; // hitpoints, maxGroupHitPoints, numberOfUnits, initialNumberOfUnits, deathCycle, dirty, attack
+        this.info[i] = data;
     }
 }
 
-EntityGroupsContainer.prototype.addEntities = function(groupName, ents)
+/**
+ * adds entities to the group
+ * groupID: id of the group
+ * ents: array of entity IDs
+ */
+EntityGroupsContainer.prototype.addEntities = function(groupID, ents)
 {
     for each (var ent in ents)
     {
-        for each (var group in this.groups)
+        // remove the entity out of all other groups
+        for (var gID in this.groups)
         {
+            var group = this.groups[gID];
             if (ent in group.ents)
             {
                 group.removeEnt(ent);
+                this.removeEnt(gID, ent); // is used because fade and icon should not be triggered if a unit comes to another group
+                break;
             }
         }
     }
-    this.groups[groupName].add(ents);
+    // add entities to group
+    this.groups[groupID].add(ents);
+    this.updateAdditionalData(groupID, ents, true);
 }
 
+/**
+ * removes a entity from the info data
+ * groupID: id of the group
+ * ent: entity ID
+ */
+EntityGroupsContainer.prototype.removeEnt = function(groupID, ent)
+{
+    if (!this.hasMembers(groupID))
+        return;
+    var entState = GetEntityState(+ent);
+    if (!entState)
+        return;
+    
+    // update the data like this unit would never be in this group
+    var data = this.info[groupID];  
+    data.hitpoints -= entState.hitpoints;
+    data.maxGroupHitPoints -= entState.maxHitpoints;
+    data.numberOfUnits--;
+    data.initialNumberOfUnits--;
+    data.dirty = true;
+    warn(JSON.stringify(data));
+}
+
+/**
+ * updates the additional info of a group; can be called for init or update but should only be called, if needed
+ * groupID: id of the group
+ * ents: array of entity IDs
+ * init: true, if init
+ */
+EntityGroupsContainer.prototype.updateAdditionalData = function(groupID, ents, init)
+{
+    if (!this.hasMembers(groupID))
+        return;
+
+    if (init)
+    {
+        var data = {};
+        data.dirty = true; // true, if GUI should be updated
+        data.attack = false; // true, if GUI should start color attack animation
+        data.hitpoints = 0;
+        data.maxGroupHitPoints = 0;
+        data.numberOfUnits = ents.length;
+        data.initialNumberOfUnits = data.numberOfUnits;
+        data.deathCycle = 0; // used for death icon
+        
+        // update the additional info
+        if (data.numberOfUnits > 0)
+            this.info[groupID] = data;
+        else
+            this.info[groupID] = {};
+    }
+
+    // update the values needed for the GUI
+    this.updateHealth(groupID);
+    this.updateMaxHealth(groupID);
+    this.updateMembers(groupID);
+}
+
+/**
+ * updates the current health points of a group
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.updateHealth = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+        
+    var data = this.info[groupID];  
+    var hitpoints = 0;
+    // calculate health
+    for (var ent in this.groups[groupID].ents)
+    {
+        var entState = GetEntityState(+ent);
+        hitpoints += entState.hitpoints;
+    }
+
+    // check, if attack is running.
+    if (hitpoints < data.hitpoints)
+        data.attack = true;
+    // update prev points
+    if (hitpoints != data.hitpoints)
+    {
+        data.hitpoints = hitpoints;
+        data.dirty = true;
+    }
+}
+
+/**
+ * updates the member count of the group
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.updateMembers = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+
+    var data = this.info[groupID];
+    var numberOfUnits = this.groups[groupID].getTotalCount();
+    if (numberOfUnits < data.numberOfUnits)
+    {
+        // update unit count
+        data.numberOfUnits = numberOfUnits;
+        data.deathCycle = 1; // show death symbol
+        // update max health of the group
+        this.updateMaxHealth(groupID);
+        data.dirty = true;
+    }   
+}
+
+/**
+ * updates the max health a group can have
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.updateMaxHealth = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+
+    var data = this.info[groupID];
+    data.maxGroupHitPoints = 0;
+    for (var ent in this.groups[groupID].ents)
+    {
+        var entState = GetEntityState(+ent);
+        data.maxGroupHitPoints += entState.maxHitpoints;
+    }
+}
+
+/**
+ * updates the death cycle icon
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.updateDeathCycle = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+
+    var data = this.info[groupID];
+    if (data.deathCycle > 0)
+        data.deathCycle++;
+    if (data.deathCycle >= g_groupDeathShowIconTicks)
+        data.dirty = true;
+}
+
+/**
+ * checks, if some entities where removed or renamed
+ */
 EntityGroupsContainer.prototype.update = function()
 {
     this.checkRenamedEntities();
-    for each (var group in this.groups)
+    for (var groupID in this.groups)
     {
+        // nothing to do, if no members are there
+        if (!this.hasMembers(groupID))
+            continue;
+            
+        var group = this.groups[groupID];
         for (var ent in group.ents)
         {
             var entState = GetEntityState(+ent);
@@ -474 +645 @@
 
             // Remove deleted units
             if (!entState)
-            {
                 group.removeEnt(ent);
-            }
         }
+        // update the values needed for the GUI
+        this.updateHealth(groupID);
+        this.updateMembers(groupID);    
+        this.updateDeathCycle(groupID);
     }
 }
 
@@ -494 +667 @@
         for each (var renamedEntity in renamedEntities)
             renamedLookup[renamedEntity.entity] = renamedEntity.newentity;
 
-        for each (var group in this.groups)
+        for (var groupID in this.groups)
         {
+            var group = this.groups[groupID];
             for each (var renamedEntity in renamedEntities)
             {
                 // Reconstruct the group if at least one entity has been renamed.
@@ -502 +676 @@
                 if (renamedEntity.entity in group.ents)
                 {
                     group.rebuildGroup(renamedLookup);
+                    this.updateAdditionalData(groupID, Object.keys(group.ents), false);
                     break;
                 }
             }
@@ -509 +684 @@
     }
 }
 
+/**
+ * resets the initialNumberOfUnits
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.resetMemberStatus = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+        
+    var data = this.info[groupID];
+    data.initialNumberOfUnits = data.numberOfUnits;
+    data.dirty = true;
+}
+
+/**
+ * checks, if a group with that ID has members
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.hasMembers = function(groupID)
+{
+    return this.groups[groupID].hasMembers();
+}
+
+/**
+ * gets the dirty state for the GUI
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.isDirty = function(groupID)
+{
+    return this.hasMembers(groupID) && this.info[groupID].dirty;
+}
+
+/**
+ * sets the dirty state to false after the GUI redrawed the stuff
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.resetDirty = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+        
+    this.info[groupID].dirty = false;
+}
+
+/**
+ * gets the attack state for the GUI
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.isAttacked = function(groupID)
+{
+    return this.hasMembers(groupID) && this.info[groupID].attack;
+}
+
+/**
+ * sets the attack state to false after the color fade was started
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.resetAttack = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+        
+    this.info[groupID].attack = false;
+}
+
+/**
+ * sets the death cycle back to zero (off)
+ * groupID: id of the group
+ */
+EntityGroupsContainer.prototype.resetDeathCycle = function(groupID)
+{
+    if (!this.hasMembers(groupID))
+        return;
+        
+    this.info[groupID].deathCycle = 0;
+}
+
 var g_Groups = new EntityGroupsContainer();

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

@@ -56 +56 @@
 // always through the list of all ongoing attacks...
 var g_previousHeroHitPoints = undefined;
 
+// simulation ticks until the deathIcon of a group is removed.
+var g_groupDeathShowIconTicks = 60; 
+
 function GetSimState()
 {
     if (!g_SimState)
@@ -165 +168 @@
     Engine.GetGUIObjectByName("civIcon").sprite = "stretched:" + g_CivData[g_Players[Engine.GetPlayerID()].civ].Emblem;
     Engine.GetGUIObjectByName("civIcon").tooltip = g_CivData[g_Players[Engine.GetPlayerID()].civ].Name;
     initMenuPosition(); // set initial position
+    initLayoutGroupButtons(); // init group buttons
 
     // Populate player selection dropdown
     var playerNames = [];
@@ -211 +215 @@
     setTimeout(function() { reportPerformance(60); }, 60000);
 }
 
+// inits the layout of the group buttons (adds spacers, labels and events to buttons)
+function initLayoutGroupButtons()
+{
+    var guiName = "Group";
+    for (var i = 0; i < 10; i++)
+    {
+        // add spacers
+        var buttonSideLength = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]").size.bottom;
+        var buttonSpacer = buttonSideLength+12;
+        layoutButtonRow(i, guiName, buttonSideLength, buttonSpacer, i, i+1);
+            
+        // add label
+        var label = Engine.GetGUIObjectByName("unit"+guiName+"Label["+i+"]").caption = i;
+        
+        // add button events and hide it
+        var button = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]");
+        button.onpress = (function(i) { return function() { performGroup((Engine.HotkeyIsPressed("selection.add") ? "add" : "select"), i); } })(i);
+        button.ondoublepress = (function(i) { return function() { performGroup("snap", i); } })(i);
+        button.onpressright = (function(i) { return function() { performGroup("breakUp", i); } })(i);
+        button.hidden = true;
+        
+        // get the members status bar and add a event
+        var memberButton = Engine.GetGUIObjectByName("unit"+guiName+"MembersButton["+i+"]");
+        memberButton.onpress = (function(i) { return function() { g_Groups.resetMemberStatus(i); } })(i);
+    }
+}
+
 function selectViewPlayer(playerID)
 {
     Engine.SetPlayerID(playerID);
@@ -311 +342 @@
     var data = {};
     data.playerAssignments = g_PlayerAssignments;
     data.groups = g_Groups.groups;
+    data.additionalGroupInfo = g_Groups.info;
     // TODO: any other gui state?
     return data;
 }
@@ -325 +357 @@
     {
         g_Groups.groups[groupNumber].groups = data.groups[groupNumber].groups;
         g_Groups.groups[groupNumber].ents = data.groups[groupNumber].ents;
+        g_Groups.info[groupNumber] = data.additionalGroupInfo[groupNumber];
+        g_Groups.info[groupNumber].dirty = true;
     }
     updateGroups();
 }
@@ -498 +532 @@
     var battleState = Engine.GuiInterfaceCall("GetBattleState", Engine.GetPlayerID());
     if (battleState)
         global.music.setState(global.music.states[battleState]);
-    
 }
 
 /**
@@ -510 +543 @@
 */
 function updateGUIStatusBar(nameOfBar, points, maxPoints, direction) 
 {
+    // check, if values are valid
+    if (!(points && maxPoints))
+        return;
     // check, if optional direction parameter is valid.
     if (!direction || !(direction >= 0 && direction < 4))
         direction = 0;
@@ -523 +559 @@
     var value = 100*Math.max(0, Math.min(1, points / maxPoints));
     
     // inverse bar
-    if(direction == 2 || direction == 3) 
+    if (direction == 2 || direction == 3) 
         value = 100 - value;
 
-    if(direction == 0)
+    if (direction == 0)
         healthSize.rright = value;
-    else if(direction == 1)
+    else if (direction == 1)
         healthSize.rbottom = value;
-    else if(direction == 2)
+    else if (direction == 2)
         healthSize.rleft = value;
-    else if(direction == 3)
+    else if (direction == 3)
         healthSize.rtop = value;
     
     // update bar
@@ -539 +575 @@
     statusBar.size = healthSize;
 }
 
+/**
+* changes the visibility of a status bar
+* nameOfBar: name of the bar
+* hide: true, if bar should be hidden
+*/
+function changeVisibilityStatusBar(nameOfBar, hide) 
+{
+    // get the bar and update it
+    var statusBar = Engine.GetGUIObjectByName(nameOfBar);
+    if (!statusBar) 
+        return;
+    
+    statusBar.hidden = hide;
+}
 
+
+
 function updateHero()
 {
     var simState = GetSimState();
@@ -595 +647 @@
     {   
         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;
     }
 }
 
 
+// updates the groups on the GUI
 function updateGroups()
 {
     var guiName = "Group";
     g_Groups.update();
-    for (var i = 0; i < 10; i++)
-    {
-        var button = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]");
-        var label = Engine.GetGUIObjectByName("unit"+guiName+"Label["+i+"]").caption = i;
-        if (g_Groups.groups[i].getTotalCount() == 0)
-            button.hidden = true;
+        for (var i = 0; i < 10; i++)
+    {
+        var button = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]");
+        // check, if group has members
+        if (!g_Groups.hasMembers(i))
+        {
+            button.hidden = true;
+            stopColorFade("unitGroupHitOverlay["+i+"]");
+            var deathIcon = Engine.GetGUIObjectByName("unitGroupIconDeath["+ i +"]");
+            deathIcon.hidden = true;        
+            continue; // nothing to do, if group has no members
+        }
+        else
+            button.hidden = false; // make button visible
+                        
+        // check, if status bars must be redrawn
+        if (!g_Groups.isDirty(i))
+        continue;
+
+        // update the status bars
+        var data = g_Groups.info[i];
+        updateGUIStatusBar("unitGroupHealthBar["+ i +"]", data.hitpoints, data.maxGroupHitPoints);
+        
+        if(data.initialNumberOfUnits == 1)
+            changeVisibilityStatusBar("unitGroupMembersButton["+ i +"]", true);
         else
-            button.hidden = false;
-        button.onpress = (function(i) { return function() { performGroup((Engine.HotkeyIsPressed("selection.add") ? "add" : "select"), i); } })(i);
-        button.ondoublepress = (function(i) { return function() { performGroup("snap", i); } })(i);
-        button.onpressright = (function(i) { return function() { performGroup("breakUp", i); } })(i);
-    }
-    var numButtons = i;
-    var rowLength = 1;
-    var numRows = Math.ceil(numButtons / rowLength);
-    var buttonSideLength = Engine.GetGUIObjectByName("unit"+guiName+"Button[0]").size.bottom;
-    var buttonSpacer = buttonSideLength+1;
-    for (var i = 0; i < numRows; i++)
-        layoutButtonRow(i, guiName, buttonSideLength, buttonSpacer, rowLength*i, rowLength*(i+1) );
+        {
+            changeVisibilityStatusBar("unitGroupMembersButton["+ i +"]", false);
+            updateGUIStatusBar("unitGroupMembersBar["+ i +"]", data.numberOfUnits, data.initialNumberOfUnits, 3);
+        }
+        
+        // check, if the attack should be started
+        if (g_Groups.isAttacked(i))
+        {
+            startColorFade("unitGroupHitOverlay["+i+"]", 100, 10000, colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
+            g_Groups.resetAttack(i);
+        }
+        
+        // check, if the death symbol should be triggered
+        if (data.deathCycle > 0)
+        {
+            var deathIcon = Engine.GetGUIObjectByName("unitGroupIconDeath["+ i +"]");
+            // show the symbol
+            if (data.deathCycle >= g_groupDeathShowIconTicks)
+            {
+                deathIcon.hidden = true;
+                g_Groups.resetDeathCycle(i);
+            }
+            else if (data.deathCycle >= 1)
+                deathIcon.hidden = false;
+        }
+        
+        // reset the dirty state after the updates are complete
+        g_Groups.resetDirty(i);
+    }
 }
 
 function updateDebug()

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

@@ -904 +904 @@
     >
         <repeat count="10">
             <object name="unitGroupButton[n]" size="0 0 36 36" type="button" hidden="false" style="iconButton" tooltip_style="sessionToolTipBottomBold"
-                tooltip="Click to select grouped units, double-click to focus the grouped units and right-click to disband the group."
-            >
+                tooltip="Click to select grouped units, double-click to focus the grouped units and right-click to disband the group.">
                 <object name="unitGroupIcon[n]" size="3 3 33 33" type="image" sprite="groupsIcon" ghost="true"/>
+                <object name="unitGroupHitOverlay[n]" hidden="true" type="image" ghost="true" size="3 3 33 33"/> 
                 <object name="unitGroupLabel[n]" type="text" style="largeCenteredOutlinedText" ghost="true"/>
+                <object name="unitGroupIconDeath[n]" size="21 3 35 17" type="image" sprite="killIcon" hidden="true" ghost="true"/>
+                <!-- Group Health bar -->
+                <object size="2 37 34 40" name="unitGroupHealthSection[n]">
+                    <object size="0 0 100% 4" name="unitGroupHealth[n]" ghost="true" type="image">
+                    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
+                    <object type="image" sprite="healthBackground" ghost="true"/> 
+                        <object type="image" sprite="healthForeground" ghost="true" name="unitGroupHealthBar[n]"/> 
+                        <object type="image" sprite="statsBarShaderHorizontal" ghost="true"/>
+                    </object>
+                </object>
+                <!-- Group Health bar -->
+                <object size="37 2 40 34" name="unitGroupMembersButton[n]" type="button" tooltip_style="sessionToolTipBottomBold"
+                    tooltip="Click to reset unit counter bar.">
+                    <object size="0 0 4 100%" name="unitGroupMembers[n]" ghost="true" type="image">
+                    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
+                    <object type="image" sprite="groupSizeBackground" ghost="true"/>  
+                        <object type="image" sprite="groupSizeForeground" ghost="true" name="unitGroupMembersBar[n]"/> 
+                    <object type="image" sprite="statsBarShaderVertical" ghost="true"/>
+                    </object>
+                </object>           
             </object>
         </repeat>
     </object>

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

@@ -8 +8 @@
             size="0 0 100% 100%"
         />
     </sprite>
-
+    
+    <sprite name="killIcon">
+        <image
+            texture="session/icons/kill.png"
+            size="0 0 100% 100%"
+        />
+    </sprite>
+    
     <sprite name="idleWorker">
         <image
             texture="session/icons/repair.png"
@@ -16 +23 @@
             size="0 0 100% 100%"
         />
     </sprite>
+    
+    <sprite name="groupSizeForeground">
+        <image backcolor="255 184 0 255"/>
+    </sprite>
+    
+    <sprite name="groupSizeBackground">
+        <image backcolor="184 184 184 255"/>
+    </sprite>
 
     <!-- ================================  ================================ -->
     <!-- Menu -->