Changeset 24960

Timestamp:
Feb 28, 2021, 11:02:03 AM (3 years ago)
Author:
Freagarach
Message:

Resupport more garrisoned slots per entity.

Basically removed in r8453, now brought back :) (But split from the population space.)

Differential revision: D2056
Comments by: @Angen, @Nescio, @Stan, @wraitii

Location:
ps/trunk/binaries/data/mods/public
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • ps/trunk/binaries/data/mods/public/globalscripts/Templates.js

    r24494 r24960  
    328328    }
    329329
     330
     331
     332
     333
     334
    330335    if (template.GarrisonHolder)
    331336    {

  • ps/trunk/binaries/data/mods/public/gui/common/tooltips.js

    r24782 r24960  
    537537function getGarrisonTooltip(template)
    538538{
    539     if (!template.garrisonHolder)
    540         return "";
    541 
    542     let tooltips = [
    543         sprintf(translate("%(label)s: %(garrisonLimit)s"), {
    544             "label": headerFont(translate("Garrison Limit")),
    545             "garrisonLimit": template.garrisonHolder.capacity
    546         })
    547     ];
    548 
    549     if (template.garrisonHolder.buffHeal)
    550         tooltips.push(
    551             sprintf(translate("%(healRateLabel)s %(value)s %(health)s / %(second)s"), {
    552                 "healRateLabel": headerFont(translate("Heal:")),
    553                 "value": Math.round(template.garrisonHolder.buffHeal),
    554                 "health": unitFont(translate("Health")),
    555                 "second": unitFont(translate("second")),
     539    let tooltips = [];
     540    if (template.garrisonHolder)
     541    {
     542        tooltips.push (
     543            sprintf(translate("%(label)s: %(garrisonLimit)s"), {
     544                "label": headerFont(translate("Garrison Limit")),
     545                "garrisonLimit": template.garrisonHolder.capacity
    556546            })
    557547        );
    558548
    559     return tooltips.join(commaFont(translate(", ")));
     549        if (template.garrisonHolder.buffHeal)
     550            tooltips.push(
     551                sprintf(translate("%(healRateLabel)s %(value)s %(health)s / %(second)s"), {
     552                    "healRateLabel": headerFont(translate("Heal:")),
     553                    "value": Math.round(template.garrisonHolder.buffHeal),
     554                    "health": unitFont(translate("Health")),
     555                    "second": unitFont(translate("second")),
     556                })
     557            );
     558
     559        tooltips.join(commaFont(translate(", ")));
     560    }
     561    if (template.garrisonable)
     562    {
     563        let extraSize;
     564        if (template.garrisonHolder)
     565            extraSize = template.garrisonHolder.occupiedSlots;
     566        if (template.garrisonable.size > 1 || extraSize)
     567            tooltips.push (
     568                sprintf(translate("%(label)s: %(garrisonSize)s %(extraSize)s"), {
     569                    "label": headerFont(translate("Garrison Size")),
     570                    "garrisonSize": template.garrisonable.size,
     571                    "extraSize": extraSize ?
     572                        translateWithContext("nested garrison", "+ ") + extraSize : ""
     573                })
     574            );
     575    }
     576
     577    return tooltips.join("\n");
    560578}
    561579

  • ps/trunk/binaries/data/mods/public/gui/session/selection_details.js

    r24457 r24960  
    367367    let totalCarrying = {};
    368368    let totalLoot = {};
     369
    369370
    370371    for (let entState of entStates)
    … …  
    396397            totalLoot[type] = (totalLoot[type] || 0) + carrying[type];
    397398        }
     399
     400
     401
     402
     403
     404
    398405    }
    399406
    … …  
    449456    numberOfUnits.tooltip = "";
    450457
     458
     459
     460
     461
     462
     463
    451464    if (Object.keys(totalCarrying).length)
    452465        numberOfUnits.tooltip = sprintf(translate("%(label)s %(details)s\n"), {

  • ps/trunk/binaries/data/mods/public/gui/session/unit_actions.js

    r24752 r24960  
    703703
    704704            let tooltip = sprintf(translate("Current garrison: %(garrisoned)s/%(capacity)s"), {
    705                 "garrisoned": targetState.garrisonHolder.garrisonedEntitiesCount,
     705                "garrisoned": targetState.garrisonHolder.,
    706706                "capacity": targetState.garrisonHolder.capacity
    707707            });
    708708
    709             let extraCount = 0;
     709            let extraCount = ;
    710710            if (entState.garrisonHolder)
    711                 extraCount += entState.garrisonHolder.garrisonedEntitiesCount;
    712 
    713             if (targetState.garrisonHolder.garrisonedEntitiesCount + extraCount >= targetState.garrisonHolder.capacity)
     711                extraCount += entState.garrisonHolder.;
     712
     713            if (targetState.garrisonHolder. targetState.garrisonHolder.capacity)
    714714                tooltip = coloredText(tooltip, "orange");
    715715
    … …  
    922922
    923923                tooltip = sprintf(translate("Current garrison: %(garrisoned)s/%(capacity)s"), {
    924                     "garrisoned": targetState.garrisonHolder.garrisonedEntitiesCount,
     924                    "garrisoned": targetState.garrisonHolder.,
    925925                    "capacity": targetState.garrisonHolder.capacity
    926926                });
    927927
    928                 if (targetState.garrisonHolder.garrisonedEntitiesCount >=
     928                if (targetState.garrisonHolder. >=
    929929                    targetState.garrisonHolder.capacity)
    930930                    tooltip = coloredText(tooltip, "orange");

  • ps/trunk/binaries/data/mods/public/simulation/ai/common-api/entity.js

    r24953 r24960  
    420420    "garrisonMax": function() { return this.get("GarrisonHolder/Max"); },
    421421
     422
     423
    422424    "garrisonEjectHealth": function() { return +this.get("GarrisonHolder/EjectHealth"); },
    423425
    … …  
    736738
    737739    "garrisoned": function() { return this._entity.garrisoned; },
    738     "canGarrisonInside": function() { return this._entity.garrisoned.length < this.garrisonMax(); },
     740
     741    "garrisonedSlots": function() {
     742        let count = 0;
     743
     744        if (this._entity.garrisoned)
     745            for (let ent of this._entity.garrisoned)
     746                count += +this._ai._entities.get(ent).garrisonSize();
     747
     748        return count;
     749    },
     750
     751    "canGarrisonInside": function()
     752    {
     753        return this.garrisonedSlots() < this.garrisonMax();
     754    },
    739755
    740756    /**

  • ps/trunk/binaries/data/mods/public/simulation/ai/petra/defenseManager.js

    r24315 r24960  
    749749        return false;
    750750    let minGarrison = data.min || target.garrisonMax();
    751     if (gameState.ai.HQ.garrisonManager.numberOfGarrisonedUnits(target) >= minGarrison)
     751    if (gameState.ai.HQ.garrisonManager.numberOfGarrisonedts(target) >= minGarrison)
    752752        return false;
    753753    if (data.attacker)
    … …  
    801801    for (let ent of units.values())
    802802    {
    803         if (garrisonManager.numberOfGarrisonedUnits(target) >= minGarrison)
     803        if (garrisonManager.numberOfGarrisonedts(target) >= minGarrison)
    804804            break;
    805805        if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") >= 0)
    … …  
    831831        if (!MatchesClassList(unit.classes(), ent.garrisonableClasses()))
    832832      ��     continue;
    833         if (garrisonManager.numberOfGarrisonedUnits(ent) >= ent.garrisonMax())
     833        if (garrisonManager.numberOfGarrisonedts(ent) >= ent.garrisonMax())
    834834            continue;
    835835        if (ent.hitpoints() < ent.garrisonEjectHealth() * ent.maxHitpoints())
    … …  
    867867        if (!MatchesClassList(unit.classes(), ent.garrisonableClasses()))
    868868            continue;
    869         if (garrisonManager.numberOfGarrisonedUnits(ent) >= ent.garrisonMax() &&
     869        if (garrisonManager.numberOfGarrisonedts(ent) >= ent.garrisonMax() &&
    870870            (!emergency || !ent.garrisoned().length))
    871871            continue;
    … …  
    888888        return true;
    889889    }
    890     if (garrisonManager.numberOfGarrisonedUnits(nearest) >= nearest.garrisonMax()) // make room for this ent
     890    if (garrisonManager.numberOfGarrisonedts(nearest) >= nearest.garrisonMax()) // make room for this ent
    891891        nearest.unload(nearest.garrisoned()[0]);
    892892

  • ps/trunk/binaries/data/mods/public/simulation/ai/petra/garrisonManager.js

    r22803 r24960  
    180180                list.splice(j--, 1);
    181181            }
    182             if (this.numberOfGarrisonedUnits(holder) === 0)
     182            if (this.numberOfGarrisonedts(holder) === 0)
    183183                this.holders.delete(id);
    184184            else
    … …  
    194194        if (!ent || ent.owner() !== PlayerID)
    195195            this.decayingStructures.delete(id);
    196         else if (this.numberOfGarrisonedUnits(ent) < gmin)
     196        else if (this.numberOfGarrisonedts(ent) < gmin)
    197197            gameState.ai.HQ.defenseManager.garrisonUnitsInside(gameState, ent, { "min": gmin, "type": "decay" });
    198198    }
    … …  
    208208};
    209209
     210
     211
     212
     213
     214
     215
     216
     217
     218
    210219PETRA.GarrisonManager.prototype.allowMelee = function(holder)
    211220{
    … …  
    219228PETRA.GarrisonManager.prototype.garrison = function(gameState, ent, holder, type)
    220229{
    221     if (this.numberOfGarrisonedUnits(holder) >= holder.garrisonMax() || !ent.canGarrison())
     230    if (this.numberOfGarrisonedts(holder) >= holder.garrisonMax() || !ent.canGarrison())
    222231        return;
    223232

  • ps/trunk/binaries/data/mods/public/simulation/ai/petra/headquarters.js

    r24669 r24960  
    21092109    // We will choose randomly ranged and melee units, except when garrisonHolder is full
    21102110    // in which case we prefer melee units
    2111     let numGarrisoned = this.garrisonManager.numberOfGarrisonedUnits(nearestAnchor);
     2111    let numGarrisoned = this.garrisonManager.numberOfGarrisonedts(nearestAnchor);
    21122112    if (nearestAnchor._entity.trainingQueue)
    21132113    {

  • ps/trunk/binaries/data/mods/public/simulation/components/AlertRaiser.js

    r24776 r24960  
    6464            let cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
    6565            if (!reserved.has(ent))
    66                 reserved.set(ent, cmpGarrisonHolder.GetCapacity() - cmpGarrisonHolder.GetGarrisonedEntitiesCount());
     66                reserved.set(ent, cmpGarrisonHolder.GetCapacity() - cmpGarrisonHolder.());
    6767
    6868            return cmpGarrisonHolder.IsAllowedToGarrison(unit) && reserved.get(ent);

  • ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js

    r24957 r24960  
    9494GarrisonHolder.prototype.IsFull = function()
    9595{
    96     return this.GetGarrisonedEntitiesCount() >= this.GetCapacity();
     96    return this.() >= this.GetCapacity();
    9797};
    9898
    … …  
    135135};
    136136
     137
     138
     139
     140
     141
     142
     143
     144
     145
     146
     147
     148
    137149GarrisonHolder.prototype.IsAllowedToGarrison = function(entity)
    138150{
    … …  
    143155        return false;
    144156
    145     let extraCount = 0;
    146     let cmpGarrisonHolder = Engine.QueryInterface(entity, IID_GarrisonHolder);
    147     if (cmpGarrisonHolder)
    148         extraCount += cmpGarrisonHolder.GetGarrisonedEntitiesCount();
    149     if (this.GetGarrisonedEntitiesCount() + extraCount >= this.GetCapacity())
     157    let cmpGarrisonable = Engine.QueryInterface(entity, IID_Garrisonable);
     158    if (!cmpGarrisonable || this.OccupiedSlots() + cmpGarrisonable.TotalSize() > this.GetCapacity())
    150159        return false;
    151160

  • ps/trunk/binaries/data/mods/public/simulation/components/Garrisonable.js

    r24957 r24960  
    11function Garrisonable() {}
    22
    3 Garrisonable.prototype.Schema = "<empty/>";
     3Garrisonable.prototype.Schema =
     4    "<a:help>Controls the garrisonability of an entity.</a:help>" +
     5    "<a:example>" +
     6        "<Size>10</Size>" +
     7    "</a:example>" +
     8    "<element name='Size' a:help='Number of garrison slots the entity occupies.'>" +
     9        "<data type='nonNegativeInteger'/>" +
     10    "</element>";
    411
    512Garrisonable.prototype.Init = function()
    613{
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
    737};
    838

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

    r24502 r24960  
    369369            "allowedClasses": cmpGarrisonHolder.GetAllowedClasses(),
    370370            "capacity": cmpGarrisonHolder.GetCapacity(),
    371             "garrisonedEntitiesCount": cmpGarrisonHolder.GetGarrisonedEntitiesCount()
     371            "()
    372372        };
    373373
    … …  
    381381    if (cmpGarrisonable)
    382382        ret.garrisonable = {
    383             "holder": cmpGarrisonable.HolderID()
     383            "holder": cmpGarrisonable.HolderID(),
     384            "size": cmpGarrisonable.UnitSize()
    384385        };
    385386

  • ps/trunk/binaries/data/mods/public/simulation/components/tests/test_GarrisonHolder.js

    r24957 r24960  
    1313const unitToGarrisonId = 24;
    1414const enemyUnitId = 34;
     15
    1516const player = 1;
    1617const friendlyPlayer = 2;
    … …  
    4647});
    4748
    48 for (let i = 24; i <= 34; ++i)
     49for (let i = 24; i <= 3; ++i)
    4950{
    5051    AddMock(i, IID_Identity, {
    … …  
    6667        });
    6768
    68     AddMock(i, IID_Garrisonable, {
    69         "Garrison": entity => true,
    70         "UnGarrison": () => true
    71     });
     69    if (i == largeUnitId)
     70        AddMock(i, IID_Garrisonable, {
     71            "UnitSize": () => 9,
     72            "TotalSize": () => 9,
     73            "Garrison": entity => true,
     74            "UnGarrison": () => true
     75        });
     76    else
     77        AddMock(i, IID_Garrisonable, {
     78            "UnitSize": () => 1,
     79            "TotalSize": () => 1,
     80            "Garrison": entity => true,
     81            "UnGarrison": () => true
     82        });
    7283
    7384    AddMock(i, IID_Position, {
    … …  
    101112    TS_ASSERT_EQUALS(cmpGarrisonHolder.Garrison(enemyUnitId), false);
    102113    TS_ASSERT_EQUALS(cmpGarrisonHolder.Garrison(unitToGarrisonId), true);
     114
     115
     116
    103117    TS_ASSERT_EQUALS(cmpGarrisonHolder.Eject(unitToGarrisonId), true);
    104118    TS_ASSERT_EQUALS(cmpGarrisonHolder.Garrison(unitToGarrisonId), true);
    105119    for (let entity of garrisonedEntitiesList)
    106120        TS_ASSERT_EQUALS(cmpGarrisonHolder.Garrison(entity), true);
     121
    107122    TS_ASSERT_EQUALS(cmpGarrisonHolder.IsFull(), true);
    108123    TS_ASSERT_EQUALS(cmpGarrisonHolder.CanPickup(unitToGarrisonId), false);
    … …  
    121136    TS_ASSERT_EQUALS(cmpGarrisonHolder.GetGarrisonedEntitiesCount(), 3);
    122137    TS_ASSERT_EQUALS(cmpGarrisonHolder.IsFull(), false);
     138
    123139    TS_ASSERT_EQUALS(cmpGarrisonHolder.UnloadAll(), true);
    124140    TS_ASSERT_UNEVAL_EQUALS(cmpGarrisonHolder.GetEntities(), []);
    … …  
    153169TS_ASSERT_EQUALS(cmpGarrisonHolder.IsFull(), false);
    154170TS_ASSERT_EQUALS(cmpGarrisonHolder.IsAllowedToGarrison(enemyUnitId), false);
     171
    155172TS_ASSERT_EQUALS(cmpGarrisonHolder.IsAllowedToGarrison(unitToGarrisonId), true);
    156173TS_ASSERT_EQUALS(cmpGarrisonHolder.HasEnoughHealth(), false);
    … …  
    214231});
    215232AddMock(siegeEngineId, IID_Garrisonable, {
     233
     234
    216235    "Garrison": entity => true,
    217236    "UnGarrison": () => true
    … …  
    235254});
    236255AddMock(cavalryId, IID_Garrisonable, {
     256
     257
    237258    "Garrison": entity => true,
    238259    "UnGarrison": () => true

  • ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Garrisonable.js

    r24957 r24960  
    11Engine.LoadComponentScript("interfaces/Auras.js");
    22Engine.LoadComponentScript("interfaces/Garrisonable.js");
     3
    34Engine.LoadComponentScript("interfaces/ProductionQueue.js");
    45Engine.LoadComponentScript("interfaces/UnitAI.js");
    56Engine.LoadComponentScript("Garrisonable.js");
    67
     8
     9
    710const garrisonHolderID = 1;
    811const garrisonableID = 2;
    912
     13
    1014let cmpGarrisonable = ConstructComponent(garrisonableID, "Garrisonable", {
     15
    1116});
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
    1228
    1329TS_ASSERT(cmpGarrisonable.Garrison(garrisonHolderID));

  • ps/trunk/binaries/data/mods/public/simulation/templates/template_unit.xml

    r24689 r24960  
    2323    <Height>4.0</Height>
    2424  </Footprint>
    25   <Garrisonable/>
     25  <Garrisonable>
     26    <Size>1</Size>
     27  </Garrisonable>
    2628  <Guard/>
    2729  <Health>
Note: See TracChangeset for help on using the changeset viewer.