Ticket #4554: resource_graph.patch

binaries/data/mods/public/gui/credits/texts/programming.json

@@ -1 +1 @@
 {
     "Title": "Programming",
     "Content": [
         {
             "Title": "Programming managers",
             "List": [
                 { "nick": "Acumen", "name": "Stuart Walpole" },
                 { "nick": "Dak Lozar", "name": "Dave Loeser" },
                 { "nick": "h20", "name": "Daniel Wilhelm" },
                 { "nick": "Janwas", "name": "Jan Wassenberg" },
                 { "nick": "Raj", "name": "Raj Sharma" }
             ]
         },
         {
             "Subtitle": "Special thanks to",
             "List": [
                 { "nick": "leper", "name": "Georg Kilzer" },
                 { "nick": "Ykkrosh", "name": "Philip Taylor" }
             ]
         },
         {
             "List": [
                 { "nick": "01d55" },
                 { "nick": "aBothe", "name": "Alexander Bothe" },
                 { "nick": "Acumen", "name": "Stuart Walpole" },
                 { "nick": "adrian", "name": "Adrian Boguszewszki" },
                 { "name": "Adrian Fatol" },
                 { "nick": "AI-Amsterdam" },
                 { "nick": "Alan", "name": "Alan Kemp" },
                 { "nick": "Alex", "name": "Alexander Yakobovich" },
                 { "nick": "alpha123", "name": "Peter P. Cannici" },
                 { "nick": "Ampaex", "name": "Antonio Vazquez" },
                 { "name": "André Puel" },
                 { "nick": "andy5995", "name": "Andy Alt" },
                 { "nick": "Angen" },
                 { "nick": "Arfrever", "name": "Arfrever Frehtes Taifersar Arahesis" },
                 { "nick": "ArnH", "name": "Arno Hemelhof" },
                 { "nick": "Aurium", "name": "Aurélio Heckert" },
                 { "nick": "badmadblacksad", "name": "Martin F" },
                 { "nick": "badosu", "name": "Amadeus Folego" },
                 { "nick": "bb", "name": "Bouke Jansen" },
                 { "nick": "Ben", "name": "Ben Vinegar" },
                 { "nick": "Bird" },
                 { "nick": "Blue", "name": "Richard Welsh" },
                 { "nick": "bmwiedemann" },
                 { "nick": "boeseRaupe", "name": "Michael Kluge" },
                 { "nick": "bog_dan_ro", "name": "BogDan Vatra" },
                 { "nick": "Bonk", "name": "Christopher Ebbert" },
                 { "nick": "Boudica" },
                 { "nick": "Caius", "name": "Lars Kemmann" },
                 { "nick": "Calefaction", "name": "Matt Holmes" },
                 { "nick": "Calvinh", "name": "Carl-Johan Höiby" },
                 { "nick": "causative", "name": "Bart Parkis" },
                 { "name": "Cédric Houbart" },
                 { "nick": "Chakakhan", "name": "Kenny Long" },
                 { "nick": "Clockwork-Muse", "name": "Stephen A. Imhoff" },
                 { "nick": "Cracker78", "name": "Chad Heim" },
                 { "nick": "Crynux", "name": "Stephen J. Fewer" },
                 { "nick": "cwprogger" },
                 { "nick": "cygal", "name": "Quentin Pradet" },
                 { "nick": "Dak Lozar", "name": "Dave Loeser" },
                 { "nick": "dalerank", "name": "Sergey Kushnirenko" },
                 { "nick": "dan", "name": "Dan Strandberg" },
                 { "nick": "DanCar", "name": "Daniel Cardenas" },
                 { "nick": "danger89", "name": "Melroy van den Berg" },
                 { "name": "Daniel Trevitz" },
                 { "nick": "Dariost", "name": "Dario Ostuni" },
                 { "nick": "Dave", "name": "David Protasowski" },
                 { "nick": "dax", "name": "Dacian Fiordean" },
                 { "nick": "deebee", "name": "Deepak Anthony" },
                 { "nick": "Deiz" },
                 { "nick": "Dietger", "name": "Dietger van Antwerpen" },
                 { "nick": "DigitalSeraphim", "name": "Nick Owens" },
                 { "nick": "dp304" },
                 { "nick": "dpiquet", "name": "Damien Piquet" },
                 { "nick": "dumbo" },
                 { "nick": "Dunedan", "name": "Daniel Roschka" },
                 { "nick": "dvangennip", "name": "Doménique" },
                 { "nick": "Echelon9", "name": "Rhys Kidd" },
                 { "nick": "echotangoecho" },
                 { "nick": "eihrul", "name": "Lee Salzman" },
                 { "nick": "elexis", "name": "Alexander Heinsius" },
                 { "nick": "EmjeR", "name": "Matthijs de Rijk" },
                 { "nick": "EMontana" },
                 { "nick": "ericb" },
                 { "nick": "evanssthomas", "name": "Evans Thomas" },
                 { "nick": "Evulant", "name": "Alexander S." },
                 { "nick": "fabio", "name": "Fabio Pedretti" },
                 { "nick": "falsevision", "name": "Mahdi Khodadadifard" },
                 { "nick": "fatherbushido", "name": "Nicolas Tisserand" },
                 { "nick": "fcxSanya", "name": "Alexander Olkhovskiy" },
                 { "nick": "FeXoR", "name": "Florian Finke" },
                 { "nick": "Fire Giant", "name": "Malte Schwarzkopf" },
                 { "name": "Fork AD" },
                 { "nick": "fpre", "name": "Frederick Stallmeyer" },
                 { "nick": "Freagarach" },
                 { "nick": "freenity", "name": "Anton Galitch" },
                 { "nick": "Gallaecio", "name": "Adrián Chaves" },
                 { "nick": "gbish (aka Iny)", "name": "Grant Bishop" },
                 { "nick": "Gee", "name": "Gustav Larsson" },
                 { "nick": "Gentz", "name": "Hal Gentz" },
                 { "nick": "gerbilOFdoom" },
                 { "nick": "godlikeldh" },
                 { "nick": "greybeard", "name": "Joe Cocovich" },
                 { "nick": "grillaz" },
                 { "nick": "Grugnas", "name": "Giuseppe Tranchese" },
                 { "nick": "gudo" },
                 { "nick": "Guuts", "name": "Matthew Guttag" },
                 { "nick": "h20", "name": "Daniel Wilhelm" },
                 { "nick": "Hannibal_Barca", "name": "Clive Juhász S." },
                 { "nick": "Haommin" },
                 { "nick": "happyconcepts", "name": "Ben Bird" },
                 { "nick": "historic_bruno", "name": "Ben Brian" },
                 { "nick": "idanwin" },
                 { "nick": "Imarok", "name": "J. S." },
                 { "nick": "Inari" },
                 { "nick": "infyquest", "name": "Vijay Kiran Kamuju" },
                 { "nick": "irishninja", "name": "Brian Broll" },
                 { "nick": "IronNerd", "name": "Matthew McMullan" },
                 { "nick": "Itms", "name": "Nicolas Auvray" },
                 { "nick": "Jaison", "name": "Marco tom Suden" },
                 { "nick": "jammus", "name": "James Scott" },
                 { "nick": "Janwas", "name": "Jan Wassenberg" },
                 { "nick": "javiergodas", "name": "Javier Godas Vieitez" },
                 { "nick": "Jgwman" },
                 { "nick": "JonBaer", "name": "Jon Baer" },
                 { "nick": "Josh", "name": "Joshua J. Bakita" },
                 { "nick": "joskar", "name": "Johnny Oskarsson" },
                 { "nick": "jP_wanN", "name": "Jonas Platte" },
                 { "nick": "Jubalbarca", "name": "James Baillie" },
                 { "nick": "JubJub", "name": "Sebastian Vetter" },
                 { "nick": "jurgemaister" },
                 { "nick": "kabzerek", "name": "Grzegorz Kabza" },
                 { "nick": "Kai", "name": "Kai Chen" },
                 { "name": "Kareem Ergawy" },
                 { "nick": "kevmo", "name": "Kevin Caffrey" },
                 { "nick": "kezz", "name": "Graeme Kerry" },
                 { "nick": "kingadami", "name": "Adam Winsor" },
                 { "nick": "kingbasil", "name": "Giannis Fafalios" },
                 { "nick": "Krinkle", "name": "Timo Tijhof" },
                 { "nick": "lafferjm", "name": "Justin Lafferty" },
                 { "nick": "LeanderH", "name": "Leander Hemelhof" },
                 { "nick": "leper", "name": "Georg Kilzer" },
                 { "nick": "Link Mauve", "name": "Emmanuel Gil Peyrot" },
                 { "nick": "LittleDev" },
                 { "nick": "livingaftermidnight", "name": "Will Dull" },
                 { "nick": "lonehawk", "name": "Vignesh Krishnan" },
                 { "nick": "Louhike" },
                 { "nick": "lsdh" },
                 { "nick": "Ludovic", "name": "Ludovic Rousseau" },
                 { "nick": "luiko", "name": "Luis Carlos Garcia Barajas" },
                 { "nick": "m0l0t0ph", "name": "Christoph Gielisch" },
                 { "nick": "madmax", "name": "Abhijit Nandy" },
                 { "nick": "madpilot", "name": "Guido Falsi" },
                 { "nick": "mammadori", "name": "Marco Amadori" },
                 { "nick": "markcho" },
                 { "nick": "MarkT", "name": "Mark Thompson" },
                 { "nick": "Markus" },
                 { "nick": "Mate-86", "name": "Mate Kovacs" },
                 { "nick": "Matei", "name": "Matei Zaharia" },
                 { "nick": "MattDoerksen", "name": "Matt Doerksen" },
                 { "nick": "mattlott", "name": "Matt Lott" },
                 { "nick": "maveric", "name": "Anton Protko" },
                 { "nick": "Micnasty", "name": "Travis Gorkin" },
                 { "name": "Mikołaj \"Bajter\" Korcz" },
                 { "nick": "mimo" },
                 { "nick": "mk12", "name": "Mitchell Kember" },
                 { "nick": "mmayfield45", "name": "Michael Mayfield" },
                 { "nick": "mmoanis", "name": "Mohamed Moanis" },
                 { "nick": "Molotov", "name": "Dario Alvarez" },
                 { "nick": "mpmoreti", "name": "Marcos Paulo Moreti" },
                 { "nick": "mreiland", "name": "Michael Reiland" },
                 { "nick": "myconid" },
                 { "nick": "nani", "name": "S. N." },
                 { "nick": "nd3c3nt", "name": "Gavin Fowler" },
                 { "nick": "nephele" },
                 { "nick": "Nescio" },
                 { "nick": "niektb", "name": "Niek ten Brinke" },
                 { "nick": "nikagra", "name": "Mikita Hradovich" },
                 { "nick": "njm" },
                 { "nick": "NoMonkey", "name": "John Mena" },
                 { "nick": "norsnor" },
                 { "nick": "notpete", "name": "Rich Cross" },
                 { "nick": "nwtour" },
                 { "nick": "odoaker", "name": "Ágoston Sipos" },
                 { "nick": "Offensive ePeen", "name": "Jared Ryan Bills" },
                 { "nick": "Ols", "name": "Oliver Whiteman" },
                 { "nick": "olsner", "name": "Simon Brenner" },
                 { "nick": "OptimusShepard", "name": "Pirmin Stanglmeier" },
                 { "nick": "otero" },
                 { "nick": "Palaxin", "name": "David A. Freitag" },
                 { "name": "Paul Withers" },
                 { "nick": "paulobezerr", "name": "Paulo George Gomes Bezerra" },
                 { "nick": "pcpa", "name": "Paulo Andrade" },
                 { "nick": "Pendingchaos" },
                 { "nick": "PeteVasi", "name": "Pete Vasiliauskas" },
                 { "nick": "pilino1234" },
                 { "nick": "PingvinBetyar", "name": "Schronk Tamás" },
                 { "nick": "plugwash", "name": "Peter Michael Green" },
                 { "nick": "Polakrity" },
                 { "nick": "Poya", "name": "Poya Manouchehri" },
                 { "nick": "prefect", "name": "Nicolai Hähnle" },
                 { "nick": "Prodigal Son" },
                 { "nick": "pstumpf", "name": "Pascal Stumpf" },
                 { "nick": "pyrolink", "name": "Andrew Decker" },
                 { "nick": "quantumstate", "name": "Jonathan Waller" },
                 { "nick": "QuickShot", "name": "Walter Krawec" },
                 { "nick": "quonter" },
                 { "nick": "qwertz" },
                 { "nick": "Radagast" },
                 { "nick": "Raj", "name": "Raj Sharma" },
                 { "nick": "ramtzok1", "name": "Ram" },
                 { "nick": "rapidelectron", "name": "Christian Weihsbach" },
                 { "nick": "r-a-sattarov", "name": "Ramil Sattarov" },
                 { "nick": "RedFox", "name": "Jorma Rebane" },
                 { "nick": "RefinedCode" },
                 { "nick": "Riemer" },
                 { "name": "Rolf Sievers" },
                 { "nick": "s0600204", "name": "Matthew Norwood" },
                 { "nick": "sacha_vrand", "name": "Sacha Vrand" },
                 { "nick": "SafaAlfulaij" },
                 { "name": "Samuel Guarnieri" },
                 { "nick": "Samulis", "name": "Sam Gossner" },
                 { "nick": "Sandarac" },
                 { "nick": "sanderd17", "name": "Sander Deryckere" },
                 { "nick": "sathyam", "name": "Sathyam Vellal" },
                 { "nick": "sbirmi", "name": "Sharad Birmiwal" },
                 { "nick": "sbte", "name": "Sven Baars" },
                 { "nick": "scroogie", "name": "André Gemünd" },
                 { "nick": "scythetwirler", "name": "Casey X." },
                 { "nick": "serveurix" },
                 { "nick": "Shane", "name": "Shane Grant" },
                 { "nick": "shh" },
                 { "nick": "Silk", "name": "Josh Godsiff" },
                 { "nick": "silure" },
                 { "nick": "Simikolon", "name": "Yannick & Simon" },
                 { "nick": "smiley", "name": "M. L." },
                 { "nick": "Spahbod", "name": "Omid Davoodi" },
                 { "nick": "Stan", "name": "Stanislas Dolcini" },
                 { "nick": "Stefan" },
                 { "nick": "StefanBruens", "name": "Stefan Brüns" },
                 { "nick": "stilz", "name": "Sławomir Zborowski" },
                 { "nick": "stwf", "name": "Steven Fuchs" },
                 { "nick": "svott", "name": "Sven Ott" },
                 { "nick": "t4nk004" },
                 { "nick": "tau" },
                 { "nick": "tbm", "name": "Martin Michlmayr" },
                 { "nick": "Teiresias" },
                 { "nick": "temple" },
                 { "nick": "texane" },
                 { "nick": "thamlett", "name": "Timothy Hamlett" },
                 { "nick": "thedrunkyak", "name": "Dan Fuhr" },
                 { "nick": "Tobbi" },
+                { "nick": "Toonijn", "name": "Toon Baeyens" },
                 { "nick": "TrinityDeath", "name": "Jethro Lu" },
                 { "nick": "triumvir", "name": "Corin Schedler" },
                 { "nick": "trompetin17", "name": "Juan Guillermo" },
                 { "nick": "user1", "name": "A. C." },
                 { "nick": "usey11" },
                 { "nick": "vincent_c", "name": "Vincent Cheng" },
                 { "nick": "vinhig", "name": "Vincent Higginson" },
                 { "nick": "vladislavbelov", "name": "Vladislav Belov" },
                 { "nick": "voroskoi" },
                 { "nick": "vts", "name": "Jeroen DR" },
                 { "nick": "wacko", "name": "Andrew Spiering" },
                 { "nick": "WhiteTreePaladin", "name": "Brian Ashley" },
                 { "nick": "wraitii", "name": "Lancelot de Ferrière le Vayer" },
                 { "nick": "Xentelian", "name": "Mark Strawson" },
                 { "nick": "Xienen", "name": "Dayle Flowers" },
                 { "nick": "xtizer", "name": "Matt Green" },
                 { "nick": "yashi", "name": "Yasushi Shoji" },
                 { "nick": "Ykkrosh", "name": "Philip Taylor" },
                 { "nick": "Yves" },
                 { "nick": "Zeusthor", "name": "Jeffrey Tavares" },
                 { "nick": "zoot" },
                 { "nick": "zsol", "name": "Zsolt Dollenstein" },
                 { "nick": "ztamas", "name": "Tamas Zolnai" },
                 { "nick": "Zyi", "name": "Charles De Meulenaer" }
             ]
         }
     ]
 }

