Changeset 25089

Timestamp:

Mar 20, 2021, 5:01:11 PM (3 years ago)

Author:

Freagarach

Message:

Move Mirage information to respective components.

Moves the functions that define the properties/functions to mirage to their respective components, making it easier for modders to know their existence and to modify.

Closes: #5985
Differential revision: D3695
Comments by: @wraitii

Location:

ps/trunk/binaries/data/mods/public/simulation/components

Files:

• Capturable.js (modified) (1 diff)
• Foundation.js (modified) (1 diff)
• Health.js (modified) (1 diff)
• Identity.js (modified) (1 diff)
• Market.js (modified) (1 diff)
• Mirage.js (modified) (1 diff)
• Repairable.js (modified) (1 diff)
• ResourceSupply.js (modified) (1 diff)

ps/trunk/binaries/data/mods/public/simulation/components/Capturable.js

@@ -370 +370 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_Capturable, "Capturable", Capturable);

ps/trunk/binaries/data/mods/public/simulation/components/Foundation.js

@@ -532 +532 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_Foundation, "Foundation", Foundation);
-

ps/trunk/binaries/data/mods/public/simulation/components/Health.js

@@ -484 +484 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_Health, "Health", Health);

ps/trunk/binaries/data/mods/public/simulation/components/Identity.js

@@ -202 +202 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_Identity, "Identity", Identity);

ps/trunk/binaries/data/mods/public/simulation/components/Market.js

@@ -85 +85 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_Market, "Market", Market);

ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js

@@ -50 +50 @@
 // Parent entity data
 
-function MiragedIdentity() {}
-MiragedIdentity.prototype.Init = function(cmpIdentity)
+Mirage.prototype.CopyCapturable = function(cmpCapturable)
 {
-    // Mirages don't get identity classes via the template-filter, so that code can query
-    // identity components via Engine.QueryInterface without having to explicitly check for mirages.
-    // This is cloned as otherwise we get a reference to Identity's property,
-    // and that array is deleted when serializing (as it's not seralized), which ends in OOS.
-    this.classes = clone(cmpIdentity.GetClassesList());
+    this.miragedIids.set(IID_Capturable, cmpCapturable.Mirage());
 };
 
-MiragedIdentity.prototype.GetClassesList = function() { return this.classes; };
-Engine.RegisterGlobal("MiragedIdentity", MiragedIdentity);
+Mirage.prototype.CopyFoundation = function(cmpFoundation)
+{
+    this.miragedIids.set(IID_Foundation, cmpFoundation.Mirage());
+};
+
+Mirage.prototype.CopyHealth = function(cmpHealth)
+{
+    this.miragedIids.set(IID_Health, cmpHealth.Mirage());
+};
 
 Mirage.prototype.CopyIdentity = function(cmpIdentity)
 {
-    let mirage = new MiragedIdentity();
-    mirage.Init(cmpIdentity);
-    this.miragedIids.set(IID_Identity, mirage);
+    this.miragedIids.set(IID_Identity, cmpIdentity.Mirage());
 };
 
-// Foundation data
-
-function MiragedFoundation() {}
-MiragedFoundation.prototype.Init = function(cmpFoundation)
+Mirage.prototype.CopyMarket = function(cmpMarket)
 {
-    this.numBuilders = cmpFoundation.GetNumBuilders();
-    this.buildTime = cmpFoundation.GetBuildTime();
+    this.miragedIids.set(IID_Market, cmpMarket.Mirage(this.entity, this.player));
 };
