Ticket #3999: 3999_guiinterface_cleanup_v1.patch

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

@@ -46 +46 @@
 
 /**
  * Returns global information about the current game state.
  * This is used by the GUI and also by AI scripts.
  */
-GuiInterface.prototype.GetSimulationState = function(player)
+GuiInterface.prototype.GetSimulationState = function()
 {
     let ret = {
         "players": []
     };
 
@@ -167 +167 @@
  * Returns global information about the current game state, plus statistics.
  * This is used by the GUI at the end of a game, in the summary screen.
  * Note: Amongst statistics, the team exploration map percentage is computed from
  * scratch, so the extended simulation state should not be requested too often.
  */
-GuiInterface.prototype.GetExtendedSimulationState = function(player)
+GuiInterface.prototype.GetExtendedSimulationState = function()
 {
     // Get basic simulation info
     let ret = this.GetSimulationState();
 
     // Add statistics to each player
@@ -194 +194 @@
         return this.renamedEntities.concat(this.miragedEntities[player]);
     else
         return this.renamedEntities;
 };
 
-GuiInterface.prototype.ClearRenamedEntities = function(player)
+GuiInterface.prototype.ClearRenamedEntities = function()
 {
     this.renamedEntities = [];
     this.miragedEntities = [];
 };
 
@@ -648 +648 @@
     return cmpTechnologyManager.CanResearch(data.tech);
 };
 
 // Returns technologies that are being actively researched, along with
 // which entity is researching them and how far along the research is.
-GuiInterface.prototype.GetStartedResearch = function(player, viewedPlayer)
+GuiInterface.prototype.GetStartedResearch = function(player)
 {
-    let cmpTechnologyManager = QueryPlayerIDInterface(viewedPlayer, IID_TechnologyManager);
+    let cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
     if (!cmpTechnologyManager)
         return {};
 
     let ret = {};
     for (let tech in cmpTechnologyManager.GetTechsStarted())
@@ -668 +668 @@
     }
     return ret;
 };
 
 // Returns the battle state of the player.
-GuiInterface.prototype.GetBattleState = function(player, viewedPlayer)
+GuiInterface.prototype.GetBattleState = function(player)
 {
-    let cmpBattleDetection = QueryPlayerIDInterface(viewedPlayer, IID_BattleDetection);
+    let cmpBattleDetection = QueryPlayerIDInterface(player, IID_BattleDetection);
 
     if (!cmpBattleDetection)
         return false;
 
     return cmpBattleDetection.GetState();
@@ -724 +724 @@
 GuiInterface.prototype.DeleteTimeNotification = function(notificationID)
 {
     this.timeNotifications = this.timeNotifications.filter(n => n.id != notificationID);
 };
 
-GuiInterface.prototype.GetTimeNotifications = function(playerID, viewedPlayer)
+GuiInterface.prototype.GetTimeNotifications = function(player)
 {
     let time = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
     // filter on players and time, since the delete timer might be executed with a delay
-    return this.timeNotifications.filter(n => n.players.indexOf(viewedPlayer) != -1 && n.endTime > time);
+    return this.timeNotifications.filter(n => n.players.indexOf(player) != -1 && n.endTime > time);
 };
 
 GuiInterface.prototype.PushNotification = function(notification)
 {
     if (!notification.type || notification.type == "text")
@@ -887 +887 @@
         if (cmpStatusBars)
             cmpStatusBars.RegenerateSprites();
     }
 };
 
