CPU eater

CPU_muncher.rs

    fn run_structure_find(&mut self) -> Vec<StructureObject> {
        self.room.find(find::STRUCTURES, None)
    }

    fn repairable_check(&mut self, structure: &StructureObject) {
        if let Some(repairable) = structure.as_repairable() {
            let max = if structure.structure_type() == StructureType::Rampart {
                //let controller = self.controller.as_ref().unwrap().controller.clone();
                //get_rampart_repair_rcl(controller.level())
                100_000
            } else {
                repairable.hits_max()
            };

            if repairable.hits() < max {
                self.needs_repair.push(structure.clone());
            }
        }
    }

    fn skip_check(&mut self, can_be_placed: bool, structure: &StructureObject) -> bool {
        if !can_be_placed && (structure.structure_type() != StructureType::Container && structure.structure_type() != StructureType::Road && structure.structure_type() != StructureType::InvaderCore) {
            return true;
        } else if !can_be_placed {
            if let StructureObject::StructureContainer(container) = structure {
                self.containers.insert(container.id(), container.clone());
                return true;
            }
        }

        false
    }

    fn classify_structure(&mut self, resource_cache: &mut RoomResourceCache, structure: StructureObject, has_links: &mut bool, has_containers: &mut bool) {
        match structure {
            StructureObject::StructureTower(tower) => {
                self.towers.insert(tower.id(), tower);
            }
            StructureObject::StructureExtension(extension) => {
                self.extensions.insert(extension.id(), extension);
            }
            StructureObject::StructureLink(link) => {
                resource_cache.energy_in_storing_structures +=
                    link.store().get_used_capacity(Some(ResourceType::Energy));

                *has_links = true;
                self.links.insert(link.id(), link);
            }
            StructureObject::StructureRoad(road) => {
                self.roads.insert(road.id(), road);
            }
            StructureObject::StructureInvaderCore(core) => {
                self.invader_core = Some(core);
            }
            StructureObject::StructureContainer(container) => {
                resource_cache.energy_in_storing_structures += container
                    .store()
                    .get_used_capacity(Some(ResourceType::Energy));

                *has_containers = true;
                self.containers.insert(container.id(), container);
            }
            StructureObject::StructureRampart(rampart) => {
                self.ramparts.push(rampart);
            }
            StructureObject::StructureStorage(storage) => {
                resource_cache.energy_in_storing_structures += storage
                    .store()
                    .get_used_capacity(Some(ResourceType::Energy));

                self.storage = Some(storage);
            }
            StructureObject::StructureSpawn(spawn) => {
                self.spawns.insert(spawn.id(), spawn);
            }
            StructureObject::StructureNuker(nuker) => {
                self.nuker = Some(nuker);
            }
            StructureObject::StructureObserver(observer) => {
                self.observer = Some(observer);
            }
            StructureObject::StructureTerminal(terminal) => {
                self.terminal = Some(terminal);
            }
            StructureObject::StructureFactory(factory) => {
                self.factory = Some(factory);
            }
            StructureObject::StructurePowerSpawn(power_spawn) => {
                self.power_spawn = Some(power_spawn);
            }
            _ => {}
        }
    }

    pub fn refresh_structure_cache(
        &mut self,
        resource_cache: &mut RoomResourceCache,
        memory: &mut ScreepsMemory
    ) {
        let room_memory = memory.rooms.get_mut(&self.room.name());

        let mut can_structures_be_placed = true;
        let mut check_ownable = false;
        if let Some(controller) = self.room.controller() {
            if !controller.my() {
                can_structures_be_placed = false;
            }
        } else {
            can_structures_be_placed = false;
        }

        if let Some(room_memory) = room_memory {
            if room_memory.rcl < room_memory.max_rcl {
                check_ownable = true;
            }
        }

        let mut has_containers = false;
        let mut has_links = false;

        for structure in self.run_structure_find().into_iter() {
            if self.skip_check(can_structures_be_placed, &structure) {
                continue;
            }

            // Dont to the is_active check UNLESS we downgraded.
            // Its very expensive from what I have heard.
            // This information has been reported by: Gadjung
            if check_ownable && !structure.is_active() {
                continue;
            }

            self.repairable_check(&structure);

            if let Some(ownable) = structure.as_owned() {
                if !ownable.my() {
                    continue;
                }
            }

            self.classify_structure(resource_cache, structure, &mut has_links, &mut has_containers);
        }

        if has_containers {
            self.process_containers();
        }

        if has_links {
            self.process_links();
        }
    }