-
-MiragedFoundation.prototype.GetNumBuilders = function() { return this.numBuilders; };
-MiragedFoundation.prototype.GetBuildTime = function() { return this.buildTime; };
-Engine.RegisterGlobal("MiragedFoundation", MiragedFoundation);
-
-Mirage.prototype.CopyFoundation = function(cmpFoundation)
-{
-    let mirage = new MiragedFoundation();
-    mirage.Init(cmpFoundation);
-    this.miragedIids.set(IID_Foundation, mirage);
-};
-
-// Repairable data
-
-function MiragedRepairable() {}
-MiragedRepairable.prototype.Init = function(cmpRepairable)
-{
-    this.numBuilders = cmpRepairable.GetNumBuilders();
-    this.buildTime = cmpRepairable.GetBuildTime();
-};
-
-MiragedRepairable.prototype.GetNumBuilders = function() { return this.numBuilders; };
-MiragedRepairable.prototype.GetBuildTime = function() { return this.buildTime; };
-Engine.RegisterGlobal("MiragedRepairable", MiragedRepairable);
 
 Mirage.prototype.CopyRepairable = function(cmpRepairable)
 {
-    let mirage = new MiragedRepairable();
-    mirage.Init(cmpRepairable);
-    this.miragedIids.set(IID_Repairable, mirage);
+    this.miragedIids.set(IID_Repairable, cmpRepairable.Mirage());
 };