binaries/data/mods/public/gui/summary/counters.js

@@ -1 +1 @@
 var g_TeamHelperData = [];
 
 function calculatePercent(divident, divisor)
 {
     return { "percent": divisor ? Math.floor(100 * divident / divisor) : 0 };
 }
 
 function calculateRatio(divident, divisor)
 {
     return divident ? +((divident / divisor).toFixed(2)) : 0;
 }
 
 function formatSummaryValue(values)
 {
     if (typeof values != "object")
         return values === Infinity ? g_InfinitySymbol : values;
 
     let ret = "";
     for (let type in values)
-        ret += (g_SummaryTypes[type].color ?
-            coloredText(values[type], g_SummaryTypes[type].color) :
-            values[type]) + g_SummaryTypes[type].postfix;
+        if(g_SummaryTypes[type].hide !== true)
+            ret += (g_SummaryTypes[type].color ?
+                coloredText(values[type], g_SummaryTypes[type].color) :
+                values[type]) + g_SummaryTypes[type].postfix;
     return ret;
 }
 
 function getPlayerValuesPerTeam(team, index, type, counters, headings)
 {
     let fn = counters[headings.map(heading => heading.identifier).indexOf(type) - 1].fn;
     return g_Teams[team].map(player => fn(g_GameData.sim.playerStates[player], index, type));
 }
 
 function updateCountersPlayer(playerState, counters, headings, idGUI, index)
 {
     for (let n in counters)
     {
         let fn = counters[n].fn;
         Engine.GetGUIObjectByName(idGUI + "[" + n + "]").caption =
             formatSummaryValue(fn && fn(playerState, index, headings[+n + 1].identifier));
     }
 }
 
 function updateCountersTeam(teamFn, counters, headings, index)
 {
     for (let team in g_Teams)
     {
         if (team == -1)
             continue;
 
         for (let n in counters)
             Engine.GetGUIObjectByName("valueDataTeam[" + team + "][" + n + "]").caption =
                 formatSummaryValue(teamFn(team, index, headings[+n + 1].identifier, counters, headings));
     }
 }
 
 /**
  * Add two objects property-wise and writes the result to obj1.
  * So summaryAddObject([1, 2], [7, 42]) will result in [8, 44] and
  * summaryAddObject({ "f": 3, "o", 5 }, { "f": -1, "o", 42 }) will result in { "f": 2, "o", 47 }.
  *
  * @param {Object} obj1 - First summand object. This will be set to the sum of both.
  * @param {Object} obj2 - Second summand object.
  */
 function summaryAddObject(obj1, obj2)
 {
     for (let p in obj1)
         obj1[p] += obj2[p];
 }
 
 /**
  * The sum of all elements of an array. So summaryArraySum([1, 2]) will be 3 and
  * summaryArraySum([{ "f": 3, "o", 5 }, { "f": -1, "o", 42 }]) will be { "f": 2, "o", 47 }.
  *
  * @param {Array} array - The array to sum up.
  * @returns the sum of all elements.
  */
 function summaryArraySum(array)
 {
     return array.reduce((sum, val) => {
         if (typeof sum != "object")
             return sum + val;
         summaryAddObject(sum, val);
         return sum;
     });
 }
 
 function calculateTeamCounterDataHelper()
 {
     for (let i = 0; i < g_PlayerCount; ++i)
     {
         let playerState = g_GameData.sim.playerStates[i + 1];
 
         if (!g_TeamHelperData[playerState.team])
         {
             g_TeamHelperData[playerState.team] = {};
             for (let value of ["food", "vegetarianFood", "femaleCitizen", "worker", "enemyUnitsKilled",
                                "unitsLost", "mapControl", "mapControlPeak",
                                "mapExploration", "totalBought", "totalSold"])
                 g_TeamHelperData[playerState.team][value] = new Array(playerState.sequences.time.length).fill(0);
         }
 
         summaryAddObject(g_TeamHelperData[playerState.team].food, playerState.sequences.resourcesGathered.food);
         summaryAddObject(g_TeamHelperData[playerState.team].vegetarianFood, playerState.sequences.resourcesGathered.vegetarianFood);
 
         summaryAddObject(g_TeamHelperData[playerState.team].femaleCitizen, playerState.sequences.unitsTrained.FemaleCitizen);
         summaryAddObject(g_TeamHelperData[playerState.team].worker, playerState.sequences.unitsTrained.Worker);
 
         summaryAddObject(g_TeamHelperData[playerState.team].enemyUnitsKilled, playerState.sequences.enemyUnitsKilled.total);
         summaryAddObject(g_TeamHelperData[playerState.team].unitsLost, playerState.sequences.unitsLost.total);
 
         g_TeamHelperData[playerState.team].mapControl = playerState.sequences.teamPercentMapControlled;
         g_TeamHelperData[playerState.team].mapControlPeak = playerState.sequences.teamPeakPercentMapControlled;
 
         g_TeamHelperData[playerState.team].mapExploration = playerState.sequences.teamPercentMapExplored;
 
         for (let type in playerState.sequences.resourcesBought)
             summaryAddObject(g_TeamHelperData[playerState.team].totalBought, playerState.sequences.resourcesBought[type]);
 
         for (let type in playerState.sequences.resourcesSold)
             summaryAddObject(g_TeamHelperData[playerState.team].totalSold, playerState.sequences.resourcesSold[type]);
     }
 }
 
 /**
  * Keep this in sync with the score computation in session/ for the lobby rating reports!
  */
 function calculateEconomyScore(playerState, index)
 {
     let total = 0;
 
     // Notice that this skips the vegetarianFood property of resourcesGathered
     for (let type of g_ResourceData.GetCodes())
         total += playerState.sequences.resourcesGathered[type][index];
 
     total += playerState.sequences.tradeIncome[index];
     return Math.round(total / 10);
 }
 
 /**
  * Keep this in sync with the score computation in session/ for the lobby rating reports!
  */
 function calculateMilitaryScore(playerState, index)
 {
     return Math.round((playerState.sequences.enemyUnitsKilledValue[index] +
         playerState.sequences.unitsCapturedValue[index] +
         playerState.sequences.enemyBuildingsDestroyedValue[index] +
         playerState.sequences.buildingsCapturedValue[index]) / 10);
 }
 
 /**
  * Keep this in sync with the score computation in session/ for the lobby rating reports!
  */
 function calculateExplorationScore(playerState, index)
 {
     return playerState.sequences.percentMapExplored[index] * 10;
 }
 
 /**
  * Keep this in sync with the score computation in session/ for the lobby rating reports!
  */
  function calculateScoreTotal(playerState, index)
 {
     return calculateEconomyScore(playerState, index) +
         calculateMilitaryScore(playerState, index) +
         calculateExplorationScore(playerState, index);
 }
 
 function calculateScoreTeam(team, index, type, counters, headings)
 {
     if (type == "explorationScore")
         return g_TeamHelperData[team].mapExploration[index] * 10;
     if (type == "totalScore")
         return ["economyScore", "militaryScore", "explorationScore"].map(
             t => calculateScoreTeam(team, index, t, counters, headings)).reduce(
             (sum, value) => sum + value);
 
     return summaryArraySum(getPlayerValuesPerTeam(team, index, type, counters, headings));
 }
 
 function calculateBuildings(playerState, index, type)
 {
     return {
         "constructed": playerState.sequences.buildingsConstructed[type][index],
         "destroyed": playerState.sequences.enemyBuildingsDestroyed[type][index],
         "captured": playerState.sequences.buildingsCaptured[type][index],
         "lost": playerState.sequences.buildingsLost[type][index]
     };
 }
 
 function calculateBuildingsTeam(team, index, type, counters, headings)
 {
     return summaryArraySum(getPlayerValuesPerTeam(team, index, type, counters, headings));
 }
 
 function calculateUnitsTeam(team, index, type, counters, headings)
 {
     return summaryArraySum(getPlayerValuesPerTeam(team, index, type, counters, headings));
 }
 
 function calculateUnitsWithCaptured(playerState, index, type)
 {
     return {
+        "alive": playerState.sequences.unitsAlive[type][index],
         "trained": playerState.sequences.unitsTrained[type][index],
         "killed": playerState.sequences.enemyUnitsKilled[type][index],
         "captured": playerState.sequences.unitsCaptured[type][index],
         "lost": playerState.sequences.unitsLost[type][index]
     };
 }
 
 function calculateUnits(playerState, index, type)
 {
     return {
+        "alive": playerState.sequences.unitsAlive[type][index],
         "trained": playerState.sequences.unitsTrained[type][index],
         "killed": playerState.sequences.enemyUnitsKilled[type][index],
         "lost": playerState.sequences.unitsLost[type][index]
     };
 }
 
 function calculateResources(playerState, index, type)
 {
     return {
+        "count": playerState.sequences.resourcesCount[type][index],
         "gathered": playerState.sequences.resourcesGathered[type][index],
         "used": playerState.sequences.resourcesUsed[type][index] - playerState.sequences.resourcesSold[type][index]
     };
 }
 
 function calculateTotalResources(playerState, index)
 {
     let totalGathered = 0;
     let totalUsed = 0;
+    let totalCount = 0;
 
     for (let type of g_ResourceData.GetCodes())
     {
+        totalCount += playerState.sequences.resourcesCount[type][index];
         totalGathered += playerState.sequences.resourcesGathered[type][index];
         totalUsed += playerState.sequences.resourcesUsed[type][index] - playerState.sequences.resourcesSold[type][index];
     }
 
-    return { "gathered": totalGathered, "used": totalUsed };
+    return { "count": totalCount, "gathered": totalGathered, "used": totalUsed };
 }
 
 function calculateTreasureCollected(playerState, index)
 {
     return playerState.sequences.treasuresCollected[index];
 }
 
 function calculateLootCollected(playerState, index)
 {
     return playerState.sequences.lootCollected[index];
 }
 
 function calculateTributeSent(playerState, index)
 {
     return {
         "sent": playerState.sequences.tributesSent[index],
         "received": playerState.sequences.tributesReceived[index]
     };
 }
 
 function calculateLivestockTrained(playerState, index)
 {
     return playerState.sequences.unitsTrained.Domestic[index];
 }
 
 function calculateResourcesTeam(team, index, type, counters, headings)
 {
     return summaryArraySum(getPlayerValuesPerTeam(team, index, type, counters, headings));
 }
 
 function calculateResourceExchanged(playerState, index, type)
 {
     return {
         "bought": playerState.sequences.resourcesBought[type][index],
         "sold": playerState.sequences.resourcesSold[type][index]
     };
 }
 
 function calculateBarterEfficiency(playerState, index)
 {
     let totalBought = 0;
     let totalSold = 0;
 
     for (let type in playerState.sequences.resourcesBought)
         totalBought += playerState.sequences.resourcesBought[type][index];
 
     for (let type in playerState.sequences.resourcesSold)
         totalSold += playerState.sequences.resourcesSold[type][index];
 
     return calculatePercent(totalBought, totalSold);
 }
 
 function calculateTradeIncome(playerState, index)
 {
     return playerState.sequences.tradeIncome[index];
 }
 
 function calculateMarketTeam(team, index, type, counters, headings)
 {
     if (type == "barterEfficency")
         return calculatePercent(g_TeamHelperData[team].totalBought[index], g_TeamHelperData[team].totalSold[index]);
 
     return summaryArraySum(getPlayerValuesPerTeam(team, index, type, counters, headings));
 }
 
 function calculateVegetarianRatio(playerState, index)
 {
     return calculatePercent(
         playerState.sequences.resourcesGathered.vegetarianFood[index],
         playerState.sequences.resourcesGathered.food[index]);
 }
 
 function calculateFeminization(playerState, index)
 {
     return calculatePercent(
         playerState.sequences.unitsTrained.FemaleCitizen[index],
         playerState.sequences.unitsTrained.Worker[index]);
 }
 
 function calculateKillDeathRatio(playerState, index)
 {
     return calculateRatio(
         playerState.sequences.enemyUnitsKilled.total[index],
         playerState.sequences.unitsLost.total[index]);
 }
 
 function calculateMapExploration(playerState, index)
 {
     return { "percent": playerState.sequences.percentMapExplored[index] };
 }
 
 function calculateMapFinalControl(playerState, index)
 {
     return { "percent": playerState.sequences.percentMapControlled[index] };
 }
 
 function calculateMapPeakControl(playerState, index)
 {
     return { "percent": playerState.sequences.peakPercentMapControlled[index] };
 }
 
 function calculateMiscellaneousTeam(team, index, type, counters, headings)
 {
     if (type == "vegetarianRatio")
         return calculatePercent(g_TeamHelperData[team].vegetarianFood[index], g_TeamHelperData[team].food[index]);
 
     if (type == "feminization")
         return calculatePercent(g_TeamHelperData[team].femaleCitizen[index], g_TeamHelperData[team].worker[index]);
 
     if (type == "killDeath")
         return calculateRatio(g_TeamHelperData[team].enemyUnitsKilled[index], g_TeamHelperData[team].unitsLost[index]);
 
     if (type == "bribes")
         return summaryArraySum(getPlayerValuesPerTeam(team, index, type, counters, headings));
 
     return { "percent": g_TeamHelperData[team][type][index] };
 }
 
 function calculateBribes(playerState, index, type)
 {
     return {
         "succeeded": playerState.sequences.successfulBribes[index],
         "failed": playerState.sequences.failedBribes[index]
     };
 }

