Ticket #3670: 3670_reqTooltips_v1-3.patch

binaries/data/mods/public/globalscripts/Templates.js

@@ -376 +376 @@
 
     ret.description = template.description;
 
+    if (template.top)
+        ret.pair = [template.top, template.bottom];
+
     return ret;
 }
 

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

@@ -2 +2 @@
     "unit": ['[font="sans-10"][color="orange"]', '[/color][/font]'],
     "header": ['[font="sans-bold-13"]', '[/font]'],
     "body": ['[font="sans-13"]', '[/font]'],
-    "comma": ['[font="sans-12"]', '[/font]']
+    "comma": ['[font="sans-12"]', '[/font]'],
+    "emphasis": ['[font="sans-bold-13"]', '[/font]']
 };
 
 const g_AttackTypes = {
@@ -42 +43 @@
     return g_TooltipTextFormats.comma[0] + text + g_TooltipTextFormats.comma[1];
 }
 
+function emphasisFont(text)
+{
+    return g_TooltipTextFormats.emphasis[0] + text + g_TooltipTextFormats.emphasis[1];
+}
+
 function getEntityTooltip(template)
 {
     if (!template.tooltip)
@@ -465 +471 @@
         return "";
 
     return sprintf(translate("Requires %(technology)s"), {
-        "technology": getEntityNames(GetTechnologyData(requiredTechnology, civ))
+        "technology": emphasisFont(getEntityNames(GetTechnologyData(requiredTechnology, civ)))
     });
 }
 

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

@@ -828 +828 @@
             ].map(func => func(template));
 
             if (!requirementsPassed)
-            {
-                let tip = template.requirementsTooltip;
-                let reqs = template.reqs;
-                for (let req of reqs)
-                {
-                    if (!req.entities)
-                        continue;
-
-                    let entityCounts = [];
-                    for (let entity of req.entities)
-                    {
-                        let current = 0;
-                        switch (entity.check)
-                        {
-                        case "count":
-                            current = playerState.classCounts[entity.class] || 0;
-                            break;
-
-                        case "variants":
-                            current = playerState.typeCountsByClass[entity.class] ?
-                                Object.keys(playerState.typeCountsByClass[entity.class]).length : 0;
-                            break;
-                        }
-
-                        let remaining = entity.number - current;
-                        if (remaining < 1)
-                            continue;
-
-                        entityCounts.push(sprintf(translatePlural("%(number)s entity of class %(class)s", "%(number)s entities of class %(class)s", remaining), {
-                            "number": remaining,
-                            "class": entity.class
-                        }));
-                    }
-
-                    tip += " " + sprintf(translate("Remaining: %(entityCounts)s"), {
-                        "entityCounts": entityCounts.join(translate(", "))
-                    });
-                }
-                tooltips.push(tip);
-            }
+                tooltips.push(template.requirementsTooltip || deriveTechRequirementsTooltip(template.reqs, player));
+
             tooltips.push(getNeededResourcesTooltip(neededResources));
             button.tooltip = tooltips.filter(tip => tip).join("\n");
 

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

@@ -144 +144 @@
     }) + "[/font]";
 }
 
+/**
+ *
+ * @param reqs {array} Civ-specific requirements
+ */
+function deriveTechRequirementsTooltip(reqs, player)
+{
+    let optionalTexts = [];
+    let playerState = GetSimState().players[player];
+
+    for (let req of reqs)
+    {
+        let requirementTexts = [];
+
+        if (req.techs)
+        {
+            let requiredTechs = [];
+
+            for (let tech of req.techs)
+                if (!playerState.researchedTechs[tech])
+                {
+                    if (tech.slice(0, 4) == "pair")
+                    {
+                        let pair = GetTechnologyData(tech).pair;
+                        requiredTechs.push(sprintf(translate("%(firstTechOfPair)s or %(secondTechOfPair)s"), {
+                            "firstTechOfPair": emphasisFont(getEntityNames(GetTechnologyData(pair[0]))),
+                            "secondTechOfPair": emphasisFont(getEntityNames(GetTechnologyData(pair[1])))
+                        }));
+                    }
+                    else
+                        requiredTechs.push(emphasisFont(getEntityNames(GetTechnologyData(tech))));
+                }
+
+            if (requiredTechs.length)
+            {
+                if (requiredTechs.length == 1)
+                    requirementTexts.push(requiredTechs[0]);
+                else
+                    requirementTexts.push(sprintf(translate("%(listOfTechs)s and %(lastTechInList)s"), {
+                        // Translation: This comma is used for separating first to penultimate elements in the list
+                        "listOfTechs": requiredTechs.slice(0,-1).join(translate(", ")),
+                        "lastTechInList": requiredTechs.slice(-1)
+                    }));
+            }
+        }
+
+        if (req.entities)
+        {
+            let requiredEnts = [];
+            for (let entity of req.entities)
+            {
+                let current = 0;
+                switch (entity.check)
+                {
+                case "count":
+                    current = playerState.classCounts[entity.class] || 0;
+                    break;
+
+                case "variants":
+                    current = playerState.typeCountsByClass[entity.class] ?
+                        Object.keys(playerState.typeCountsByClass[entity.class]).length : 0;
+                    break;
+                }
+
+                let remaining = entity.number - current;
+                if (remaining < 1)
+                    continue;
+
+                let nameList = [];
+                for (let templateName of playerState.templatesByClass[entity.class])
+                    // We use the generic name only to keep the tooltip short
+                    nameList.push(emphasisFont(GetTemplateData(templateName).name.generic));
+
+                if (nameList.length == 1)
+                    nameList = nameList[0];
+                else
+                    nameList = sprintf(translate("%(listOfEntityNames)s or %(lastEntityNameInList)s"), {
+                        // Translation: This comma is used for separating first to penultimate elements in the list
+                        "listOfEntityNames": nameList.slice(0,-1).join(translate(", ")),
+                        "lastEntityNameInList": nameList.slice(-1)
+                    });
+
+                requiredEnts.push(sprintf(translate("%(number)s %(listOfTemplateNames)s (%(remaining)s remaining)"), {
+                    "number": entity.number,
+                    "listOfTemplateNames": nameList,
+                    "remaining": remaining,
+                }));
+            }
+            if (requiredEnts.length)
+                // Translation: This is used to join multiple technology requirements
+                requirementTexts.push(requiredEnts.join(translate(" and ")));
+        }
+
+        // Translation: This is used to join multiple technology requirements
+        optionalTexts.push(requirementTexts.join(translate(" and ")));
+    }
 
+    return sprintf(translate("Requires %(requirementTexts)s"), {
+        // Translation: This is used to join multiple technology requirements
+        "requirementTexts": optionalTexts.join(translate("; or "))
+    });
+}

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

