Ticket #3277: trading_v4.patch

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

@@ -1663 +1663 @@
     let firstMarket = cmpEntityTrader.GetFirstMarket();
     let secondMarket = cmpEntityTrader.GetSecondMarket();
     let result = null;
-    if (data.target === firstMarket)
+    if (!firstMarket)
+        result = { "type": "set first" };
+    else if (!secondMarket)
     {
         result = {
+            "type": "set second",
+            "gain": cmpEntityTrader.CalculateGain(firstMarket, data.target),
+        };
+    }
+    else if (data.target === firstMarket)
+    {
+        result = {
             "type": "is first",
             "hasBothMarkets": cmpEntityTrader.HasBothMarkets()
         };
@@ -1679 +1688 @@
             "gain": cmpEntityTrader.GetGoods().amount,
         };
     }
-    else if (!firstMarket)
-    {
-        result = { "type": "set first" };
-    }
-    else if (!secondMarket)
-    {
-        result = {
-            "type": "set second",
-            "gain": cmpEntityTrader.CalculateGain(firstMarket, data.target),
-        };
-    }
     else
     {
         // Else both markets are not null and target is different from them

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

@@ +1 @@
+/**
+ @file Market.js
+ Component used for the management of market and trade units in the field
+*/
+function Market() {}
+
+Market.prototype.Schema = "<a:component type='system'/><empty/>";
+
+Market.prototype.Init = function()
+{
+    this.tradeEntities = []; // List of trade entities from which this market works as a target
+};
+
+/**
+ Subscribes a new trader to this market.
+ @param {Object} trader - The trader object expected being subscribed inside the market.
+*/
+
+Market.prototype.SubscribeTrader = function(trader)
+{
+    // First check that this trader has not been already registered inside the market.
+    // If that is the case then do nothing
+    if (!(trader in this.tradeEntities))
+        // If the entity has not been registered for this market,
+        // add it to the list of traders
+        this.tradeEntities.push(trader);
+};
+
+Market.prototype.OnDestroy = function()
+{
+    this.NotifySubscribedTraders();
+};
+
+Market.prototype.OnOwnershipChanged = function(msg)
+{
+    if (msg.to != -1 && msg.from != -1)
+    {
+        let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+        let cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(msg.to), IID_Player);
+
+        // If the new owner is an not an ally the trader should display a behavior
+        // similar when the market is destroyed.
+        if(!cmpPlayer.IsAlly(msg.from) || !cmpPlayer.isNeutral(msg.from))
+            this.NotifySubscribedTraders();
+    }
+};
+
+Market.prototype.OnDiplomacyChanged = function(msg)
+{
+    let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    let cmpPlayer = undefined;
+    if(cmpPlayerManager)
+        cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(msg.player), IID_Player);
+
+    if(!cmpOwnership || !cmpPlayer)
+        return;
+
+    // If the new diplomatic position of the player is not an ally return to
+    // respective ally markets
+    if (!cmpPlayer.IsAlly(cmpOwnership.GetOwner()) || !cmpPlayer.IsNeutral(cmpOwnership.GetOwner()))
+        this.NotifySubscribedTraders();
+}
+
+/**
+ Notifies traders subscribed to this market to change their trading behavior
+*/
+Market.prototype.NotifySubscribedTraders = function() {
+
+    let cmpUnitAI = undefined;
+    for(let i=0, l=this.tradeEntities.length; i<l; ++i)
+    {
+        if (this.tradeEntities[i])
+        {
+            cmpUnitAI = Engine.QueryInterface(this.tradeEntities[i], IID_UnitAI);
+            if (cmpUnitAI)
+            {
+                // Unsubscribe the trader from the market
+                delete this.tradeEntities[i];
+                cmpUnitAI.InvalidateTradingMarket(this.entity);
+            }
+        }
+    }
+}
+
+Engine.RegisterComponentType(IID_Market, "Market", Market);

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

@@ -1 @@
-// See helpers/TraderGain.js for the CalculateTaderGain() function which works out how many 
-// resources a trader gets 
+// See helpers/TraderGain.js for the CalculateTaderGain() function which works out how many
+// resources a trader gets
 
 // Additional gain for ships for each garrisoned trader, in percents
 const GARRISONED_TRADER_ADDITION = 20;
@@ -61 +61 @@
                 gain.market2Gain = Math.round(garrisonMultiplier * gain.market2Gain);
         }
     }
-    
+
     return gain;
 };
 
@@ -273 +273 @@
         this.goods.amount = this.CalculateGain(this.markets[0], this.markets[1]);
 };
 
+Trader.prototype.InvalidateFirstMarket = function()
+{
+    this.firstMarket = INVALID_ENTITY;
+}
+
+Trader.prototype.InvalidateSecondMarket = function()
+{
+    this.secondMarket = INVALID_ENTITY;
+}
+
 Engine.RegisterComponentType(IID_Trader, "Trader", Trader);

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

@@ -353 +353 @@
         var needToMove = true;
         var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
         if (this.lastShorelinePosition && cmpPosition && (this.lastShorelinePosition.x == cmpPosition.GetPosition().x)
-            && (this.lastShorelinePosition.z == cmpPosition.GetPosition().z))
+            && (this.lastShorelinePosition.z == cmpPosition.GetPosition().z))
         {
             // we were already on the shoreline, and have not moved since
             if (DistanceBetweenEntities(this.entity, this.order.data.target) < 50)
@@ -583 +583 @@
                 return;
             }
 
