Ticket #2357: idle_worker_blink_v7.patch

File idle_worker_blink_v7.patch, 22.7 KB (added by Michael, 10 years ago)

Problem with formation update; with some warnings...

  • 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

     
    5656// always through the list of all ongoing attacks...
    5757var g_previousHeroHitPoints = undefined;
    5858
     59// cache idle worker button class names
     60var g_idleWorkerClasses = undefined;
     61
    5962function GetSimState()
    6063{
    6164    if (!g_SimState)
    … …  
    148151    {
    149152        g_Players = getPlayerData(null);
    150153    }
     154    // cache worker class data
     155    g_idleWorkerClasses = Engine.GuiInterfaceCall("GetIdleWorkerClasses");
    151156
    152157    // Cache civ data
    153158    g_CivData = loadCivData();
    … …  
    486491
    487492    updateHero();
    488493    updateGroups();
     494    updateIdleWorkerButton();
    489495    updateDebug();
    490496    updatePlayerDisplay();
    491497    updateSelectionDetails();
    … …  
    499505    if (battleState)
    500506        global.music.setState(global.music.states[battleState]);
    501507   
     508};
     509
     510/**
     511 * updates the idle worker button
     512 */
     513function updateIdleWorkerButton()
     514{
     515    var simState = GetSimState();
     516    var idleUnitsCounter = simState.players[Engine.GetPlayerID()].idleWorkerButtonCount;
     517    // set color fade and label
     518    if (idleUnitsCounter > 0)
     519    {
     520        startColorFade("idleWorkerOverlay", 750, 0, colorFade_IdleWorker, false);
     521        var label = Engine.GetGUIObjectByName("idleWorkerLabel")
     522        label.caption = idleUnitsCounter;
     523        label.hidden = false;
     524    }
     525    else
     526    {
     527        stopColorFade("idleWorkerOverlay");
     528        var label = Engine.GetGUIObjectByName("idleWorkerLabel");
     529        label.hidden = true;
     530    }
    502531}
    503532
    504533/**
     534 * finds an idle worker when the idle worker button is clicked
     535 */
     536function findIdleWorker()
     537{
     538    findIdleUnit(g_idleWorkerClasses);
     539}
     540
     541
     542/**
    505543* updates a status bar on the GUI
    506544* nameOfBar: name of the bar
    507545* points: points to show
    … …  
    595633    {   
    596634        g_previousHeroHitPoints = heroState.hitpoints;
    597635        // trigger the animation
    598         fadeColour("heroHitOverlay", 100, 10000, {"r": 175,"g": 0,"b": 0,"o": 100}, colourFade_attackUnit, smoothColourFadeRestart_attackUnit);
     636        startColorFade("heroHitOverlay", 100, 0, colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
    599637        return;
    600638    }
    601639}

  • 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">findIdleWorker();</action>
    962963            </object>
    963964        </object>
    964965        </object>

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

     
    8989            "team": cmpPlayer.GetTeam(),
    9090            "teamsLocked": cmpPlayer.GetLockTeams(),
    9191            "cheatsEnabled": cmpPlayer.GetCheatsEnabled(),
     92            "idleWorkerButtonCount": cmpPlayer.GetIdleWorkerButtonCount(),
    9293            "phase": phase,
    9394            "isAlly": allies,
    9495            "isMutualAlly": mutualAllies,
    … …  
    724725}
    725726
    726727// Returns the battle state of the player.
     728GuiInterface.prototype.GetIdleWorkerClasses = function(player)
     729{
     730    // try to get the data
     731    var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
     732    if (!cmpPlayer)
     733        return [];
     734    else
     735        return cmpPlayer.GetIdleWorkerButtonClassesList();
     736};
     737
     738// Returns the battle state of the player.
    727739GuiInterface.prototype.GetBattleState = function(player)
    728740{
    729741    var cmpBattleDetection = QueryPlayerIDInterface(player, IID_BattleDetection);
    … …  
    19731985    "SetWallPlacementPreview": 1,
    19741986    "GetFoundationSnapData": 1,
    19751987    "PlaySound": 1,
     1988    "GetIdleWorkerClasses" :1,
    19761989    "FindIdleUnits": 1,
    19771990    "GetTradingRouteGain": 1,
    19781991    "GetTradingDetails": 1,

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

     
    11function Player() {}
    22
    33Player.prototype.Schema =
    4     "<a:component type='system'/><empty/>";
    5 
     4    "<element name='IdleWorkerButtonClasses' a:help='Classes of entities which are used for the idle worker button.'>" +
     5        "<attribute name='datatype'>" +
     6            "<value>tokens</value>" +
     7        "</attribute>" +
     8        "<text/>" +
     9    "</element>";
     10   
    611Player.prototype.Init = function()
    712{
    813    this.playerID = undefined;
    … …  
    3742    this.cheatsEnabled = false;
    3843    this.cheatTimeMultiplier = 1;
    3944    this.heroes = [];
     45    this.idleWorkerButtonCount = 0;
     46    this.idleWorkerButtonClasses = this.template.IdleWorkerButtonClasses._string ? this.template.IdleWorkerButtonClasses._string.split(/\s+/) : []; // classes used for the work idle button
    4047    Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager).CheckConquestCriticalEntities();
    4148};
    4249
     50/**
     51 * Returns an array of unit classes which are used for the idle worker button
     52 */
     53Player.prototype.GetIdleWorkerButtonClassesList = function()
     54{
     55    return this.idleWorkerButtonClasses;
     56};
     57
    4358Player.prototype.SetPlayerID = function(id)
    4459{
    4560    this.playerID = id;
    … …  
    560575            if (index >= 0)
    561576                this.heroes.splice(index, 1);
    562577        }
     578        if (this.playerID == 1) warn("DIE: " + msg.entity);
     579        // check, if new idle worker is gone
     580        var cmpUnitAI = Engine.QueryInterface(msg.entity, IID_UnitAI);
     581        if (cmpUnitAI) {
     582            if (this.playerID == 1) warn("idle: "+ cmpUnitAI.IsIdle());;
     583
     584            if (cmpUnitAI.IsIdle() && cmpUnitAI.IsUsedForIdleWorkerButton())
     585                this.DecreaseWorkerButtonCount();
     586            }
    563587    }
    564588    if (msg.to == this.playerID)
    565589    {
    … …  
    571595
    572596        if (cmpIdentity && cmpIdentity.HasClass("Hero"))
    573597            this.heroes.push(msg.entity);
     598           
     599        // check, if new idle worker is there
     600        var cmpUnitAI = Engine.QueryInterface(msg.entity, IID_UnitAI);
     601        if (cmpUnitAI)
     602            if (cmpUnitAI.IsIdle() && cmpUnitAI.IsUsedForIdleWorkerButton())
     603                this.IncreaseWorkerButtonCount();
    574604    }
    575605};
    576606
    … …  
    664694        cmpGUIInterface.PushNotification(notification);
    665695};
    666696
     697Player.prototype.GetIdleWorkerButtonCount = function()
     698{
     699    return this.idleWorkerButtonCount;
     700};
     701
     702Player.prototype.IncreaseWorkerButtonCount = function()
     703{
     704    this.idleWorkerButtonCount++;
     705};
     706
     707Player.prototype.DecreaseWorkerButtonCount = function()
     708{
     709    this.idleWorkerButtonCount--;
     710    if (this.idleWorkerButtonCount < 0)
     711    {
     712        this.idleWorkerButtonCount = 0;
     713        error("Negative worker idle count for player '" + this.playerID + "'");
     714    }
     715};
     716
    667717Engine.RegisterComponentType(IID_Player, "Player", Player);

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

     
    169169    "GuardedAttacked": function(msg) {
    170170        // ignore
    171171    },
     172   
     173    "UnitIdleChanged": function(msg) {     
     174        // do only if its not animal and is used for the idle worker button
     175        if (!this.IsAnimal() && this.IsUsedForIdleWorkerButton())
     176        {
     177            var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
     178            if (cmpPlayer)
     179            {
     180                if(msg.idle)
     181                    cmpPlayer.IncreaseWorkerButtonCount();
     182                else
     183                    cmpPlayer.DecreaseWorkerButtonCount();
     184            }
     185        }
     186    },
    172187
    173188    // Formation handlers:
    174189
    … …  
    12131228                // idle for an instant and will quickly go off and do something else.
    12141229                // So we'll set a timer here and only report the idle event if we
    12151230                // remain idle
    1216                 this.StartTimer(1000);
     1231                this.StartTimer(5000);
    12171232
    12181233                // If a unit can heal and attack we first want to heal wounded units,
    12191234                // so check if we are a healer and find whether there's anybody nearby to heal.
    … …  
    14131428                // idle for an instant and will quickly go off and do something else.
    14141429                // So we'll set a timer here and only report the idle event if we
    14151430                // remain idle
    1416                 this.StartTimer(1000);
     1431                this.StartTimer(5000);
    14171432
    14181433                // If a unit can heal and attack we first want to heal wounded units,
    14191434                // so check if we are a healer and find whether there's anybody nearby to heal.
    … …  
    30523067    this.formationController = INVALID_ENTITY; // entity with IID_Formation that we belong to
    30533068    this.isGarrisoned = false;
    30543069    this.isIdle = false;
     3070    this.isUsedForIdleWorkerButton = undefined; // will be initialised, if IsUsedForIdleWorkerButton() is called the first time
    30553071    this.lastFormationTemplate = "";
    30563072    this.finishedOrder = false; // used to find if all formation members finished the order
    30573073   
    … …  
    31303146    return Engine.QueryInterface(this.entity, IID_Heal);
    31313147};
    31323148
     3149UnitAI.prototype.IsUsedForIdleWorkerButton = function()
     3150{
     3151    // return cached value, if some is stored
     3152    if (this.isUsedForIdleWorkerButton !== undefined)
     3153        return this.isUsedForIdleWorkerButton;
     3154   
     3155    // calculate value
     3156    this.isUsedForIdleWorkerButton = false;
     3157    var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
     3158    if (!cmpIdentity)
     3159        return false;
     3160    var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
     3161    if (!cmpPlayer)
     3162        return false;
     3163    // check idle class names   
     3164    for each(var className in cmpPlayer.GetIdleWorkerButtonClassesList())
     3165        if (cmpIdentity.HasClass(className)) {
     3166            this.isUsedForIdleWorkerButton = true;
     3167            break;
     3168        }
     3169    // return the value
     3170    return this.isUsedForIdleWorkerButton;
     3171};
     3172
    31333173UnitAI.prototype.IsIdle = function()
    31343174{
    31353175    return this.isIdle;
    … …  
    37723812    UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
    37733813};
    37743814
     3815UnitAI.prototype.OnUnitIdleChanged = function(msg)
     3816{
     3817    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
     3818    if (!cmpOwnership)
     3819        return;
     3820    UnitFsm.ProcessMessage(this, {"type": "UnitIdleChanged", "idle": msg.idle, "player": cmpOwnership.GetOwner()});
     3821}
     3822
    37753823//// Helper functions to be called by the FSM ////
    37763824
    37773825UnitAI.prototype.GetWalkSpeed = function()

  • binaries/data/mods/public/simulation/templates/special/player.xml

     
    3838      </Pillar>
    3939    </LimitChangers>
    4040  </EntityLimits>
    41   <Player/>
     41  <Player>
     42    <IdleWorkerButtonClasses datatype="tokens">Worker Trade FishingBoat</IdleWorkerButtonClasses>
     43  </Player>
    4244  <StatisticsTracker/>
    4345  <TechnologyManager/>
    4446</Entity>