Line data    Source code

       1             : /**
       2             :  * Holds a list of wanted plans to train or construct
       3             :  */
       4           0 : PETRA.Queue = function()
       5             : {
       6           0 :         this.plans = [];
       7           0 :         this.paused = false;
       8           0 :         this.switched = 0;
       9             : };
      10             : 
      11           0 : PETRA.Queue.prototype.empty = function()
      12             : {
      13           0 :         this.plans = [];
      14             : };
      15             : 
      16           0 : PETRA.Queue.prototype.addPlan = function(newPlan)
      17             : {
      18           0 :         if (!newPlan)
      19           0 :                 return;
      20           0 :         for (let plan of this.plans)
      21             :         {
      22           0 :                 if (newPlan.category === "unit" && plan.type == newPlan.type && plan.number + newPlan.number <= plan.maxMerge)
      23             :                 {
      24           0 :                         plan.addItem(newPlan.number);
      25           0 :                         return;
      26             :                 }
      27           0 :                 else if (newPlan.category === "technology" && plan.type === newPlan.type)
      28           0 :                         return;
      29             :         }
      30           0 :         this.plans.push(newPlan);
      31             : };
      32             : 
      33           0 : PETRA.Queue.prototype.check= function(gameState)
      34             : {
      35           0 :         while (this.plans.length > 0)
      36             :         {
      37           0 :                 if (!this.plans[0].isInvalid(gameState))
      38           0 :                         return;
      39           0 :                 let plan = this.plans.shift();
      40           0 :                 if (plan.queueToReset)
      41           0 :                         gameState.ai.queueManager.changePriority(plan.queueToReset, gameState.ai.Config.priorities[plan.queueToReset]);
      42             :         }
      43             : };
      44             : 
      45           0 : PETRA.Queue.prototype.getNext = function()
      46             : {
      47           0 :         if (this.plans.length > 0)
      48           0 :                 return this.plans[0];
      49           0 :         return null;
      50             : };
      51             : 
      52           0 : PETRA.Queue.prototype.startNext = function(gameState)
      53             : {
      54           0 :         if (this.plans.length > 0)
      55             :         {
      56           0 :                 this.plans.shift().start(gameState);
      57           0 :                 return true;
      58             :         }
      59           0 :         return false;
      60             : };
      61             : 
      62             : /**
      63             :  * returns the maximal account we'll accept for this queue.
      64             :  * Currently all the cost of the first element and fraction of that of the second
      65             :  */
      66           0 : PETRA.Queue.prototype.maxAccountWanted = function(gameState, fraction)
      67             : {
      68           0 :         let cost = new API3.Resources();
      69           0 :         if (this.plans.length > 0 && this.plans[0].isGo(gameState))
      70           0 :                 cost.add(this.plans[0].getCost());
      71           0 :         if (this.plans.length > 1 && this.plans[1].isGo(gameState) && fraction > 0)
      72             :         {
      73           0 :                 let costs = this.plans[1].getCost();
      74           0 :                 costs.multiply(fraction);
      75           0 :                 cost.add(costs);
      76             :         }
      77           0 :         return cost;
      78             : };
      79             : 
      80           0 : PETRA.Queue.prototype.queueCost = function()
      81             : {
      82           0 :         let cost = new API3.Resources();
      83           0 :         for (let plan of this.plans)
      84           0 :                 cost.add(plan.getCost());
      85           0 :         return cost;
      86             : };
      87             : 
      88           0 : PETRA.Queue.prototype.length = function()
      89             : {
      90           0 :         return this.plans.length;
      91             : };
      92             : 
      93           0 : PETRA.Queue.prototype.hasQueuedUnits = function()
      94             : {
      95           0 :         return this.plans.length > 0;
      96             : };
      97             : 
      98           0 : PETRA.Queue.prototype.countQueuedUnits = function()
      99             : {
     100           0 :         let count = 0;
     101           0 :         for (let plan of this.plans)
     102           0 :                 count += plan.number;
     103           0 :         return count;
     104             : };
     105             : 
     106           0 : PETRA.Queue.prototype.hasQueuedUnitsWithClass = function(classe)
     107             : {
     108           0 :         return this.plans.some(plan => plan.template && plan.template.hasClass(classe));
     109             : };
     110             : 
     111           0 : PETRA.Queue.prototype.countQueuedUnitsWithClass = function(classe)
     112             : {
     113           0 :         let count = 0;
     114           0 :         for (let plan of this.plans)
     115           0 :                 if (plan.template && plan.template.hasClass(classe))
     116           0 :                         count += plan.number;
     117           0 :         return count;
     118             : };
     119             : 
     120           0 : PETRA.Queue.prototype.countQueuedUnitsWithMetadata = function(data, value)
     121             : {
     122           0 :         let count = 0;
     123           0 :         for (let plan of this.plans)
     124           0 :                 if (plan.metadata[data] && plan.metadata[data] == value)
     125           0 :                         count += plan.number;
     126           0 :         return count;
     127             : };
     128             : 
     129           0 : PETRA.Queue.prototype.Serialize = function()
     130             : {
     131           0 :         let plans = [];
     132           0 :         for (let plan of this.plans)
     133           0 :                 plans.push(plan.Serialize());
     134             : 
     135           0 :         return { "plans": plans, "paused": this.paused, "switched": this.switched };
     136             : };
     137             : 
     138           0 : PETRA.Queue.prototype.Deserialize = function(gameState, data)
     139             : {
     140           0 :         this.paused = data.paused;
     141           0 :         this.switched = data.switched;
     142           0 :         this.plans = [];
     143           0 :         for (let dataPlan of data.plans)
     144             :         {
     145             :                 let plan;
     146           0 :                 if (dataPlan.category == "unit")
     147           0 :                         plan = new PETRA.TrainingPlan(gameState, dataPlan.type);
     148           0 :                 else if (dataPlan.category == "building")
     149           0 :                         plan = new PETRA.ConstructionPlan(gameState, dataPlan.type);
     150           0 :                 else if (dataPlan.category == "technology")
     151           0 :                         plan = new PETRA.ResearchPlan(gameState, dataPlan.type);
     152             :                 else
     153             :                 {
     154           0 :                         API3.warn("Petra deserialization error: plan unknown " + uneval(dataPlan));
     155           0 :                         continue;
     156             :                 }
     157           0 :                 plan.Deserialize(gameState, dataPlan);
     158           0 :                 this.plans.push(plan);
     159             :         }
     160             : };