-            this.PushOrderFront("Attack", { "target": this.order.data.target, "force": false, "hunting": true, "allowCapture": false });
+            this.PushOrderFront("Attack", { "target": this.order.data.target, "force": false, "hunting": true, "allowCapture": false });
             return;
         }
 
@@ -1551 +1551 @@
             },
         },
 
+        "INVALIDATEPENDINGMARKET": {
+            "enter": function() {
+                this.StartTimer(500,1000);
+            },
+
+            "Timer": function(msg) {
+                if(!this.CheckTargetVisible(this.order.data.target))
+                    this.InvalidateTradingMarket(this.order.data.target);
+            },
+
+            "MoveCompleted": function() {
+                this.StopTimer();
+            }
+
+        },
+
         "GUARD": {
             "RemoveGuard": function() {
                 this.StopMoving();
@@ -2724 +2740 @@
                     let dropsiteTypes = cmpResourceDropsite.GetTypes();
                     cmpResourceGatherer.CommitResources(dropsiteTypes);
                     this.SetGathererAnimationOverride();
-                } 
+                }
 
                 // We finished building it.
                 // Switch to the next order (if any)
@@ -3436 +3452 @@
     var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     if (this.losRangeQuery)
         this.SetupRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losRangeQuery));
- 
+
     if (this.IsHealer() && this.losHealRangeQuery)
         this.SetupHealRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losHealRangeQuery));
 };
@@ -5156 +5172 @@
         return;
     }
 
-    var marketsChanged = this.SetTargetMarket(target, source);
+    let marketsChanged = this.SetTargetMarket(target, source);
     if (!marketsChanged)
         return;
 
-    var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
+    let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
+    let cmpMarket = Engine.QueryInterface(target, IID_Market);
+    if(!cmpTrader || !cmpMarket)
+        return;
+
+    cmpMarket.SubscribeTrader(this.entity);
+
     if (cmpTrader.HasBothMarkets())
     {
         let data = {
@@ -5179 +5201 @@
         if (this.IsFormationController())
         {
             this.CallMemberFunction("AddOrder", ["Trade", data, queued]);
-            var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
             if (cmpFormation)
                 cmpFormation.Disband();
         }
@@ -5227 +5249 @@
     return ok;
 };
 
+/**
+ * Makes a routing trade invalid sending the trader unit to the next
+ * possible market.
+ */
+UnitAI.prototype.InvalidateTradingMarket = function(market)
+{
+    // Find the entity inside the one of the markets in the trader
+    //
+    // If the market is found as the first market then send the trader to the
+    // second market.
+    //
+    // If the market is found in the second market then send the trader to the
+    // first market
+    //
+    // If the source and target have been captured then stop
+    // trading
+    let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
+
+    // Check if the market is visible, otherwise add it to the Queue
+    if(cmpTrader && !this.CheckTargetVisible(market))
+    {
+        if (!cmpTrader.GetFirstMarket() || !cmpTrader.GetSecondMarket())
+            this.StopTrading();
+        else if(cmpTrader.GetFirstMarket() === market)
+        {
+            cmpTrader.InvalidateFirstMarket();
+            this.MoveToMarket(cmpTrader.GetSecondMarket());
+        }
+        else if(cmpTrader.GetSecondMarket() === market)
+        {
+            cmpTrader.InvalidateSecondMarket();
+            this.MoveToMarket(cmpTrader.GetFirstMarket());
+        }
+    }
+    else
+    {
+        this.order.data.target = market;
+        this.SetNextState("INDIVIDUAL.INVALIDATEPENDINGMARKET");
+    }
+};
+
 UnitAI.prototype.PerformTradeAndMoveToNextMarket = function(currentMarket)
 {
     if (!this.CanTrade(currentMarket))
@@ -5243 +5306 @@
     }
 
     let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
+    if(!cmpTrader)
+    {
+        this.StopTrading();
+        return;
+    }
+
     cmpTrader.PerformTrade(currentMarket);
     if (!cmpTrader.GetGoods().amount.traderGain)
     {
@@ -5270 +5339 @@
 UnitAI.prototype.StopTrading = function()
 {
     this.StopMoving();
-    this.FinishOrder();
-    var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
+    let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
     cmpTrader.StopTrading();
 };
 

binaries/data/mods/public/simulation/components/interfaces/Market.js

@@ +1 @@
+Engine.RegisterInterface("Market");

binaries/data/mods/public/simulation/templates/template_structure_economic_market.xml

@@ -64 +64 @@
   <Vision>
     <Range>32</Range>
   </Vision>
+  <Market/>
   <VisualActor>
     <FoundationActor>structures/fndn_5x5.xml</FoundationActor>
   </VisualActor>

binaries/data/mods/public/simulation/templates/template_structure_military_dock.xml

@@ -75 +75 @@
    <Vision>
     <Range>40</Range>
   </Vision>
+  <Market/>
   <VisualActor>
     <FoundationActor>structures/fndn_4x4_dock.xml</FoundationActor>
   </VisualActor>