Refactor building storage

Author: object-Object

src/logic/vm/buildings.rs

@@ -1,4 +1,4 @@
-use std::rc::Rc;
+use std::{cell::RefCell, rc::Rc};
 
 use strum_macros::IntoStaticStr;
 
@@ -32,14 +32,31 @@ const MESSAGE_MAX_LINES: usize = 24;
 pub struct Building {
     pub block: &'static Block,
     pub position: Point2,
-    pub data: BuildingData,
+    pub data: Rc<RefCell<BuildingData>>,
 }
 
 impl Building {
-    pub fn new(name: &str, position: Point2, config: &Object, vm: &LogicVM) -> VMLoadResult<Self> {
+    pub fn new(name: &str, position: Point2, data: BuildingData) -> VMLoadResult<Self> {
+        let block = *content::blocks::FROM_NAME
+            .get(name)
+            .ok_or_else(|| VMLoadError::UnknownBlockType(name.to_string()))?;
+
+        Ok(Self {
+            block,
+            position,
+            data: Rc::new(RefCell::new(data)),
+        })
+    }
+
+    pub fn from_config(
+        name: &str,
+        position: Point2,
+        config: &Object,
+        vm: &LogicVM,
+    ) -> VMLoadResult<Self> {
         let data = match name {
             MICRO_PROCESSOR | LOGIC_PROCESSOR | HYPER_PROCESSOR | WORLD_PROCESSOR => {
-                return Self::new_processor(
+                return Self::from_processor_config(
                     name,
                     position,
                     &ProcessorBuilder::parse_config(config)?,
@@ -79,10 +96,10 @@ impl Building {
             },
         };
 
-        Self::from_data(name, position, data)
+        Self::new(name, position, data)
     }
 
-    pub fn new_processor(
+    pub fn from_processor_config(
         name: &str,
         position: Point2,
         config: &ProcessorConfig,
@@ -145,7 +162,7 @@ impl Building {
             }
         };
 
-        Self::from_data(name, position, data)
+        Self::new(name, position, data)
     }
 
     pub fn from_schematic_tile(
@@ -157,19 +174,7 @@ impl Building {
         }: &SchematicTile,
         vm: &LogicVM,
     ) -> VMLoadResult<Self> {
-        Self::new(name, (*position).into(), config, vm)
-    }
-
-    pub fn from_data(name: &str, position: Point2, data: BuildingData) -> VMLoadResult<Self> {
-        let block = *content::blocks::FROM_NAME
-            .get(name)
-            .ok_or_else(|| VMLoadError::UnknownBlockType(name.to_string()))?;
-
-        Ok(Self {
-            block,
-            position,
-            data,
-        })
+        Self::from_config(name, (*position).into(), config, vm)
     }
 }
 

src/logic/vm/instructions.rs

@@ -192,7 +192,7 @@ struct Print {
 }
 
 impl Print {
-    fn to_string(value: &LValue) -> Cow<'_, str> {
+    fn to_string<'a>(value: &'a LValue, vm: &LogicVM) -> Cow<'a, str> {
         match value {
             LValue::Null => Cow::from("null"),
             LValue::Number(n) => {
@@ -206,19 +206,22 @@ impl Print {
             LValue::String(s) => Cow::Borrowed(s),
             LValue::Content(content) => Cow::Borrowed(content.name()),
             LValue::Team(team) => team.name(),
-            LValue::Building { block, .. } => Cow::Borrowed(&block.name),
+            LValue::Building(position) => vm
+                .building(*position)
+                .map(|b| Cow::Borrowed(b.block.name.as_str()))
+                .unwrap_or(Cow::from("null")),
         }
     }
 }
 
 impl SimpleInstruction for Print {
-    fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
+    fn execute(&self, state: &mut ProcessorState, vm: &LogicVM) {
         if state.printbuffer.len() >= MAX_TEXT_BUFFER {
             return;
         }
 
         let value = self.value.get(state);
-        state.append_printbuffer(&Print::to_string(&value));
+        state.append_printbuffer(&Print::to_string(&value, vm));
     }
 }
 
@@ -245,7 +248,7 @@ struct Format {
 }
 
 impl SimpleInstruction for Format {
-    fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
+    fn execute(&self, state: &mut ProcessorState, vm: &LogicVM) {
         if state.printbuffer.len() >= MAX_TEXT_BUFFER {
             return;
         }
@@ -273,7 +276,7 @@ impl SimpleInstruction for Format {
         let value = self.value.get(state);
         state.printbuffer.splice(
             placeholder_index..placeholder_index + 3,
-            ProcessorState::encode_utf16(&Print::to_string(&value)),
+            ProcessorState::encode_utf16(&Print::to_string(&value, vm)),
         );
     }
 }

src/logic/vm/mod.rs

@@ -7,7 +7,7 @@ mod variables;
 
 use std::{
     borrow::Cow,
-    cell::{Cell, RefCell},
+    cell::Cell,
     collections::HashMap,
     rc::Rc,
     time::{Duration, Instant},
@@ -25,8 +25,10 @@ const MILLIS_PER_SEC: u64 = 1_000;
 const NANOS_PER_MILLI: u32 = 1_000_000;
 
 pub struct LogicVM<'a> {
-    buildings: HashMap<Point2, Rc<RefCell<Building>>>,
-    processors: Vec<Rc<RefCell<Building>>>,
+    /// Sorted with all processors first, then all other buildings.
+    buildings: Vec<Building>,
+    buildings_map: HashMap<Point2, usize>,
+    total_processors: usize,
     running_processors: Rc<Cell<usize>>,
     time: Rc<Cell<f64>>,
     globals: Cow<'a, HashMap<String, LVar>>,
@@ -39,8 +41,9 @@ impl<'a> LogicVM<'a> {
 
     pub fn new_with_globals(globals: Cow<'a, HashMap<String, LVar>>) -> Self {
         Self {
-            buildings: HashMap::new(),
-            processors: Vec::new(),
+            buildings: Vec::new(),
+            buildings_map: HashMap::new(),
+            total_processors: 0,
             running_processors: Rc::new(Cell::new(0)),
             time: Rc::new(Cell::new(0.)),
             globals,
@@ -57,41 +60,42 @@ impl<'a> LogicVM<'a> {
         Ok(vm)
     }
 
-    pub fn add_building(&mut self, building: Building) -> VMLoadResult<()> {
+    pub fn add_building(&mut self, building: Building) {
         let position = building.position;
         let size = building.block.size;
 
-        let building = Rc::new(RefCell::new(building));
+        let index = if let BuildingData::Processor(processor) = &*building.data.borrow() {
+            if processor.state.enabled() {
+                self.running_processors.update(|n| n + 1);
+            }
+            self.total_processors += 1;
+            self.total_processors - 1
+        } else {
+            self.buildings.len()
+        };
+
+        self.buildings.insert(index, building);
 
         for x in position.x..position.x + size {
             for y in position.y..position.y + size {
-                self.buildings.insert(Point2 { x, y }, building.clone());
-            }
-        }
-
-        if let BuildingData::Processor(processor) = &building.borrow().data {
-            self.processors.push(building.clone());
-            if processor.state.enabled() {
-                self.running_processors.update(|n| n + 1);
+                self.buildings_map.insert(Point2 { x, y }, index);
             }
         }
-
-        Ok(())
     }
 
-    pub fn add_buildings<T>(&mut self, buildings: T) -> VMLoadResult<()>
+    pub fn add_buildings<T>(&mut self, buildings: T)
     where
         T: IntoIterator<Item = Building>,
     {
         for building in buildings.into_iter() {
-            self.add_building(building)?;
+            self.add_building(building);
         }
-        Ok(())
     }
 
     pub fn add_schematic_tile(&mut self, tile: &SchematicTile) -> VMLoadResult<()> {
         let building = Building::from_schematic_tile(tile, self)?;
-        self.add_building(building)
+        self.add_building(building);
+        Ok(())
     }
 
     pub fn add_schematic_tiles(&mut self, tiles: &[SchematicTile]) -> VMLoadResult<()> {
@@ -101,6 +105,12 @@ impl<'a> LogicVM<'a> {
         Ok(())
     }
 
+    pub fn building(&self, position: Point2) -> Option<&Building> {
+        self.buildings_map
+            .get(&position)
+            .map(|&i| &self.buildings[i])
+    }
+
     /// Run the simulation until all processors halt, or until a number of ticks are finished.
     /// Returns true if all processors halted, or false if the tick limit was reached.
     pub fn run(&mut self, max_ticks: Option<usize>) -> bool {
@@ -134,10 +144,10 @@ impl<'a> LogicVM<'a> {
         let time = self.time.get() + duration_millis_f64(delta).max(0.);
         self.time.set(time);
 
-        for processor in &self.processors {
+        for processor in self.buildings.iter().take(self.total_processors) {
             processor
-                .borrow_mut()
                 .data
+                .borrow_mut()
                 .unwrap_processor_mut()
                 .do_tick(self, time);
         }
@@ -189,23 +199,22 @@ mod tests {
             buildings::{HYPER_PROCESSOR, MICRO_PROCESSOR},
             variables::{Content, LValue, LVar},
         },
-        types::{Object, PackedPoint2, ProcessorConfig, Team, colors::COLORS, content},
+        types::{Object, PackedPoint2, ProcessorConfig, Team, colors::COLORS},
     };
 
     use super::{buildings::WORLD_PROCESSOR, processor::Processor, *};
 
     fn single_processor_vm<'a>(name: &str, code: &str) -> LogicVM<'a> {
         let mut vm = LogicVM::new();
         vm.add_building(
-            Building::new_processor(
+            Building::from_processor_config(
                 name,
                 Point2::new(0, 0),
                 &ProcessorConfig::from_code(code),
                 &vm,
             )
             .unwrap(),
-        )
-        .unwrap();
+        );
         vm
     }
 
@@ -216,15 +225,14 @@ mod tests {
     ) -> LogicVM<'a> {
         let mut vm = LogicVM::new_with_globals(Cow::Borrowed(globals));
         vm.add_building(
-            Building::new_processor(
+            Building::from_processor_config(
                 name,
                 Point2::new(0, 0),
                 &ProcessorConfig::from_code(code),
                 &vm,
             )
             .unwrap(),
-        )
-        .unwrap();
+        );
         vm
     }
 
@@ -239,19 +247,15 @@ mod tests {
     }
 
     fn with_processor(vm: &mut LogicVM, idx: usize, f: impl FnOnce(&mut Processor)) {
-        f(vm.processors[idx].borrow_mut().data.unwrap_processor_mut())
+        f(vm.buildings[idx].data.borrow_mut().unwrap_processor_mut())
     }
 
     fn take_processor(vm: &mut LogicVM, idx: usize) -> Processor {
-        vm.processors[idx]
-            .replace(Building {
-                position: Point2::new(0, 0),
-                block: &content::blocks::VALUES[0],
-                data: BuildingData::Unknown {
-                    config: Object::Null,
-                },
-            })
+        vm.buildings[idx]
             .data
+            .replace(BuildingData::Unknown {
+                config: Object::Null,
+            })
             .into_processor()
     }
 

src/logic/vm/variables.rs

@@ -179,10 +179,7 @@ pub enum LValue {
     String(Rc<str>),
     Content(Content),
     Team(Team),
-    Building {
-        block: &'static Block,
-        position: Point2,
-    },
+    Building(Point2),
 }
 
 impl LValue {