Поиск структуры с наивысшей энергией screeps

Question

Итак, у меня есть эта роль ползучести, называемая storer, которая должна собирать энергию из контейнеров и выводить ее на хранение. Однако в настоящее время он находит ближайший контейнер по пути и с уровнем энергии, превышающим определенный порог, так что он не дожидается там в течение нескольких часов каждый раз, когда шахтер заправляет контейнер.

Проблема в том, что если я опустил порог, storer будет бегать туда-сюда в те же контейнеры, игнорируя все контейнеры в комнате и позволяя им заполняться.
И повышение порога заставит его сидеть и ждать слишком долго, не давая ему достаточно времени, чтобы пустые контейнеры, и, таким образом, хранилище будет пустым почти все время.

Мне нужна дорога для ползучести, чтобы определить контейнер с наивысшей энергией и заполнить оттуда.

Вот код его работы:

if ((source = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return (s.structureType == STRUCTURE_CONTAINER && s.store[RESOURCE_ENERGY] >= 150)}})) != undefined) { 
    if (creep.withdraw(source, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { 
     creep.moveTo(source); 
    } 
} 

EDIT: Вот код, который я попробовал, но я чувствую, что она использует слишком много ресурсов процессора и может быть сделано в лучшем виде:

for (let i = 2000; i>=0; i=i-100) { 
    source = creep.pos.findClosestByPath(FIND_STRUCTURES, {filter: (s) => {return s.structureType == STRUCTURE_CONTAINER && s.store[RESOURCE_ENERGY] >= i}}); 
     if (source != undefined) { 
      break; 
     } 
    } 
    if (creep.withdraw(source, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { 
     creep.moveTo(source); 
    } 
} 

Answer 1

Что вы можете сделать, это петля через все контейнеры один раз, получить уровень энергии и выбрать самый высокий уровень. Установите значение, когда ползучесть работает, поэтому ползучесть не перемещается в другой контейнер, если он становится выше.

Это код, который я сделал для роли Сторера:

module.exports = { 

    run: function(creep) { 

    // Setting the working variable so the creep focus 
    // on getting the ressource or returning it. 
    if (creep.memory.working && creep.carry.energy == 0) { 
     creep.memory.working = false; 
    } 

    if (! creep.memory.working && creep.carry.energy == creep.carryCapacity) { 
     creep.memory.working = true; 
     creep.memory.targetContainer = false; 
    } 

    if (creep.memory.working) { 

     // Bring the ressources to the storage. 
     var theStorage = creep.pos.findClosestByRange(FIND_MY_STRUCTURES, { 
      filter: (structure) => { 
       return (structure.structureType == STRUCTURE_STORAGE); 
      } 
     }); 

     if (creep.transfer(theStorage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { 
      creep.moveTo(theStorage); 
     } 

    } else { 

     // If the creep have a target. 
     if (creep.memory.targetContainer) { 

      // Go to the container. 
      var theContainer = Game.getObjectById(creep.memory.targetContainer); 

      if (creep.withdraw(theContainer, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) { 
       creep.moveTo(theContainer); 
      } 

     } else { 

      // Find the container with the most energy. 
      var target = creep.room.find(FIND_STRUCTURES, { 
       filter: (structure) => { 
        return (structure.structureType == STRUCTURE_CONTAINER); 
       } 
      }); 

      if (target.length) { 

       var allContainer = []; 

       // Calculate the percentage of energy in each container. 
       for (var i = 0; i < target.length; i++) { 

        allContainer.push({ energyPercent: ((target[i].store.energy/target[i].storeCapacity) * 100), id: target[i].id }); 

       } 

       // Get the container containing the most energy. 
       var highestContainer = _.max(allContainer, function(container){ return container.energyPercent; }); 

       console.log('Going for the container id "' + highestContainer.id + '" at ' + highestContainer.energyPercent + '% full.'); 

       // set the target in memory so the creep dosen't 
       // change target in the middle of the room. 
       creep.memory.targetContainer = highestContainer.id; 

      } 
     } 
    } 
    } 
}; 

Answer 2

Вместо того, чтобы фильтр сделал все для вас, почему бы не вернуть список структур, соответствующих вашим критериям, а затем выяснить, какая структура в списке имеет наибольшую энергию? Что-то вроде этого найдет все контейнеры, которые будут иметь наибольшую энергию, и если у вас есть привязка к энергии, выберите ближайшую (прямая линия, не учитывающая препятствия).

var sources = creep.room.find(FIND_STRUCTURES, { 
    filter: (structure) => { 
     return (structure.structureType == STRUCTURE_CONTAINER); 
    } 
}); 
var maxAmount = -1; 
var maxSource = null; 
var maxRange = 100; 
for (var i = 0; i < sources.length; i++) { 
    if (sources[i].store[RESOURCE_ENERGY] >= maxAmount) { 
     var range = creep.pos.getRangeTo(sources[i]); 
     if (sources[i].store[RESOURCE_ENERGY] > maxAmount || range < maxRange) { 
      maxAmount = sources[i].store[RESOURCE_ENERGY]; 
      maxSource = sources[i]; 
      maxRange = range; 
     } 
    } 
} 
console.log(maxAmount); 
console.log(maxSource); 
console.log(maxRange); 

Answer 3

Я не знаю, если этот метод использует больше ресурсов процессора, но гораздо проще в использовании JavaScript встроенный в метод сортировки. Он позволяет сортировать объекты в массиве на основе любого свойства или вычисления с его участием. Если вы хотите увидеть полный синтаксис и некоторые примеры: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Этот код должен работать для ваших целей. A и B - две части массива, которые она сравнивает. Часть возврата сообщает, что сравнение выполняется с элементами массива.

var sources = creep.pos.findClosestByPath(FIND_STRUCTURES, 
{filter: (s) => {return (s.structureType == STRUCTURE_CONTAINER && 
s.store[RESOURCE_ENERGY] >= 150) 
}}); 
sources.sort(function(a, b) {return b.store[RESOURCE_ENERGY] - a.store[RESOURCE_ENERGY]}); 

Затем просто запустите свой обычный код, чтобы извлечь энергию из источников. Если он начинает принимать энергию от энергии с наименьшим количеством энергии, я, вероятно, получил порядок a и b в обратной части, поэтому просто переверните их.