Ticket #3670: 3670_reqTooltips_v1-1.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

@@ -830 +830 @@
             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(", "))
-                    });
-                }
+                tip += "\n" + deriveTechRequirementsTooltip(template.reqs, player);
                 tooltips.push(tip);
             }
             tooltips.push(getNeededResourcesTooltip(neededResources));

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 = [];
+
+    for (let req of reqs)
+    {
+        let requirementTexts = [];
+
+        if (req.techs)
+        {
+            let requiredTechs = [];
+
+            for (let tech of req.techs)
+                if (!GetSimState().players[player].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 = GetSimState().players[player].classCounts[entity.class] || 0;
+                    break;
+
+                case "variants":
+                    current = GetSimState().players[player].typeCountsByClass[entity.class] ?
+                        Object.keys(GetSimState().players[player].typeCountsByClass[entity.class]).length : 0;
+                    break;
+                }
+
+                let remaining = entity.number - current;
+                if (remaining < 1)
+                    continue;
+
+                requiredEnts.push(sprintf(translatePlural(
+                    "%(number)s unit or structure of class %(class)s (%(remaining)s remaining)",
+                    "%(number)s units or structures of class %(class)s (%(remaining)s remaining)",
+                    entity.number
+                ), {
+                    "number": entity.number,
+                    "class": emphasisFont(entity.class),
+                    "remaining": remaining,
+                }));
+            }
+            if (requiredEnts.length)
+                requirementTexts.push(requiredEnts.join(translate(" and ")));
+        }
+
+        optionalTexts.push(requirementTexts.join(" and "));
+    }
 
+    return sprintf(translate("Requires %(requirementTexts)s"), {
+            "requirementTexts": optionalTexts.join(translate("; or "))
+        });
+}