binaries/data/mods/public/gui/summary/summary.js

@@ -1 +1 @@
 const g_CivData = loadCivData(false, false);
 
 var g_ScorePanelsData;
 
 var g_MaxHeadingTitle = 9;
 var g_LongHeadingWidth = 250;
 var g_PlayerBoxYSize = 40;
 var g_PlayerBoxGap = 2;
 var g_PlayerBoxAlpha = 50;
 var g_TeamsBoxYStart = 40;
 
 var g_TypeColors = {
     "blue": "196 198 255",
     "green": "201 255 200",
     "red": "255 213 213",
     "yellow": "255 255 157"
 };
 
 /**
  * Colors, captions and format used for units, structures, etc. types
  */
 var g_SummaryTypes = {
     "percent": {
         "color": "",
         "caption": "%",
         "postfix": "%"
     },
     "trained": {
         "color": g_TypeColors.green,
         "caption": translate("Trained"),
         "postfix": " / "
     },
     "constructed": {
         "color": g_TypeColors.green,
         "caption": translate("Constructed"),
         "postfix": " / "
     },
     "gathered": {
         "color": g_TypeColors.green,
         "caption": translate("Gathered"),
         "postfix": " / "
     },
+    "alive": {
+        "caption": translate("Alive"),
+        "hide": true
+    },
+    "count": {
+        "caption": translate("Count"),
+        "hide": true
+    },
     "sent": {
         "color": g_TypeColors.green,
         "caption": translate("Sent"),
         "postfix": " / "
     },
     "bought": {
         "color": g_TypeColors.green,
         "caption": translate("Bought"),
         "postfix": " / "
     },
     "income": {
         "color": g_TypeColors.green,
         "caption": translate("Income"),
         "postfix": " / "
     },
     "captured": {
         "color": g_TypeColors.yellow,
         "caption": translate("Captured"),
         "postfix": " / "
     },
     "succeeded": {
         "color": g_TypeColors.green,
         "caption": translate("Succeeded"),
         "postfix": " / "
     },
     "destroyed": {
         "color": g_TypeColors.blue,
         "caption": translate("Destroyed"),
         "postfix": "\n"
     },
     "killed": {
         "color": g_TypeColors.blue,
         "caption": translate("Killed"),
         "postfix": "\n"
     },
     "lost": {
         "color": g_TypeColors.red,
         "caption": translate("Lost"),
         "postfix": ""
     },
     "used": {
         "color": g_TypeColors.red,
         "caption": translate("Used"),
         "postfix": ""
     },
     "received": {
         "color": g_TypeColors.red,
         "caption": translate("Received"),
         "postfix": ""
     },
     "sold": {
         "color": g_TypeColors.red,
         "caption": translate("Sold"),
         "postfix": ""
     },
     "outcome": {
         "color": g_TypeColors.red,
         "caption": translate("Outcome"),
         "postfix": ""
     },
     "failed": {
         "color": g_TypeColors.red,
         "caption": translate("Failed"),
         "postfix": ""
     }
 };
 
 // Translation: Unicode encoded infinity symbol indicating a division by zero in the summary screen.
 var g_InfinitySymbol = translate("\u221E");
 
 var g_Teams = [];
 
 var g_PlayerCount;
 
 var g_GameData;
 var g_ResourceData = new Resources();
 
 /**
  * Selected chart indexes.
  */
 var g_SelectedChart = {
     "category": [0, 0],
     "value": [0, 1],
     "type": [0, 0]
 };
 
 function init(data)
 {
     initSummaryData(data);
     initGUISummary();
 }
 
 function initSummaryData(data)
 {
     g_GameData = data;
     g_ScorePanelsData = getScorePanelsData();
 
     let teamCharts = false;
     if (data && data.gui && data.gui.summarySelection)
     {
         g_TabCategorySelected = data.gui.summarySelection.panel;
         g_SelectedChart = data.gui.summarySelection.charts;
         teamCharts = data.gui.summarySelection.teamCharts;
     }
     Engine.GetGUIObjectByName("toggleTeamBox").checked = g_Teams && teamCharts;
 
     initTeamData();
     calculateTeamCounterDataHelper();
 }
 
 function initGUISummary()
 {
     initGUIWindow();
     initPlayerBoxPositions();
     initGUICharts();
     initGUILabels();
     initGUIButtons();
 }
 
 /**
  * Sets the style and title of the page.
  */
 function initGUIWindow()
 {
     let summaryWindow = Engine.GetGUIObjectByName("summaryWindow");
     summaryWindow.sprite = g_GameData.gui.dialog ? "ModernDialog" : "ModernWindow";
     summaryWindow.size = g_GameData.gui.dialog ? "16 24 100%-16 100%-24" : "0 0 100% 100%";
     Engine.GetGUIObjectByName("summaryWindowTitle").size = g_GameData.gui.dialog ? "50%-128 -16 50%+128 16" : "50%-128 4 50%+128 36";
 }
 
 function selectPanelGUI(panel)
 {
     adjustTabDividers(Engine.GetGUIObjectByName("tabButton[" + panel + "]").size);
 
     let generalPanel = Engine.GetGUIObjectByName("generalPanel");
     let chartsPanel = Engine.GetGUIObjectByName("chartsPanel");
 
     // We assume all scorePanels come before the charts.
     let chartsHidden = panel < g_ScorePanelsData.length;
     generalPanel.hidden = !chartsHidden;
     chartsPanel.hidden = chartsHidden;
     if (chartsHidden)
         updatePanelData(g_ScorePanelsData[panel]);
     else
         [0, 1].forEach(updateCategoryDropdown);
 }
 
 function constructPlayersWithColor(color, playerListing)
 {
     return sprintf(translateWithContext("Player listing with color indicator",
         "%(colorIndicator)s %(playerListing)s"),
     {
         "colorIndicator": setStringTags(translateWithContext(
             "Charts player color indicator", "■"), { "color": color }),
         "playerListing": playerListing
     });
 }
 
 function updateChartColorAndLegend()
 {
     let playerColors = [];
     for (let i = 1; i <= g_PlayerCount; ++i)
     {
         let playerState = g_GameData.sim.playerStates[i];
         playerColors.push(
             Math.floor(playerState.color.r * 255) + " " +
             Math.floor(playerState.color.g * 255) + " " +
             Math.floor(playerState.color.b * 255)
         );
     }
 
     for (let i = 0; i < 2; ++i)
         Engine.GetGUIObjectByName("chart[" + i + "]").series_color =
             Engine.GetGUIObjectByName("toggleTeamBox").checked ?
                 g_Teams.filter(el => el !== null).map(players => playerColors[players[0] - 1]) :
                 playerColors;
 
     let chartLegend = Engine.GetGUIObjectByName("chartLegend");
     chartLegend.caption = (Engine.GetGUIObjectByName("toggleTeamBox").checked ?
         g_Teams.filter(el => el !== null).map(players =>
             constructPlayersWithColor(playerColors[players[0] - 1], players.map(player =>
                 g_GameData.sim.playerStates[player].name
             ).join(translateWithContext("Player listing", ", ")))
         ) :
         g_GameData.sim.playerStates.slice(1).map((state, index) =>
             constructPlayersWithColor(playerColors[index], state.name))
     ).join("   ");
 }
 
 function initGUICharts()
 {
     updateChartColorAndLegend();
     let chart1Part = Engine.GetGUIObjectByName("chart[1]Part");
     let chart1PartSize = chart1Part.size;
     chart1PartSize.rright += 50;
     chart1PartSize.rleft += 50;
     chart1PartSize.right -= 5;
     chart1PartSize.left -= 5;
     chart1Part.size = chart1PartSize;
     Engine.GetGUIObjectByName("toggleTeam").hidden = !g_Teams;
 }
 
 function resizeDropdown(dropdown)
 {
     let size = dropdown.size;
     size.bottom = dropdown.size.top +
         (Engine.GetTextWidth(dropdown.font, dropdown.list[dropdown.selected]) >
             dropdown.size.right - dropdown.size.left - 32 ? 42 : 27);
     dropdown.size = size;
 }
 
 function updateCategoryDropdown(number)
 {
     let chartCategory = Engine.GetGUIObjectByName("chart[" + number + "]CategorySelection");
     chartCategory.list_data = g_ScorePanelsData.map((panel, idx) => idx);
     chartCategory.list = g_ScorePanelsData.map(panel => panel.label);
     chartCategory.onSelectionChange = function() {
         if (!this.list_data[this.selected])
             return;
         if (g_SelectedChart.category[number] != this.selected)
         {
             g_SelectedChart.category[number] = this.selected;
             g_SelectedChart.value[number] = 0;
             g_SelectedChart.type[number] = 0;
         }
 
         resizeDropdown(this);
         updateValueDropdown(number, this.list_data[this.selected]);
     };
     chartCategory.selected = g_SelectedChart.category[number];
 }
 
 function updateValueDropdown(number, category)
 {
     let chartValue = Engine.GetGUIObjectByName("chart[" + number + "]ValueSelection");
     let list = g_ScorePanelsData[category].headings.map(heading => heading.caption);
     list.shift();
     chartValue.list = list;
     let list_data = g_ScorePanelsData[category].headings.map(heading => heading.identifier);
     list_data.shift();
     chartValue.list_data = list_data;
     chartValue.onSelectionChange = function() {
         if (!this.list_data[this.selected])
             return;
         if (g_SelectedChart.value[number] != this.selected)
         {
             g_SelectedChart.value[number] = this.selected;
             g_SelectedChart.type[number] = 0;
         }
 
         resizeDropdown(this);
         updateTypeDropdown(number, category, this.list_data[this.selected], this.selected);
     };
     chartValue.selected = g_SelectedChart.value[number];
 }
 
 function updateTypeDropdown(number, category, item, itemNumber)
 {
     let testValue = g_ScorePanelsData[category].counters[itemNumber].fn(g_GameData.sim.playerStates[1], 0, item);
     let hide = !g_ScorePanelsData[category].counters[itemNumber].fn ||
         typeof testValue != "object" || Object.keys(testValue).length < 2;
     Engine.GetGUIObjectByName("chart[" + number + "]TypeLabel").hidden = hide;
     let chartType = Engine.GetGUIObjectByName("chart[" + number + "]TypeSelection");
     chartType.hidden = hide;
     if (hide)
     {
         updateChart(number, category, item, itemNumber, Object.keys(testValue)[0] || undefined);
         return;
     }
 
     chartType.list = Object.keys(testValue).map(type => g_SummaryTypes[type].caption);
     chartType.list_data = Object.keys(testValue);
     chartType.onSelectionChange = function() {
         if (!this.list_data[this.selected])
             return;
         g_SelectedChart.type[number] = this.selected;
         resizeDropdown(this);
         updateChart(number, category, item, itemNumber, this.list_data[this.selected]);
     };
     chartType.selected = g_SelectedChart.type[number];
 }
 
 function updateChart(number, category, item, itemNumber, type)
 {
     if (!g_ScorePanelsData[category].counters[itemNumber].fn)
         return;
     let chart = Engine.GetGUIObjectByName("chart[" + number + "]");
     chart.format_y = g_ScorePanelsData[category].headings[itemNumber + 1].format || "INTEGER";
     Engine.GetGUIObjectByName("chart[" + number + "]XAxisLabel").caption = translate("Time elapsed");
 
     let series = [];
     if (Engine.GetGUIObjectByName("toggleTeamBox").checked)
         for (let team in g_Teams)
         {
             let data = [];
             for (let index in g_GameData.sim.playerStates[1].sequences.time)
             {
                 let value = g_ScorePanelsData[category].teamCounterFn(team, index, item,
                     g_ScorePanelsData[category].counters, g_ScorePanelsData[category].headings);
                 if (type)
                     value = value[type];
                 data.push([g_GameData.sim.playerStates[1].sequences.time[index], value]);
             }
             series.push(data);
         }
     else
         for (let j = 1; j <= g_PlayerCount; ++j)
         {
             let playerState = g_GameData.sim.playerStates[j];
             let data = [];
             for (let index in playerState.sequences.time)
             {
                 let value = g_ScorePanelsData[category].counters[itemNumber].fn(playerState, index, item);
                 if (type)
                     value = value[type];
                 data.push([playerState.sequences.time[index], value]);
             }
             series.push(data);
         }
 
     chart.series = series;
 }
 
 function adjustTabDividers(tabSize)
 {
     let tabButtonsLeft = Engine.GetGUIObjectByName("tabButtonsFrame").size.left;
 
     let leftSpacer = Engine.GetGUIObjectByName("tabDividerLeft");
     let leftSpacerSize = leftSpacer.size;
     leftSpacerSize.right = tabSize.left + tabButtonsLeft + 2;
     leftSpacer.size = leftSpacerSize;
 
     let rightSpacer = Engine.GetGUIObjectByName("tabDividerRight");
     let rightSpacerSize = rightSpacer.size;
     rightSpacerSize.left = tabSize.right + tabButtonsLeft - 2;
     rightSpacer.size = rightSpacerSize;
 }
 
 function updatePanelData(panelInfo)
 {
     resetGeneralPanel();
     updateGeneralPanelHeadings(panelInfo.headings);
     updateGeneralPanelTitles(panelInfo.titleHeadings);
     let rowPlayerObjectWidth = updateGeneralPanelCounter(panelInfo.counters);
     updateGeneralPanelTeams();
 
     let index = g_GameData.sim.playerStates[1].sequences.time.length - 1;
     let playerBoxesCounts = [];
     for (let i = 0; i < g_PlayerCount; ++i)
     {
         let playerState = g_GameData.sim.playerStates[i + 1];
 
         if (!playerBoxesCounts[playerState.team + 1])
             playerBoxesCounts[playerState.team + 1] = 1;
         else
             playerBoxesCounts[playerState.team + 1] += 1;
 
         let positionObject = playerBoxesCounts[playerState.team + 1] - 1;
         let rowPlayer = "playerBox[" + positionObject + "]";
         let playerOutcome = "playerOutcome[" + positionObject + "]";
         let playerNameColumn = "playerName[" + positionObject + "]";
         let playerCivicBoxColumn = "civIcon[" + positionObject + "]";
         let playerCounterValue = "valueData[" + positionObject + "]";
 
         if (playerState.team != -1)
         {
             rowPlayer = "playerBoxt[" + playerState.team + "][" + positionObject + "]";
             playerOutcome = "playerOutcomet[" + playerState.team + "][" + positionObject + "]";
             playerNameColumn = "playerNamet[" + playerState.team + "][" + positionObject + "]";
             playerCivicBoxColumn = "civIcont[" + playerState.team + "][" + positionObject + "]";
             playerCounterValue = "valueDataTeam[" + playerState.team + "][" + positionObject + "]";
         }
 
         let colorString = "color: " +
             Math.floor(playerState.color.r * 255) + " " +
             Math.floor(playerState.color.g * 255) + " " +
             Math.floor(playerState.color.b * 255);
 
         let rowPlayerObject = Engine.GetGUIObjectByName(rowPlayer);
         rowPlayerObject.hidden = false;
         rowPlayerObject.sprite = colorString + " " + g_PlayerBoxAlpha;
 
         let boxSize = rowPlayerObject.size;
         boxSize.right = rowPlayerObjectWidth;
         rowPlayerObject.size = boxSize;
 
         setOutcomeIcon(playerState.state, Engine.GetGUIObjectByName(playerOutcome));
 
         playerNameColumn = Engine.GetGUIObjectByName(playerNameColumn);
         playerNameColumn.caption = g_GameData.sim.playerStates[i + 1].name;
         playerNameColumn.tooltip = translateAISettings(g_GameData.sim.mapSettings.PlayerData[i + 1]);
 
         let civIcon = Engine.GetGUIObjectByName(playerCivicBoxColumn);
         civIcon.sprite = "stretched:" + g_CivData[playerState.civ].Emblem;
         civIcon.tooltip = g_CivData[playerState.civ].Name;
 
         updateCountersPlayer(playerState, panelInfo.counters, panelInfo.headings, playerCounterValue, index);
     }
 
     let teamCounterFn = panelInfo.teamCounterFn;
     if (g_Teams && teamCounterFn)
         updateCountersTeam(teamCounterFn, panelInfo.counters, panelInfo.headings, index);
 }
 
 function continueButton()
 {
     let summarySelection = {
         "panel": g_TabCategorySelected,
         "charts": g_SelectedChart,
         "teamCharts": Engine.GetGUIObjectByName("toggleTeamBox").checked
     };
     if (g_GameData.gui.isInGame)
         Engine.PopGuiPage({
             "summarySelection": summarySelection
         });
     else if (g_GameData.gui.dialog)
         Engine.PopGuiPage();
     else if (Engine.HasXmppClient())
         Engine.SwitchGuiPage("page_lobby.xml", { "dialog": false });
     else if (g_GameData.gui.isReplay)
         Engine.SwitchGuiPage("page_replaymenu.xml", {
             "replaySelectionData": g_GameData.gui.replaySelectionData,
             "summarySelection": summarySelection
         });
     else
         Engine.SwitchGuiPage("page_pregame.xml");
 }
 
 function startReplay()
 {
     if (!Engine.StartVisualReplay(g_GameData.gui.replayDirectory))
     {
         warn("Replay file not found!");
         return;
     }
 
     Engine.SwitchGuiPage("page_loading.xml", {
         "attribs": Engine.GetReplayAttributes(g_GameData.gui.replayDirectory),
         "playerAssignments": {
             "local": {
                 "name": singleplayerName(),
                 "player": -1
             }
         },
         "savedGUIData": "",
         "isReplay": true,
         "replaySelectionData": g_GameData.gui.replaySelectionData
     });
 }
 
 function initGUILabels()
 {
     let assignedState = g_GameData.sim.playerStates[g_GameData.gui.assignedPlayer || -1];
 
     Engine.GetGUIObjectByName("summaryText").caption =
         g_GameData.gui.isInGame ?
             translate("Current Scores") :
         g_GameData.gui.isReplay ?
             translate("Scores at the end of the game.") :
         g_GameData.gui.disconnected ?
             translate("You have been disconnected.") :
         !assignedState ?
             translate("You have left the game.") :
         assignedState.state == "won" ?
             translate("You have won the battle!") :
         assignedState.state == "defeated" ?
             translate("You have been defeated…") :
             translate("You have abandoned the game.");
 
     Engine.GetGUIObjectByName("timeElapsed").caption = sprintf(
         translate("Game time elapsed: %(time)s"), {
             "time": timeToString(g_GameData.sim.timeElapsed)
     });
 
     let mapType = g_Settings.MapTypes.find(type => type.Name == g_GameData.sim.mapSettings.mapType);
     let mapSize = g_Settings.MapSizes.find(size => size.Tiles == g_GameData.sim.mapSettings.Size || 0);
 
     Engine.GetGUIObjectByName("mapName").caption = sprintf(
         translate("%(mapName)s - %(mapType)s"), {
             "mapName": translate(g_GameData.sim.mapSettings.Name),
             "mapType": mapSize ? mapSize.Name : (mapType ? mapType.Title : "")
         });
 }
 
 function initGUIButtons()
 {
     let replayButton = Engine.GetGUIObjectByName("replayButton");
     replayButton.hidden = g_GameData.gui.isInGame || !g_GameData.gui.replayDirectory;
 
     let lobbyButton = Engine.GetGUIObjectByName("lobbyButton");
     lobbyButton.tooltip = colorizeHotkey(translate("%(hotkey)s: Toggle the multiplayer lobby in a dialog window."), "lobby");
     lobbyButton.hidden = g_GameData.gui.isInGame || !Engine.HasXmppClient();
 
     // Right-align lobby button
     let lobbyButtonSize = lobbyButton.size;
     let lobbyButtonWidth = lobbyButtonSize.right - lobbyButtonSize.left;
     lobbyButtonSize.right = (replayButton.hidden ? Engine.GetGUIObjectByName("continueButton").size.left : replayButton.size.left) - 10;
     lobbyButtonSize.left = lobbyButtonSize.right - lobbyButtonWidth;
     lobbyButton.size = lobbyButtonSize;
 
     let allPanelsData = g_ScorePanelsData.concat(g_ChartPanelsData);
     for (let tab in allPanelsData)
         allPanelsData[tab].tooltip =
             sprintf(translate("Toggle the %(name)s summary tab."), { "name": allPanelsData[tab].label }) +
             colorizeHotkey("\n" + translate("Use %(hotkey)s to move a summary tab right."), "tab.next") +
             colorizeHotkey("\n" + translate("Use %(hotkey)s to move a summary tab left."), "tab.prev");
 
     placeTabButtons(
         allPanelsData,
         true,
         g_TabButtonWidth,
         g_TabButtonDist,
         selectPanel,
         selectPanelGUI);
 }
 
 function initTeamData()
 {
     // Panels
     g_PlayerCount = g_GameData.sim.playerStates.length - 1;
 
     if (g_GameData.sim.mapSettings.LockTeams)
     {
         // Count teams
         for (let player = 1; player <= g_PlayerCount; ++player)
         {
             let playerTeam = g_GameData.sim.playerStates[player].team;
             if (!g_Teams[playerTeam])
                 g_Teams[playerTeam] = [];
             g_Teams[playerTeam].push(player);
         }
 
         if (g_Teams.every(team => team && team.length < 2))
             g_Teams = false;    // Each player has his own team. Displaying teams makes no sense.
     }
     else
         g_Teams = false;
 
     // Erase teams data if teams are not displayed
     if (!g_Teams)
         for (let p = 0; p < g_PlayerCount; ++p)
             g_GameData.sim.playerStates[p+1].team = -1;
 }

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

