Ticket #3277: trading_v5.patch

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

@@ -1684 +1684 @@
     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()
         };
@@ -1700 +1709 @@
             "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)
+{
+    if (this.tradeEntities.indexOf(trader) === -1)
+        this.tradeEntities.push(trader);
+};
+
+Market.prototype.OnDestroy = function()
+{
+    this.NotifySubscribedTraders();
+};
+
+Market.prototype.OnOwnershipChanged = function(msg)
+{
+    if (msg.to != -1 && msg.from != -1)
+        this.NotifySubscribedTraders();
+};
+
+Market.prototype.OnDiplomacyChanged = function(msg)
+{
+    this.NotifySubscribedTraders();
+}
+
+/**
+ Notifies traders subscribed to this market to change their trading behavior
+*/
+Market.prototype.NotifySubscribedTraders = function() {
+
+    let cmpUnitAI = undefined;
+    // When the market is invalidated for an entity, this should be unsubscribed
+    // from the market. But this creates a change in the size of the array,
+    // generating an error that when the iterator arrives to half of the sub array
+    // that would be eliminated, the upper half will be the new lower half. This
+    // generate a problem because then the array returns null after the iterator
+    // has moved passed the half for the next half of elements. To eliminate
+    // this problem we create a temporal array where the index of the trade
+    // elements that will be unsubscribed are temporarily saved and
+    // eliminated in the future
+    let entitiesToEliminate = [];
+    for(let trader of this.tradeEntities)
+    {
+        if (!trader)
+            continue;
+
+        cmpUnitAI = Engine.QueryInterface(trader, IID_UnitAI);
+        if (cmpUnitAI && !cmpUnitAI.CanTrade(this.entity))
+        {
+            // Unsubscribe the trader from the market
+            entitiesToEliminate.push(this.tradeEntities.indexOf(trader));
+            cmpUnitAI.InvalidateTradingMarket(this.entity);
+        }
+    }
+
+    // Unsubscribe the entities from this market
+    for(let index of entitiesToEliminate)
+    {
+        this.tradeEntities.splice(index, 1);
+    }
+}
+
+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;
 };
 
@@ -166 +166 @@
     var cmpTraderPlayer = QueryOwnerInterface(this.entity, IID_Player);
     var traderPlayerId = cmpTraderPlayer.GetPlayerID();
     var cmpTargetPlayer = QueryOwnerInterface(target, IID_Player);
+    if (!cmpTargetPlayer)
+        return false;
     var targetPlayerId = cmpTargetPlayer.GetPlayerID();
     var ownershipSuitableForTrading = cmpTraderPlayer.IsAlly(targetPlayerId) || cmpTraderPlayer.IsNeutral(targetPlayerId);
     if (!ownershipSuitableForTrading)
@@ -270 +272 @@
         this.goods.amount = this.CalculateGain(this.markets[0], this.markets[1]);
 };
 
+Trader.prototype.InvalidateFirstMarket = function()
+{
+    this.markets[0] = INVALID_ENTITY;
+}
+
+Trader.prototype.InvalidateSecondMarket = function()
+{
+    this.markets[1] = INVALID_ENTITY;
+}
+
 Engine.RegisterComponentType(IID_Trader, "Trader", Trader);

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

@@ -58 +58 @@
 // There some targeting options:
 //   targetVisibleEnemies: anything in vision range is a viable target
 //   targetAttackersAlways: anything that hurts us is a viable target,
-//     possibly overriding user orders!
+//   possibly overriding user orders!
 //   targetAttackersPassive: anything that hurts us is a viable target,
-//     if we're on a passive/unforced order (e.g. gathering/building)
+//   if we're on a passive/unforced order (e.g. gathering/building)
 // There are some response options, triggered when targets are detected:
 //   respondFlee: run away
 //   respondChase: start chasing after the enemy
 //   respondChaseBeyondVision: start chasing, and don't stop even if it's out
-//     of this unit's vision range (though still visible to the player)
+//   of this unit's vision range (though still visible to the player)
 //   respondStandGround: attack enemy but don't move at all
 //   respondHoldGround: attack enemy but don't move far from current position
 // TODO: maybe add targetAggressiveEnemies (don't worry about lone scouts,
@@ -349 +349 @@
             return;
         }
 
-        // Check if we need to move     TODO implement a better way to know if we are on the shoreline
+        // Check if we need to move  TODO implement a better way to know if we are on the shoreline
         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)
@@ -1080 +1080 @@
                 var cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
                 if (cmpGarrisonHolder && cmpGarrisonHolder.CanPickup(this.entity))
                 {
-                    this.pickup = this.order.data.target;       // temporary, deleted in "leave"
+                    this.pickup = this.order.data.target;      // temporary, deleted in "leave"
                     Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
                 }
             },
