Ticket #2357: idle_worker_blink_v4.patch

File idle_worker_blink_v4.patch, 19.2 KB (added by Michael, 10 years ago)

Fixed problem with smooth reset. (opacity)

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

     
    11/*
    2     DESCRIPTION : Some functions to make colour fades on GUI elements (f.e. used for hero and group icons)
     2    DESCRIPTION : Some functions to make color fades on GUI elements (f.e. used for hero and group icons)
    33    NOTES       :
    44*/
    55
    6 // Used for storing object names of running color fades in order to stop them, if the fade is restarted before the old ended
    7 var g_colorFade = {};
    8 g_colorFade["id"] = {};
    9 g_colorFade["tick"] = {};
     6// Used for storing information about color fades
     7var g_colorFade = {};
    108
    119/**
    12  * starts fading a colour of a GUI object using the sprite argument
    13  * name: name of the object which colour should be faded
    14  * changeInterval: interval in ms when the next colour change should be made
    15  * duration: maximal duration of the complete fade
    16  * colour: RGB + opacity object with keys r,g,b and o
     10 * returns the init RGB color setting
     11 */
     12function getInitColorFadeRGB()
     13{
     14    var rgb = {};
     15    rgb.r = 0;
     16    rgb.g = 0;
     17    rgb.b = 0;
     18    rgb.o = 100;
     19    return rgb;
     20}
     21
     22/**
     23 * starts fading a color of a GUI object using the sprite argument
     24 * name: name of the object which color should be faded
     25 * tickInterval: interval in ms when the next color change should be made
     26 * duration: maximal duration of the complete fade (if 0 it runs until it is stopped)
    1727 * fun_colorTransform: function which transform the colors;
    18  *                    arguments: [colour object, tickCounter]
     28 *                     arguments: [var data]
     29 * restartAble [optional: if false, the fade can not be restarted; default: true
    1930 * fun_smoothRestart [optional]: a function, which returns a smooth tick counter, if the fade should be started;
    20  *                              arguments: [tickCounter of current fade; not smaller than 1 or it restarts at 0] returns: smooth tick counter value
    21  * tickCounter [optional]: should not be set by hand! - how often the function was called recursively
     31 *                               arguments: [var data]; must return false, if smooth restart was not possible and true, if it was ok
    2232 */
    23 function fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter)
     33function startColorFade(name, tickInterval, duration, fun_colorTransform, restartAble, fun_smoothRestart) // TODO: replace restartAble = true, fun_smoothRestart = null when it is supported (spiderMonkey upgrade #1886)
    2434{
    2535    // get the overlay
    2636    var overlay = Engine.GetGUIObjectByName(name);
    … …  
    2838        return;
    2939
    3040    // check, if fade overlay was started just now
    31     if (!tickCounter)
     41    if (!isColorFadeRunning(name))
    3242    {
    33         tickCounter = 1;
    3443        overlay.hidden = false;
    35                    
    36         // check, if another animation is running and restart it, if it's the case
    37         if (isColourFadeRunning(name))
    38         {
    39             restartColourFade(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, g_colorFade.tick[name]);
    40             return;
    41         }
     44       
     45        // store the values into a var to make it more flexible (can be changed from every function)
     46        var data = {};
     47        data.timerId = -1;
     48        data.tickInterval = tickInterval;
     49        data.duration = duration;
     50        data.fun_colorTransform = fun_colorTransform;
     51        data.restartAble = restartAble !== false;  // TODO: ' !== false' and add default parameter
     52        data.fun_smoothRestart = fun_smoothRestart;
     53        data.tickCounter = 0;
     54        data.runsUntilStop = duration == 0;
     55        data.stopFade = false;
     56        data.rgb = getInitColorFadeRGB();
     57
     58        // store it!
     59        g_colorFade[name] = data;
     60
     61        // start with fading
     62        fadeColorTick(name);
    4263    }
     64    else if (restartAble)
     65    {
     66        restartColorFade(name, tickInterval, duration, fun_colorTransform, restartAble, fun_smoothRestart);
     67        return;
     68    }
     69}
     70
     71/**
     72 * makes the color changes in a tick
     73 * name: name of the object which color should be faded
     74 */
     75function fadeColorTick(name)
     76{
     77    // make some checks
     78    if (!isColorFadeRunning(name))
     79        return;
     80       
     81    var overlay = Engine.GetGUIObjectByName(name);
     82    if (!overlay)
     83        return;
     84    var data = g_colorFade[name];
     85       
     86    // change the color
     87    data.fun_colorTransform(data);
    4388   
    44     // get colors
    45     fun_colorTransform(colour, tickCounter);
    46    
    47     // set new colour
    48     overlay.sprite="colour: "+colour.r+" "+colour.g+" "+colour.b+" "+colour.o;
     89    // set new color
     90    var rgb = data.rgb;
     91    overlay.sprite="colour: "+rgb.r+" "+rgb.g+" "+rgb.b+" "+rgb.o;
    4992
    5093    // recusive call, if duration is positive
    51     duration-= changeInterval;
    52     if (duration > 0 && colour.o > 0)
     94    if (!data.stopFade && (data.runsUntilStop || data.duration - (data.tickInterval * data.tickCounter) > 0))
    5395    {
    54         var id = setTimeout(function() { fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, ++tickCounter); }, changeInterval);
    55         g_colorFade.id[name] = id;
    56         g_colorFade.tick[name] = tickCounter;
     96        var id = setTimeout(function() { fadeColorTick(name); }, data.tickInterval);
     97        data.timerId = id;
     98        data.tickCounter++;
    5799    }
    58100    else
    59101    {
    60102        overlay.hidden = true;
    61         stopColourFade(name);
     103        stopColorFade(name);
    62104    }
    63105}
    64106
    65 
    66107/**
    67  * checks, if a colour fade on that object is running
    68  * name: name of the object which colour fade should be checked
     108 * checks, if a color fade on that object is running
     109 * name: name of the object which color fade should be checked
    69110 * return: true a running fade was found
    70111 */
    71 function isColourFadeRunning(name)
     112function isColorFadeRunning(name)
    72113{
    73     return name in g_colorFade.id;
     114    return name in g_colorFade;
    74115}
    75116
    76117/**
    77  * stops fading a colour
    78  * name: name of the object which colour fade should be stopped
    79  * hideOverlay: hides the overlay, if true
     118 * stops fading a color
     119 * name: name of the object which color fade should be stopped
     120 * hideOverlay [optional]: hides the overlay, if true [default: true]
    80121 * return: true a running fade was stopped
    81122 */
    82 function stopColourFade(name, hideOverlay)
     123function stopColorFade(name, hideOverlay) //TODO: add 'hideOverlay = true' when its supported (spiderMonkey upgrade #1886)
    83124{
    84     // check, if a colour fade is running
    85     if (!isColourFadeRunning(name))
     125    // check, if a color fade is running
     126    if (!isColorFadeRunning(name))
    86127        return false;
    87128
    88129    // delete the timer
    89     clearTimeout(g_colorFade.id[name]);
    90     delete g_colorFade.id[name];
    91     delete g_colorFade.tick[name];
    92    
     130    clearTimeout(g_colorFade[name].timerId);
     131    delete g_colorFade[name];
     132
     133    hideOverlay = hideOverlay !== false; // TODO: remove this line and add default value for hideOverlay
    93134    // get the overlay and hide it
    94135    if (hideOverlay)
    95136    {
    96137        var overlay = Engine.GetGUIObjectByName(name);
    97         if(overlay)
     138        if (overlay)
    98139            overlay.hidden = true;
    99140    }
    100141    return true;
    … …  
    101142}
    102143
    103144/**
    104  * restarts a colour fade
    105  * see paramter in fadeColour function
     145 * restarts a color fade
     146 * see paramter in startColorFade function
    106147 */
    107 function restartColourFade(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter)
     148function restartColorFade(name)
    108149{
    109     // check, if a colour fade is running
    110     if (!isColourFadeRunning(name))
     150    // check, if a color fade is running
     151    if (!isColorFadeRunning(name))
    111152        return false;
    112153   
     154    var data = g_colorFade[name];
    113155    // check, if fade can be restarted smoothly
    114     if (fun_smoothRestart)
     156    if (data.fun_smoothRestart)
    115157    {
    116         tickCounter = fun_smoothRestart(colour, tickCounter);
    117         // set new function to existing timer
    118         var fun = function() { fadeColour(name, changeInterval, duration, colour, fun_colorTransform, fun_smoothRestart, tickCounter); };
    119         setNewTimerFunction(g_colorFade.id[name], fun);
     158        // if call was too late
     159        if (!data.fun_smoothRestart(data))
     160        {
     161            data.rgb = getInitColorFadeRGB(); // set RGB start values
     162            data.tickCounter = 0;
     163        }
    120164    }
    121165    // stop it and restart it
    122166    else
    123167    {
    124         stopColourFade(name, true);
    125         fadeColour(name, changeInterval, duration, colour, fun_colorTransform);
     168        stopColorFade(name, false);
     169        startColorFade(name, data.changeInterval, data.duration, data.fun_colorTransform, data.restartAble, data.fun_smoothRestart);
    126170    }
    127171    return true;
    128172}
    … …  
    133177
    134178var g_fadeAttackUnit = {};
    135179g_fadeAttackUnit.blinkingTicks = 50; // how many ticks should first blinking phase be
    136 g_fadeAttackUnit.blinkingChangeInterval = 5; // how often should the colour be changed during the blinking phase
    137 g_fadeAttackUnit.gbColourChangeRate = 3; // how fast should blue and green part of the colour change
     180g_fadeAttackUnit.blinkingChangeInterval = 5; // how often should the color be changed during the blinking phase
     181g_fadeAttackUnit.gbcolorChangeRate = 3; // how fast should blue and green part of the color change
    138182g_fadeAttackUnit.fadeOutStart = 100; // when should the fade out start using the opacity
    139183g_fadeAttackUnit.opacityChangeRate = 3; // how fast should opacity change
    140184
    141 /**
    142  * rgb: colour object with keys r,g,b and o
    143  * tickCounter: how often the fade was executed
    144  */
    145 function colourFade_attackUnit(rgb, tickCounter)
     185function colorFade_attackUnit(data)
    146186{
     187    var rgb = data.rgb;
     188   
     189    // init color
     190    if (data.tickCounter == 0)
     191        rgb.r = 175;
    147192    // blinking
    148     if (tickCounter < g_fadeAttackUnit.blinkingTicks)
     193    if (data.tickCounter < g_fadeAttackUnit.blinkingTicks)
    149194    {
    150195        // slow that process down
    151         if (tickCounter % g_fadeAttackUnit.blinkingChangeInterval != 0)
     196        if (data.tickCounter % g_fadeAttackUnit.blinkingChangeInterval != 0)
    152197            return;
    153198           
    154         rgb.g = rgb.g == 0 ? 255 : rgb.g = 0;
    155         rgb.b = rgb.b == 0 ? 255 : rgb.b = 0;
     199        rgb.g = rgb.g == 0 ? 255 : 0;
    156200    }
    157     // wait a short time and then colour fade from red to grey to nothing
    158     else if ( tickCounter >= g_fadeAttackUnit.blinkingTicks + g_fadeAttackUnit.blinkingChangeInterval)
     201    // wait a short time and then color fade from red to grey to nothing
     202    else if ( data.tickCounter >= g_fadeAttackUnit.blinkingTicks + g_fadeAttackUnit.blinkingChangeInterval)
    159203    {
    160         rgb.g = rgb.g < 255 ? rgb.g += g_fadeAttackUnit.gbColourChangeRate * Math.sqrt(tickCounter - g_fadeAttackUnit.blinkingTicks) : 255;
    161         rgb.b = rgb.g;
     204        rgb.g = rgb.g < 255 ? rgb.g += g_fadeAttackUnit.gbcolorChangeRate * Math.sqrt(data.tickCounter - g_fadeAttackUnit.blinkingTicks) : 255;
    162205       
    163206        // start with fading it out
    164207        if (rgb.g > g_fadeAttackUnit.fadeOutStart)
    165208            rgb.o = rgb.o > g_fadeAttackUnit.opacityChangeRate ? rgb.o -= g_fadeAttackUnit.opacityChangeRate : 0;
     209        // check for end
     210        if (rgb.o == 0)
     211            data.stopFade = true;
    166212    }
     213    rgb.b = rgb.g;
    167214}
    168215
    169 /**
    170  * makes a smooth fade, if the attack on the unit has not stopped yet
    171  * rgb: colour object with keys r,g,b and o
    172  * tickCounter: how often the fade was executed
    173  */
    174 function smoothColourFadeRestart_attackUnit(rgb, tickCounter)
     216function smoothColorFadeRestart_attackUnit(data)
    175217{
    176218    // check, if in blinking phase
    177     if (tickCounter < g_fadeAttackUnit.blinkingTicks)
     219    if (data.tickCounter < g_fadeAttackUnit.blinkingTicks)
    178220    {
    179         // get rgb to current state
    180         for (var i = 1; i <= tickCounter; i++)
    181             colourFade_attackUnit(rgb, i);
    182         // set the tick counter back to start
    183         return (tickCounter % (g_fadeAttackUnit.blinkingChangeInterval * 2)) + 1;
     221        data.tickCounter = data.tickCounter % (g_fadeAttackUnit.blinkingChangeInterval * 2);
     222        data.rgb.o = getInitColorFadeRGB().o;
     223        return true;
    184224    }
    185     return 1;
     225    return false;
    186226}
    187227
    188 //[END] of hero fade functions
    189  No newline at end of file
     228//[END] of hero fade functions
     229//[START] idle workers icon
     230
     231function colorFade_IdleWorker(data)
     232{
     233    var rgb = data.rgb;
     234    // init color
     235    if (data.tickCounter == 0)
     236    {
     237        rgb.r = 255;
     238        rgb.g = 255;
     239        rgb.b = 255;
     240    }
     241    // hide it every tick
     242    if (data.tickCounter % 2 == 0)
     243        rgb.o = 0;
     244    else
     245        rgb.o = 100;
     246}
     247
     248//[END] of idle workers icon functions
     249 No newline at end of file

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

     
    486486
    487487    updateHero();
    488488    updateGroups();
     489    updateIdleWorkerButton();
    489490    updateDebug();
    490491    updatePlayerDisplay();
    491492    updateSelectionDetails();
    … …  
    499500    if (battleState)
    500501        global.music.setState(global.music.states[battleState]);
    501502   
     503};
     504
     505/**
     506 * updates the idle worker button
     507 */
     508function updateIdleWorkerButton()
     509{
     510    var idleUnitsCounter = Engine.GuiInterfaceCall("GetIdleWorkerButtonCount");
     511    // set color fade and label
     512    if (idleUnitsCounter > 0)
     513    {
     514        startColorFade("idleWorkerOverlay", 750, 0, colorFade_IdleWorker, false);
     515        var label = Engine.GetGUIObjectByName("idleWorkerLabel")
     516        label.caption = idleUnitsCounter;
     517        label.hidden = false;
     518    }
     519    else
     520    {
     521        stopColorFade("idleWorkerOverlay");
     522        var label = Engine.GetGUIObjectByName("idleWorkerLabel");
     523        label.hidden = true;
     524    }
    502525}
    503526
     527
    504528/**
    505529* updates a status bar on the GUI
    506530* nameOfBar: name of the bar
    … …  
    595619    {   
    596620        g_previousHeroHitPoints = heroState.hitpoints;
    597621        // trigger the animation
    598         fadeColour("heroHitOverlay", 100, 10000, {"r": 175,"g": 0,"b": 0,"o": 100}, colourFade_attackUnit, smoothColourFadeRestart_attackUnit);
     622        startColorFade("heroHitOverlay", 100, 0, colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
    599623        return;
    600624    }
    601625}

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

     
    956956                tooltip="Find idle worker"
    957957                hotkey="selection.idleworker"
    958958            >
    959             <!-- TODO: should highlight the button if there's non-zero idle workers -->
    960959            <object size="0 0 100% 100%" type="image" sprite="idleWorker" ghost="true" />
    961             <action on="Press">findIdleUnit(["Female", "Trade", "FishingBoat", "CitizenSoldier", "Healer"]);</action>
     960            <object name="idleWorkerOverlay" hidden="true" type="image" ghost="true" size="2 2 100%-2 100%-2"/>
     961            <object name="idleWorkerLabel" type="text" style="groupIconsText" size="0 0 100% 100%" ghost="true"/>
     962            <action on="Press">findIdleUnit(["Worker", "Trade", "FishingBoat", "Healer"]);</action>
    962963            </object>
    963964        </object>
    964965        </object>

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

     
    17321732    PlaySound(data.name, data.entity);
    17331733};
    17341734
     1735GuiInterface.prototype.GetIdleWorkerButtonCount = function(player)
     1736{
     1737    var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
     1738    if (!cmpPlayer)
     1739        return -1;
     1740    return cmpPlayer.GetIdleWorkerButtonCount();
     1741}
     1742
    17351743function isIdleUnit(ent, idleClass)
    17361744{
    17371745    var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
    … …  
    19701978    "SetWallPlacementPreview": 1,
    19711979    "GetFoundationSnapData": 1,
    19721980    "PlaySound": 1,
     1981    "GetIdleWorkerButtonCount": 1,
    19731982    "FindIdleUnits": 1,
    19741983    "GetTradingRouteGain": 1,
    19751984    "GetTradingDetails": 1,

  • binaries/data/mods/public/simulation/components/Player.js

     
    3636    this.gatherRateMultiplier = 1;
    3737    this.cheatsEnabled = false;
    3838    this.cheatTimeMultiplier = 1;
     39    this.idleWorkerButtonCount = 0;
    3940    this.heroes = [];
    4041    Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager).CheckConquestCriticalEntities();
    4142};
    … …  
    558559            if (index >= 0)
    559560                this.heroes.splice(index, 1);
    560561        }
     562       
     563        // check, if new idle worker is gone
     564        var cmpUnitAI = Engine.QueryInterface(msg.entity, IID_UnitAI);
     565        if (cmpUnitAI)
     566            if (cmpUnitAI.IsIdle() && cmpUnitAI.IsUsedForIdleWorkerButton())
     567                this.DecreaseWorkerButtonCount();
    561568    }
    562569    if (msg.to == this.playerID)
    563570    {
    … …  
    572579
    573580        if (cmpIdentity && cmpIdentity.HasClass("Hero"))
    574581            this.heroes.push(msg.entity);
     582           
     583        // check, if new idle worker is there
     584        var cmpUnitAI = Engine.QueryInterface(msg.entity, IID_UnitAI);
     585        if (cmpUnitAI)
     586            if (cmpUnitAI.IsIdle() && cmpUnitAI.IsUsedForIdleWorkerButton())
     587                this.IncreaseWorkerButtonCount();
    575588    }
    576589};
    577590
    … …  
    665678        cmpGUIInterface.PushNotification(notification);
    666679};
    667680
     681Player.prototype.GetIdleWorkerButtonCount = function()
     682{
     683    return this.idleWorkerButtonCount;
     684};
     685
     686Player.prototype.IncreaseWorkerButtonCount = function()
     687{
     688    this.idleWorkerButtonCount++;
     689};
     690
     691Player.prototype.DecreaseWorkerButtonCount = function()
     692{
     693    this.idleWorkerButtonCount--;
     694    if (this.idleWorkerButtonCount < 0)
     695        error("Negative worker idle count for player '" + this.playerID + "'");
     696};
     697
    668698Engine.RegisterComponentType(IID_Player, "Player", Player);

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

     
    123123    },
    124124};
    125125
     126// classes used for the work idle button
     127var g_idleClassNames = ["Worker", "Trade", "FishingBoat", "Healer"];
     128
    126129// See ../helpers/FSM.js for some documentation of this FSM specification syntax
    127130var UnitFsmSpec = {
    128131
    … …  
    169172    "GuardedAttacked": function(msg) {
    170173        // ignore
    171174    },
     175   
     176    "UnitIdleChanged": function(msg) {
     177        // check if this are units which can be selected by the workes idle button
     178        if(this.IsUsedForIdleWorkerButton())
     179        {
     180            if(msg.idle)
     181                this.IncreaseIdleWorkerButtonCount();
     182            else
     183                this.DecreaseIdleWorkerButtonCount();
     184        }
     185    },
    172186
    173187    // Formation handlers:
    174188
    … …  
    31593173    return Engine.QueryInterface(this.entity, IID_Heal);
    31603174};
    31613175
     3176UnitAI.prototype.IsUsedForIdleWorkerButton = function()
     3177{
     3178    var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
     3179    if (!cmpIdentity)
     3180        return false;
     3181    // check idle class names   
     3182    for each(var className in g_idleClassNames)
     3183        if (cmpIdentity.HasClass(className)) {
     3184            return true;
     3185        }
     3186    // return false because all checks where negative
     3187    return false;
     3188};
     3189
    31623190UnitAI.prototype.IsIdle = function()
    31633191{
    31643192    return this.isIdle;
    … …  
    38053833    UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
    38063834};
    38073835
     3836UnitAI.prototype.OnUnitIdleChanged = function(msg)
     3837{
     3838    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
     3839    if (!cmpOwnership)
     3840        return;
     3841    UnitFsm.ProcessMessage(this, {"type": "UnitIdleChanged", "idle": msg.idle, "player": cmpOwnership.GetOwner()});
     3842}
     3843
    38083844//// Helper functions to be called by the FSM ////
    38093845
    38103846UnitAI.prototype.GetWalkSpeed = function()
    … …  
    56055641    );
    56065642};
    56075643
     5644UnitAI.prototype.IncreaseIdleWorkerButtonCount = function()
     5645{
     5646    var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
     5647    if (cmpPlayer)
     5648        cmpPlayer.IncreaseWorkerButtonCount();
     5649}
     5650
     5651UnitAI.prototype.DecreaseIdleWorkerButtonCount = function()
     5652{
     5653    var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
     5654    if (cmpPlayer)
     5655        cmpPlayer.DecreaseWorkerButtonCount();
     5656}
     5657
    56085658Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);