@@ -1 +1 @@
 function StatisticsTracker() {}
 
 StatisticsTracker.prototype.Schema =
     "<a:help>This component records statistics over the course of the match, such as the number of trained, lost, captured and destroyed units and buildings The statistics are consumed by the summary screen and lobby rankings.</a:help>" +
     "<a:example>" +
         "<UnitClasses>Infantry FemaleCitizen</UnitClasses>" +
         "<StructureClasses>House Wonder</StructureClasses>" +
     "</a:example>" +
     "<element name='UnitClasses' a:help='The tracker records trained, lost, killed and captured units of entities that match any of these Identity classes.'>" +
         "<attribute name='datatype'>" +
             "<value>tokens</value>" +
         "</attribute>" +
         "<text/>" +
     "</element>" +
     "<element name='StructureClasses' a:help='The tracker records constructed, lost, destroyed and captured structures of entities that match any of these Identity classes.'>" +
         "<attribute name='datatype'>" +
             "<value>tokens</value>" +
         "</attribute>" +
         "<text/>" +
     "</element>";
 
 /**
  * This number specifies the time in milliseconds between consecutive statistics snapshots recorded.
  */
 StatisticsTracker.prototype.UpdateSequenceInterval = 30 * 1000;
 
 StatisticsTracker.prototype.Init = function()
 {
     this.unitsClasses = this.template.UnitClasses._string.split(/\s+/);
     this.buildingsClasses = this.template.StructureClasses._string.split(/\s+/);
 
+    this.unitsAlive = {};
     this.unitsTrained = {};
     this.unitsLost = {};
     this.enemyUnitsKilled = {};
     this.unitsCaptured = {};
 
     this.unitsLostValue = 0;
     this.enemyUnitsKilledValue = 0;
     this.unitsCapturedValue = 0;
 
-    for (let counterName of ["unitsTrained", "unitsLost", "enemyUnitsKilled", "unitsCaptured"])
+    for (let counterName of ["unitsAlive", "unitsTrained", "unitsLost", "enemyUnitsKilled", "unitsCaptured"])
     {
         this[counterName].total = 0;
         for (let unitClass of this.unitsClasses)
             // Domestic units are only counted for training
             if (unitClass != "Domestic" || counterName == "unitsTrained")
                 this[counterName][unitClass] = 0;
     }
 
     this.buildingsConstructed = {};
     this.buildingsLost = {};
     this.enemyBuildingsDestroyed = {};
     this.buildingsCaptured = {};
 
     this.buildingsLostValue = 0;
     this.enemyBuildingsDestroyedValue = 0;
     this.buildingsCapturedValue = 0;
 
     for (let counterName of ["buildingsConstructed", "buildingsLost", "enemyBuildingsDestroyed", "buildingsCaptured"])
     {
         this[counterName].total = 0;
         for (let unitClass of this.buildingsClasses)
             this[counterName][unitClass] = 0;
     }
 
     this.resourcesGathered = {
         "vegetarianFood": 0
     };
     this.resourcesUsed = {};
     this.resourcesSold = {};
     this.resourcesBought = {};
     for (let res of Resources.GetCodes())
     {
         this.resourcesGathered[res] = 0;
         this.resourcesUsed[res] = 0;
         this.resourcesSold[res] = 0;
         this.resourcesBought[res] = 0;
     }
 
     this.tributesSent = 0;
     this.tributesReceived = 0;
     this.tradeIncome = 0;
     this.treasuresCollected = 0;
     this.lootCollected = 0;
     this.peakPercentMapControlled = 0;
     this.teamPeakPercentMapControlled = 0;
     this.successfulBribes = 0;
     this.failedBribes = 0;
 
     let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
     this.updateTimer = cmpTimer.SetInterval(
         this.entity, IID_StatisticsTracker, "UpdateSequences", 0, this.UpdateSequenceInterval);
 };
 
 StatisticsTracker.prototype.OnGlobalInitGame = function()
 {
     this.sequences = clone(this.GetStatistics());
     this.sequences.time = [];
+    this.unitsAlive = this.GetUnitsAlive();
 };
 
 /**
  * Returns a subset of statistics that will be added to the simulation state,
  * thus called each turn. Basic statistics should not contain data that would
  * be expensive to compute.
  *
  * Note: as of now, nothing in the game needs that, but some AIs developed by
  * modders need it in the API.
  */
 StatisticsTracker.prototype.GetBasicStatistics = function()
 {
     return {
         "resourcesGathered": this.resourcesGathered,
         "percentMapExplored": this.GetPercentMapExplored()
     };
 };
 
 StatisticsTracker.prototype.GetStatistics = function()
 {
     return {
+        "unitsAlive": this.unitsAlive,
         "unitsTrained": this.unitsTrained,
         "unitsLost": this.unitsLost,
         "unitsLostValue": this.unitsLostValue,
         "enemyUnitsKilled": this.enemyUnitsKilled,
         "enemyUnitsKilledValue": this.enemyUnitsKilledValue,
         "unitsCaptured": this.unitsCaptured,
         "unitsCapturedValue": this.unitsCapturedValue,
         "buildingsConstructed": this.buildingsConstructed,
         "buildingsLost": this.buildingsLost,
         "buildingsLostValue": this.buildingsLostValue,
         "enemyBuildingsDestroyed": this.enemyBuildingsDestroyed,
         "enemyBuildingsDestroyedValue": this.enemyBuildingsDestroyedValue,
         "buildingsCaptured": this.buildingsCaptured,
         "buildingsCapturedValue": this.buildingsCapturedValue,
+        "resourcesCount": this.GetResourceCounts(),
         "resourcesGathered": this.resourcesGathered,
         "resourcesUsed": this.resourcesUsed,
         "resourcesSold": this.resourcesSold,
         "resourcesBought": this.resourcesBought,
         "tributesSent": this.tributesSent,
         "tributesReceived": this.tributesReceived,
         "tradeIncome": this.tradeIncome,
         "treasuresCollected": this.treasuresCollected,
         "lootCollected": this.lootCollected,
         "percentMapExplored": this.GetPercentMapExplored(),
         "teamPercentMapExplored": this.GetTeamPercentMapExplored(),
         "percentMapControlled": this.GetPercentMapControlled(),
         "teamPercentMapControlled": this.GetTeamPercentMapControlled(),
         "peakPercentMapControlled": this.peakPercentMapControlled,
         "teamPeakPercentMapControlled": this.teamPeakPercentMapControlled,
         "successfulBribes": this.successfulBribes,
         "failedBribes": this.failedBribes
     };
 };
 
 StatisticsTracker.prototype.GetSequences = function()
 {
     let ret = clone(this.sequences);
     let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 
     ret.time.push(cmpTimer.GetTime() / 1000);
     this.PushValue(this.GetStatistics(), ret);
     return ret;
 };
 
 /**
  * Used to print statistics for non-visual autostart games.
  * @return The player's statistics as a JSON string beautified with some indentations.
  */
 StatisticsTracker.prototype.GetStatisticsJSON = function()
 {
     let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
 
     let playerStatistics = {
         "playerID": cmpPlayer.GetPlayerID(),
         "playerState": cmpPlayer.GetState(),
         "statistics": this.GetStatistics()
     };
 
     return JSON.stringify(playerStatistics, null, "\t");
 };
 
 /**
+ * @return Breakdown of the living units
+ */
+StatisticsTracker.prototype.GetUnitsAlive = function() {
+    let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
+
+    let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    let entities = cmpRangeManager.GetEntitiesByPlayer(cmpPlayer.playerID);
+
+    let unitsAlive = { total: 0 };
+    for (let unitClass of this.unitsClasses)
+        unitsAlive[unitClass] = 0;
+
+    for (let entity of entities)
+    {
+        let cmpEntityIdentity = Engine.QueryInterface(entity, IID_Identity);
+        if (!cmpEntityIdentity)
+            break;
+
+        if (cmpEntityIdentity.HasClass("Unit"))
+        {
+            let classes = cmpEntityIdentity.GetClassesList();
+            if (!classes)
+                return;
+
+            for(let type in classes)
+                if (unitsAlive[type] !== undefined)
+                {
+                    ++unitsAlive[type];
+                }
+
+            if (!cmpEntityIdentity.HasClass("Domestic"))
+                ++unitsAlive.total;
+        }
+
+    }
+
+    return unitsAlive;
+}
+
+/**
  * Increments counter associated with certain entity/counter and type of given entity.
  * @param cmpIdentity - the entity identity component.
  * @param counter - the name of the counter to increment (e.g. "unitsTrained").
  * @param type - the type of the counter (e.g. "workers").
+ * @param value - the value to increment the counter with (default: 1) (e.g. -1 to decrement the counter)
  */
