Munch.rs

    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);
            }
            StructureObject::StructureLab(lab) => {
                self.labs.insert(lab.id(), lab);
            }
            _ => {}
        }
    }
    
    
    // run_structure_find just returns
    // self.room.find(find::STRUCTURES, None)
            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);
        }