-GuiInterface.prototype.GetPlayerEntities = function(player, data)
+GuiInterface.prototype.GetPlayerEntities = function(player)
 {
-    return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEntitiesByPlayer(data.viewedPlayer);
+    return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEntitiesByPlayer(player);
 };
 
 GuiInterface.prototype.GetNonGaiaEntities = function()
 {
     return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetNonGaiaEntities();
@@ -1647 +1647 @@
 };
 
 /**
  * Find any idle units.
  *
- * @param data.viewedPlayer The player for which to find idle units.
  * @param data.idleClasses      Array of class names to include.
  * @param data.prevUnit     The previous idle unit, if calling a second time to iterate through units.  May be left undefined.
  * @param data.limit            The number of idle units to return.  May be left undefined (will return all idle units).
  * @param data.excludeUnits Array of units to exclude.
  *
@@ -1662 +1661 @@
 {
     let idleUnits = [];
     // The general case is that only the 'first' idle unit is required; filtering would examine every unit.
     // This loop imitates a grouping/aggregation on the first matching idle class.
     let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-    for (let entity of cmpRangeManager.GetEntitiesByPlayer(data.viewedPlayer))
+    for (let entity of cmpRangeManager.GetEntitiesByPlayer(player))
     {
         let filtered = this.IdleUnitFilter(entity, data.idleClasses, data.excludeUnits);
         if (!filtered.idle)
             continue;
 
@@ -1693 +1692 @@
 };
 
 /**
  * Discover if the player has idle units.
  *
- * @param data.viewedPlayer The player for which to find idle units.
  * @param data.idleClasses  Array of class names to include.
  * @param data.excludeUnits Array of units to exclude.
  *
  * Returns a boolean of whether the player has any idle units
  */
 GuiInterface.prototype.HasIdleUnits = function(player, data)
 {
     let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-    return cmpRangeManager.GetEntitiesByPlayer(data.viewedPlayer).some(unit => this.IdleUnitFilter(unit, data.idleClasses, data.excludeUnits).idle);
+    return cmpRangeManager.GetEntitiesByPlayer(player).some(unit => this.IdleUnitFilter(unit, data.idleClasses, data.excludeUnits).idle);
 };
 
 /**
  * Whether to filter an idle unit
  *
@@ -1865 +1863 @@
 GuiInterface.prototype.SetRangeDebugOverlay = function(player, enabled)
 {
     Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).SetDebugOverlay(enabled);
 };
 
-GuiInterface.prototype.GetTraderNumber = function(player, viewedPlayer)
+GuiInterface.prototype.GetTraderNumber = function(player)
 {
     let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-    let traders = cmpRangeManager.GetEntitiesByPlayer(viewedPlayer).filter(e => Engine.QueryInterface(e, IID_Trader));
+    let traders = cmpRangeManager.GetEntitiesByPlayer(player).filter(e => Engine.QueryInterface(e, IID_Trader));
 
     let landTrader = { "total": 0, "trading": 0, "garrisoned": 0 };
     let shipTrader = { "total": 0, "trading": 0 };
 
     for each (let ent in traders)
@@ -1904 +1902 @@
     }
 
     return { "landTrader": landTrader, "shipTrader": shipTrader };
 };
 
-GuiInterface.prototype.GetTradingGoods = function(player, viewedPlayer)
+GuiInterface.prototype.GetTradingGoods = function(player)
 {
-    return QueryPlayerIDInterface(viewedPlayer).GetTradingGoods();
+    return QueryPlayerIDInterface(player).GetTradingGoods();
 };
 
 GuiInterface.prototype.OnGlobalEntityRenamed = function(msg)
 {
     this.renamedEntities.push(msg);

source/gui/scripting/ScriptFunctions.cpp

@@ -121 +121 @@
 
     CmpPtr<ICmpGuiInterface> cmpGuiInterface(*sim, SYSTEM_ENTITY);
     if (!cmpGuiInterface)
         return JS::UndefinedValue();
 
-    int player = g_Game->GetPlayerID();
-
     JSContext* cxSim = sim->GetScriptInterface().GetContext();
     JSAutoRequest rqSim(cxSim);
     JS::RootedValue arg(cxSim, sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), data));
     JS::RootedValue ret(cxSim);
-    cmpGuiInterface->ScriptCall(player, name, arg, &ret);
+    cmpGuiInterface->ScriptCall(g_Game->GetViewedPlayerID(), name, arg, &ret);
 
     return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(sim->GetScriptInterface(), ret);
 }
 
 void PostNetworkCommand(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue cmd)