-StatisticsTracker.prototype.CounterIncrement = function(cmpIdentity, counter, type)
+StatisticsTracker.prototype.CounterIncrement = function(cmpIdentity, counter, type, value=1)
 {
     var classes = cmpIdentity.GetClassesList();
     if (!classes)
         return;
 
     if (classes.indexOf(type) != -1)
-        ++this[counter][type];
+        this[counter][type] += value;
 };
 
 /**
  * Counts the total number of units trained as well as an individual count for
  * each unit type. Based on templates.
  */
 StatisticsTracker.prototype.IncreaseTrainedUnitsCounter = function(trainedUnit)
 {
     let cmpUnitEntityIdentity = Engine.QueryInterface(trainedUnit, IID_Identity);
 
     if (!cmpUnitEntityIdentity)
         return;
 
     let cmpCost = Engine.QueryInterface(trainedUnit, IID_Cost);
     let costs = cmpCost && cmpCost.GetResourceCosts();
 
     for (let type of this.unitsClasses)
+    {
         this.CounterIncrement(cmpUnitEntityIdentity, "unitsTrained", type);
+        this.CounterIncrement(cmpUnitEntityIdentity, "unitsAlive", type);
+    }
 
     if (!cmpUnitEntityIdentity.HasClass("Domestic"))
+    {
         ++this.unitsTrained.total;
+        ++this.unitsAlive.total;
+    }
 
     if (cmpUnitEntityIdentity.HasClass("Domestic") && costs)
     {
         // Subtract costs for sheep/goats/pigs to get the net food gain/use for corralling
         this.resourcesUsed.food -= costs.food;
         this.resourcesGathered.food -= costs.food;
     }
 
 };
 
 /**
  * Counts the total number of buildings constructed as well as an individual count for
  * each building type. Based on templates.
  */
 StatisticsTracker.prototype.IncreaseConstructedBuildingsCounter = function(constructedBuilding)
 {
     var cmpBuildingEntityIdentity = Engine.QueryInterface(constructedBuilding, IID_Identity);
 
     if (!cmpBuildingEntityIdentity)
         return;
 
     for (let type of this.buildingsClasses)
         this.CounterIncrement(cmpBuildingEntityIdentity, "buildingsConstructed", type);
 
     ++this.buildingsConstructed.total;
 };
 
 StatisticsTracker.prototype.KilledEntity = function(targetEntity)
 {
     var cmpTargetEntityIdentity = Engine.QueryInterface(targetEntity, IID_Identity);
     if (!cmpTargetEntityIdentity)
         return;
 
     var cmpCost = Engine.QueryInterface(targetEntity, IID_Cost);
     var costs = cmpCost && cmpCost.GetResourceCosts();
 
     // Exclude gaia animals but not gaia soldiers.
     if (cmpTargetEntityIdentity.HasClass("Unit") && !cmpTargetEntityIdentity.HasClass("Animal"))
     {
         for (let type of this.unitsClasses)
             this.CounterIncrement(cmpTargetEntityIdentity, "enemyUnitsKilled", type);
 
         ++this.enemyUnitsKilled.total;
 
         if (costs)
             for (let type in costs)
                 this.enemyUnitsKilledValue += costs[type];
     }
 
     let cmpFoundation = Engine.QueryInterface(targetEntity, IID_Foundation);
     if (cmpTargetEntityIdentity.HasClass("Structure") && !cmpFoundation)
     {
         for (let type of this.buildingsClasses)
             this.CounterIncrement(cmpTargetEntityIdentity, "enemyBuildingsDestroyed", type);
 
         ++this.enemyBuildingsDestroyed.total;
 
         if (costs)
             for (let type in costs)
                 this.enemyBuildingsDestroyedValue += costs[type];
     }
 };
 
 StatisticsTracker.prototype.LostEntity = function(lostEntity)
 {
     var cmpLostEntityIdentity = Engine.QueryInterface(lostEntity, IID_Identity);
     if (!cmpLostEntityIdentity)
         return;
 
     var cmpCost = Engine.QueryInterface(lostEntity, IID_Cost);
     var costs = cmpCost && cmpCost.GetResourceCosts();
 
     if (cmpLostEntityIdentity.HasClass("Unit") && !cmpLostEntityIdentity.HasClass("Domestic"))
     {
         for (let type of this.unitsClasses)
+        {
             this.CounterIncrement(cmpLostEntityIdentity, "unitsLost", type);
+            this.CounterIncrement(cmpLostEntityIdentity, "unitsAlive", type, -1);
+        }
 
         ++this.unitsLost.total;
+        --this.unitsAlive.total;
 
         if (costs)
             for (let type in costs)
                 this.unitsLostValue += costs[type];
     }
 
     let cmpFoundation = Engine.QueryInterface(lostEntity, IID_Foundation);
     if (cmpLostEntityIdentity.HasClass("Structure") && !cmpFoundation)
     {
         for (let type of this.buildingsClasses)
             this.CounterIncrement(cmpLostEntityIdentity, "buildingsLost", type);
 
         ++this.buildingsLost.total;
 
         if (costs)
             for (let type in costs)
                 this.buildingsLostValue += costs[type];
     }
 };
 
 StatisticsTracker.prototype.CapturedEntity = function(capturedEntity)
 {
     let cmpCapturedEntityIdentity = Engine.QueryInterface(capturedEntity, IID_Identity);
     if (!cmpCapturedEntityIdentity)
         return;
 
     let cmpCost = Engine.QueryInterface(capturedEntity, IID_Cost);
     let costs = cmpCost && cmpCost.GetResourceCosts();
 
     if (cmpCapturedEntityIdentity.HasClass("Unit"))
     {
         for (let type of this.unitsClasses)
+        {
             this.CounterIncrement(cmpCapturedEntityIdentity, "unitsCaptured", type);
+            this.CounterIncrement(cmpCapturedEntityIdentity, "unitsAlive", type);
+        }
 
         ++this.unitsCaptured.total;
+        ++this.unitsAlive.total;
 
         if (costs)
             for (let type in costs)
                 this.unitsCapturedValue += costs[type];
     }
 
     if (cmpCapturedEntityIdentity.HasClass("Structure"))
     {
         for (let type of this.buildingsClasses)
             this.CounterIncrement(cmpCapturedEntityIdentity, "buildingsCaptured", type);
 
         ++this.buildingsCaptured.total;
 
         if (costs)
             for (let type in costs)
                 this.buildingsCapturedValue += costs[type];
     }
 };
 