@@ -1387 +1387 @@
             var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
             var cmpHealth = Engine.QueryInterface(this.isGuardOf, IID_Health);
             if (cmpIdentity && cmpIdentity.HasClass("Support") &&
-                cmpHealth && cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints())
+                cmpHealth && cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints())
             {
                 if (this.CanHeal(this.isGuardOf))
                     this.PushOrderFront("Heal", { "target": this.isGuardOf, "force": false });
@@ -1795 +1795 @@
                     }
                     // Check the target is still alive and attackable
                     if (this.TargetIsAlive(target) &&
-                        this.CanAttack(target, this.order.data.forceResponse || null) &&
-                        !this.CheckTargetAttackRange(target, this.order.data.attackType))
+                        this.CanAttack(target, this.order.data.forceResponse || null) &&
+                        !this.CheckTargetAttackRange(target, this.order.data.attackType))
                     {
                         // Can't reach it - try to chase after it
                         if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
@@ -2037 +2037 @@
                     var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
                     var cmpMirage = Engine.QueryInterface(this.gatheringTarget, IID_Mirage);
                     if ((!cmpMirage || !cmpMirage.Mirages(IID_ResourceSupply)) &&
-                        (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity)))
+                        (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity)))
                     {
                         // Save the current order's data in case we need it later
                         var oldType = this.order.data.type;
@@ -2614 +2614 @@
                         this.PerformTradeAndMoveToNextMarket(this.order.data.target);
                 },
             },
+
+            "INVALIDATINGMARKET": {
+                "enter": function() {
+                    this.StartTimer(50,1000);
+                },
+
+                "Timer": function(msg) {
+                    if(!this.CheckTargetVisible(this.order.data.target))
+                        this.InvalidateTradingMarket(this.order.data.target);
+                },
+
+                "leave": function() {
+                    this.StopTimer();
+                    this.StopTrading();
+                },
+
+                "MoveCompleted": function() {
+                    this.StopTimer();
+                    this.SetNextState("IDLE");
+                }
+
+            },
+
         },
 
         "REPAIR": {
@@ -2724 +2747 @@
                     let dropsiteTypes = cmpResourceDropsite.GetTypes();
                     cmpResourceGatherer.CommitResources(dropsiteTypes);
                     this.SetGathererAnimationOverride();
-                } 
+                }
 
                 // We finished building it.
                 // Switch to the next order (if any)
@@ -2799 +2822 @@
                 var cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
                 if (cmpGarrisonHolder && cmpGarrisonHolder.CanPickup(this.entity))
                 {
-                    this.pickup = this.order.data.target;       // temporary, deleted in "leave"
+                    this.pickup = this.order.data.target;      // temporary, deleted in "leave"
                     Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
                 }
             },
@@ -3054 +3077 @@
     "ANIMAL": {
         "Attacked": function(msg) {
             if (this.template.NaturalBehaviour == "skittish" ||
-                this.template.NaturalBehaviour == "passive")
+                this.template.NaturalBehaviour == "passive")
             {
                 this.Flee(msg.data.attacker, false);
             }
@@ -3436 +3459 @@
     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 +5179 @@
         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 +5208 @@
         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 +5256 @@
     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();
+            if(this.order.data.target === market)
+                this.MoveToMarket(cmpTrader.GetSecondMarket());
+        }
+        else if(cmpTrader.GetSecondMarket() === market)
+        {
+            cmpTrader.InvalidateSecondMarket();
+            if(this.order.data.target === market)
+                this.MoveToMarket(cmpTrader.GetFirstMarket());
+        }
+    }
+    else if(this.GetCurrentState() !== "INDIVIDUAL.TRADE.INVALIDATINGMARKET")
+    {
+        this.order.data.target = market;
+        this.SetNextState("INDIVIDUAL.TRADE.INVALIDATINGMARKET");
+    }
+};
+
 UnitAI.prototype.PerformTradeAndMoveToNextMarket = function(currentMarket)
 {
     if (!this.CanTrade(currentMarket))
@@ -5243 +5315 @@
     }
 
     let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
+    if(!cmpTrader)
+    {
+        this.StopTrading();
+        return;
+    }
+
     cmpTrader.PerformTrade(currentMarket);
     let amount = cmpTrader.GetGoods().amount;
     if (!amount || !amount.traderGain)
@@ -5271 +5349 @@
 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();
 };
 
@@ -5775 +5852 @@
     if (cmpOwnership && IsOwnedByPlayer(cmpOwnership.GetOwner(), target))
         return true;
     return cmpPlayer && cmpPlayer.HasSharedDropsites() && cmpResourceDropsite.IsShared() &&
-           cmpOwnership && IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target);
+           cmpOwnership && IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target);
 };
 
 UnitAI.prototype.CanTrade = function(target)

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>