@@ -29 +29 @@
     this.notifications = [];
     this.renamedEntities = [];
     this.miragedEntities = [];
+    this.playerTemplatesByClass = [];
     this.timeNotificationID = 1;
     this.timeNotifications = [];
     this.entsRallyPointsDisplayed = [];
@@ -106 +107 @@
             "teamsLocked": cmpPlayer.GetLockTeams(),
             "cheatsEnabled": cmpPlayer.GetCheatsEnabled(),
             "disabledTemplates": cmpPlayer.GetDisabledTemplates(),
+            "templatesByClass": this.GetPlayerTemplatesByName(i),
             "hasSharedDropsites": cmpPlayer.HasSharedDropsites(),
             "hasSharedLos": cmpPlayer.HasSharedLos(),
             "phase": phase,
@@ -718 +720 @@
     return ret;
 };
 
+/**
+ * For a given player, produces an object that has classes as keys and an array of template names as values
+ */
+GuiInterface.prototype.GetPlayerTemplatesByName = function(player)
+{
+    if (this.playerTemplatesByClass[player])
+        return this.playerTemplatesByClass[player];
+
+    let playerEntity = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetPlayerByID(player);
+
+    // todo: find a better starting point
+    let cmpTechnologyManager = Engine.QueryInterface(playerEntity, IID_TechnologyManager);
+    if (!cmpTechnologyManager)
+        return {};
+
+    let cmpPlayer = Engine.QueryInterface(playerEntity, IID_Player);
+    let disabledTemplates = cmpPlayer.GetDisabledTemplates();
+
+    let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+    let entsByClass = {};
+    let toParse = Object.keys(cmpTechnologyManager.GetTypeCountsByClass().Structure);
+    let templateData = new Map();
+    
+
+    while (toParse.length)
+    {
+        let toParseNext = [];
+
+        for (let templateName of toParse)
+        {
+            if (!cmpTemplateManager.TemplateExists(templateName))
+                continue;
+
+            let template = cmpTemplateManager.GetTemplate(templateName);
+            templateData.set(templateName, {
+                "parent": template["@parent"],
+                "classes": GetIdentityClasses(template.Identity)
+            });
+
+            let entStrings = [];
+            if (template.ProductionQueue && template.ProductionQueue.Entities)
+                entStrings.push(template.ProductionQueue.Entities._string || "");
+
+            if (template.Builder && template.Builder.Entities)
+                entStrings.push(template.Builder.Entities._string || "");
+
+            for (let ent of entStrings.join(" ").replace(/\{civ\}/g, cmpPlayer.GetCiv()).split(/\s+/))
+                if (ent && !templateData.has(ent) && toParseNext.indexOf(ent) < 0 && !disabledTemplates[ent])
+                    toParseNext.push(ent);
+        }
+        toParse = toParseNext;
+    }
+
+    for (let template of templateData)
+    {
+        // Crudely filter out *_house, *_trireme and *_barracks copies
+        if (templateData[template[1].parent])
+            continue;
+
+        for (let cls of template[1].classes)
+        {
+            if (!entsByClass[cls])
+                entsByClass[cls] = [];
+            entsByClass[cls].push(template[0]);
+        }
+    }
+
+    this.playerTemplatesByClass[player] = entsByClass;
+    return this.playerTemplatesByClass[player];
+};
+
+GuiInterface.prototype.OnDisabledTemplatesChanged = function(msg)
+{
+    // No player identifier is passed, so erase all
+    this.playerTemplatesByClass = [];
+};
+
 // Returns the battle state of the player.
 GuiInterface.prototype.GetBattleState = function(player)
 {