-
-// Health data
-
-function MiragedHealth() {}
-MiragedHealth.prototype.Init = function(cmpHealth)
-{
-    this.maxHitpoints = cmpHealth.GetMaxHitpoints();
-    this.hitpoints = cmpHealth.GetHitpoints();
-    this.repairable = cmpHealth.IsRepairable();
-    this.injured = cmpHealth.IsInjured();
-    this.unhealable = cmpHealth.IsUnhealable();
-};
-
-MiragedHealth.prototype.GetMaxHitpoints = function() { return this.maxHitpoints; };
-MiragedHealth.prototype.GetHitpoints = function() { return this.hitpoints; };
-MiragedHealth.prototype.IsRepairable = function() { return this.repairable; };
-MiragedHealth.prototype.IsInjured = function() { return this.injured; };
-MiragedHealth.prototype.IsUnhealable = function() { return this.unhealable; };
-Engine.RegisterGlobal("MiragedHealth", MiragedHealth);
-
-Mirage.prototype.CopyHealth = function(cmpHealth)
-{
-    let mirage = new MiragedHealth();
-    mirage.Init(cmpHealth);
-    this.miragedIids.set(IID_Health, mirage);
-};
-
-// Capture data
-
-function MiragedCapturable() {}
-MiragedCapturable.prototype.Init = function(cmpCapturable)
-{
-    this.capturePoints = clone(cmpCapturable.GetCapturePoints());
-    this.maxCapturePoints = cmpCapturable.GetMaxCapturePoints();
-};
-
-MiragedCapturable.prototype.GetCapturePoints = function() { return this.capturePoints; };
-MiragedCapturable.prototype.GetMaxCapturePoints = function() { return this.maxCapturePoints; };
-MiragedCapturable.prototype.CanCapture = Capturable.prototype.CanCapture;
-Engine.RegisterGlobal("MiragedCapturable", MiragedCapturable);
-
-Mirage.prototype.CopyCapturable = function(cmpCapturable)
-{
-    let mirage = new MiragedCapturable();
-    mirage.Init(cmpCapturable);
-    this.miragedIids.set(IID_Capturable, mirage);
-};
-
-// ResourceSupply data
-function MiragedResourceSupply() {}
-MiragedResourceSupply.prototype.Init = function(cmpResourceSupply)
-{
-    this.maxAmount = cmpResourceSupply.GetMaxAmount();
-    this.amount = cmpResourceSupply.GetCurrentAmount();
-    this.type = cmpResourceSupply.GetType();
-    this.isInfinite = cmpResourceSupply.IsInfinite();
-    this.killBeforeGather = cmpResourceSupply.GetKillBeforeGather();
-    this.maxGatherers = cmpResourceSupply.GetMaxGatherers();
-    this.numGatherers = cmpResourceSupply.GetNumGatherers();
-};
-
-MiragedResourceSupply.prototype.GetMaxAmount = function() { return this.maxAmount; };
-MiragedResourceSupply.prototype.GetCurrentAmount = function() { return this.amount; };
-MiragedResourceSupply.prototype.GetType = function() { return this.type; };
-MiragedResourceSupply.prototype.IsInfinite = function() { return this.isInfinite; };
-MiragedResourceSupply.prototype.GetKillBeforeGather = function() { return this.killBeforeGather; };
-MiragedResourceSupply.prototype.GetMaxGatherers = function() { return this.maxGatherers; };
-MiragedResourceSupply.prototype.GetNumGatherers = function() { return this.numGatherers; };
-
-// Apply diminishing returns with more gatherers, for e.g. infinite farms. For most resources this has no effect
-// (GetDiminishingReturns will return null). We can assume that for resources that are miraged this is the case.
-MiragedResourceSupply.prototype.GetDiminishingReturns = function() { return null; };
-
-Engine.RegisterGlobal("MiragedResourceSupply", MiragedResourceSupply);
 
 Mirage.prototype.CopyResourceSupply = function(cmpResourceSupply)
 {
-    let mirage = new MiragedResourceSupply();
-    mirage.Init(cmpResourceSupply);
-    this.miragedIids.set(IID_ResourceSupply, mirage);
-};
-
-// Market data
-function MiragedMarket() {}
-MiragedMarket.prototype.Init = function(cmpMarket, entity, parent, player)
-{
-    this.entity = entity;
-    this.parent = parent;
-    this.player = player;
-
-    this.traders = new Set();
-    for (let trader of cmpMarket.GetTraders())
-    {
-        let cmpTrader = Engine.QueryInterface(trader, IID_Trader);
-        let cmpOwnership = Engine.QueryInterface(trader, IID_Ownership);
-        if (!cmpTrader || !cmpOwnership)
-        {
-            cmpMarket.RemoveTrader(trader);
-            continue;
-        }
-        if (this.player != cmpOwnership.GetOwner())
-            continue;
-        cmpTrader.SwitchMarket(cmpMarket.entity, this.entity);
-        cmpMarket.RemoveTrader(trader);
-        this.AddTrader(trader);
-    }
-    this.marketType = cmpMarket.GetType();
-    this.internationalBonus = cmpMarket.GetInternationalBonus();
-};
-
-MiragedMarket.prototype.HasType = function(type) { return this.marketType.has(type); };
-MiragedMarket.prototype.GetInternationalBonus = function() { return this.internationalBonus; };
-MiragedMarket.prototype.AddTrader = function(trader) { this.traders.add(trader); };
-MiragedMarket.prototype.RemoveTrader = function(trader) { this.traders.delete(trader); };
-
-MiragedMarket.prototype.UpdateTraders = function(msg)
-{
-    let cmpMarket = Engine.QueryInterface(this.parent, IID_Market);
-    if (!cmpMarket) // The parent market does not exist anymore
-    {
-        for (let trader of this.traders)
-        {
-            let cmpTrader = Engine.QueryInterface(trader, IID_Trader);
-            if (cmpTrader)
-                cmpTrader.RemoveMarket(this.entity);
-        }
-        return;
-    }
-
-    // The market becomes visible, switch all traders from the mirage to the market
-    for (let trader of this.traders)
-    {
-        let cmpTrader = Engine.QueryInterface(trader, IID_Trader);
-        if (!cmpTrader)
-            continue;
-        cmpTrader.SwitchMarket(this.entity, cmpMarket.entity);
-        this.RemoveTrader(trader);
-        cmpMarket.AddTrader(trader);
-    }
-};
-Engine.RegisterGlobal("MiragedMarket", MiragedMarket);
-
-Mirage.prototype.CopyMarket = function(cmpMarket)
-{
-    let mirage = new MiragedMarket();
-    mirage.Init(cmpMarket, this.entity, this.parent, this.player);
-    this.miragedIids.set(IID_Market, mirage);
+    this.miragedIids.set(IID_ResourceSupply, cmpResourceSupply.Mirage());
 };
 

ps/trunk/binaries/data/mods/public/simulation/components/Repairable.js

@@ -152 +152 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_Repairable, "Repairable", Repairable);

ps/trunk/binaries/data/mods/public/simulation/components/ResourceSupply.js

@@ -469 +469 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Engine.RegisterComponentType(IID_ResourceSupply, "ResourceSupply", ResourceSupply);