+StatisticsTracker.prototype.GetResourceCounts = function() {
+    let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
+    if (!cmpPlayer) {
+        let empty = {};
+        for (let res of Resources.GetCodes())
+            empty[res] = 0;
+        return empty;
+    }
+    return cmpPlayer.GetResourceCounts();
+}
+
 /**
  * @param {string} type - generic type of resource.
  * @param {number} amount - amount of resource, whick should be added.
  * @param {string} specificType - specific type of resource.
  */
 StatisticsTracker.prototype.IncreaseResourceGatheredCounter = function(type, amount, specificType)
 {
     this.resourcesGathered[type] += amount;
 
     if (type == "food" && (specificType == "fruit" || specificType == "grain"))
         this.resourcesGathered.vegetarianFood += amount;
 };
 
 /**
  * @param {string} type - generic type of resource.
  * @param {number} amount - amount of resource, which should be added.
  */
 StatisticsTracker.prototype.IncreaseResourceUsedCounter = function(type, amount)
 {
     this.resourcesUsed[type] += amount;
 };
 
 StatisticsTracker.prototype.IncreaseTreasuresCollectedCounter = function()
 {
     ++this.treasuresCollected;
 };
 
 StatisticsTracker.prototype.IncreaseLootCollectedCounter = function(amount)
 {
     for (let type in amount)
         this.lootCollected += amount[type];
 };
 
 StatisticsTracker.prototype.IncreaseResourcesSoldCounter = function(type, amount)
 {
     this.resourcesSold[type] += amount;
 };
 
 StatisticsTracker.prototype.IncreaseResourcesBoughtCounter = function(type, amount)
 {
     this.resourcesBought[type] += amount;
 };
 
 StatisticsTracker.prototype.IncreaseTributesSentCounter = function(amount)
 {
     this.tributesSent += amount;
 };
 
 StatisticsTracker.prototype.IncreaseTributesReceivedCounter = function(amount)
 {
     this.tributesReceived += amount;
 };
 
 StatisticsTracker.prototype.IncreaseTradeIncomeCounter = function(amount)
 {
     this.tradeIncome += amount;
 };
 
 StatisticsTracker.prototype.IncreaseSuccessfulBribesCounter = function()
 {
     ++this.successfulBribes;
 };
 
 StatisticsTracker.prototype.IncreaseFailedBribesCounter = function()
 {
     ++this.failedBribes;
 };
 
 StatisticsTracker.prototype.GetPercentMapExplored = function()
 {
     let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
     if (!cmpPlayer)
         return 0;
 
     return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetPercentMapExplored(cmpPlayer.GetPlayerID());
 };
 
 /**
  * Note: cmpRangeManager.GetUnionPercentMapExplored computes statistics from scratch!
  * As a consequence, this function should not be called too often.
  */
 StatisticsTracker.prototype.GetTeamPercentMapExplored = function()
 {
     let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
     if (!cmpPlayer)
         return 0;
 
     let team = cmpPlayer.GetTeam();
     let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     // If teams are not locked, this statistic won't be displayed, so don't bother computing
     if (team == -1 || !cmpPlayer.GetLockTeams())
         return cmpRangeManager.GetPercentMapExplored(cmpPlayer.GetPlayerID());
 
     let teamPlayers = [];
     let numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
     for (let i = 1; i < numPlayers; ++i)
     {
         let cmpOtherPlayer = QueryPlayerIDInterface(i);
         if (cmpOtherPlayer && cmpOtherPlayer.GetTeam() == team)
             teamPlayers.push(i);
     }
 
     return cmpRangeManager.GetUnionPercentMapExplored(teamPlayers);
 };
 
 StatisticsTracker.prototype.GetPercentMapControlled = function()
 {
     let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
     if (!cmpPlayer)
         return 0;
 
     return Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager).GetTerritoryPercentage(cmpPlayer.GetPlayerID());
 };
 
 StatisticsTracker.prototype.GetTeamPercentMapControlled = function()
 {
     let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
     if (!cmpPlayer)
         return 0;
 
     let team = cmpPlayer.GetTeam();
     let cmpTerritoryManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager);
     if (team == -1 || !cmpPlayer.GetLockTeams())
         return cmpTerritoryManager.GetTerritoryPercentage(cmpPlayer.GetPlayerID());
 
     let teamPercent = 0;
     let numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
     for (let i = 1; i < numPlayers; ++i)
     {
         let cmpOtherPlayer = QueryPlayerIDInterface(i);
         if (cmpOtherPlayer && cmpOtherPlayer.GetTeam() == team)
             teamPercent += cmpTerritoryManager.GetTerritoryPercentage(i);
     }
 
     return teamPercent;
 };
 
 StatisticsTracker.prototype.OnTerritoriesChanged = function(msg)
 {
     this.UpdatePeakPercentages();
 };
 
 StatisticsTracker.prototype.OnGlobalPlayerDefeated = function(msg)
 {
     this.UpdatePeakPercentages();
 };
 
 StatisticsTracker.prototype.OnGlobalPlayerWon = function(msg)
 {
     this.UpdatePeakPercentages();
 };
 
 StatisticsTracker.prototype.UpdatePeakPercentages = function()
 {
     this.peakPercentMapControlled = Math.max(this.peakPercentMapControlled, this.GetPercentMapControlled());
     this.teamPeakPercentMapControlled = Math.max(this.teamPeakPercentMapControlled, this.GetTeamPercentMapControlled());
 };
 
 /**
  * Adds the values of fromData to the end of the arrays of toData.
  * If toData misses the needed array, one will be created.
  *
  * @param fromData - an object of values or a value.
  * @param toData - an object of arrays or an array.
 **/
 StatisticsTracker.prototype.PushValue = function(fromData, toData)
 {
     if (typeof fromData == "object")
         for (let prop in fromData)
         {
             if (typeof toData[prop] != "object")
                 toData[prop] = [fromData[prop]];
             else
                 this.PushValue(fromData[prop], toData[prop]);
         }
     else
         toData.push(fromData);
 };
 
 StatisticsTracker.prototype.UpdateSequences = function()
 {
     let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
     this.sequences.time.push(cmpTimer.GetTime() / 1000);
     this.PushValue(this.GetStatistics(), this.sequences);
 };
 
 Engine.RegisterComponentType(IID_StatisticsTracker, "StatisticsTracker", StatisticsTracker);