Implement memory blocks, messages, and switches

Author: object-Object

Cargo.lock

@@ -15,6 +15,7 @@ js-sys = "0.3.77"
 mindy = { path = "..", default-features = false, features = ["std", "embedded_graphics", "wasm"] }
 wasm-bindgen = "0.2.100"
 wee_alloc = "0.4.5"
+widestring = "1.2.0"
 
 [dependencies.web-sys]
 version = "0.3"

mindy-website/Cargo.toml

@@ -0,0 +1,96 @@
+use std::borrow::Cow;
+
+use mindy::{
+    types::LAccess,
+    vm::{Building, CustomBuildingData, InstructionResult, LValue, LogicVM, instructions},
+};
+use widestring::U16String;
+
+use crate::utils::{on_building_change, u16str_to_js};
+
+pub struct WebMessageData {
+    value: U16String,
+    on_building_change: js_sys::Function,
+}
+
+impl WebMessageData {
+    pub fn new(on_building_change: js_sys::Function) -> Self {
+        Self {
+            value: U16String::new(),
+            on_building_change,
+        }
+    }
+}
+
+impl CustomBuildingData for WebMessageData {
+    fn read(&mut self, _: &Building, _: &LogicVM, address: Cow<'_, LValue>) -> Option<LValue> {
+        Some(instructions::Read::read_slice(self.value.as_slice(), &address).into())
+    }
+
+    fn printflush(
+        &mut self,
+        building: &Building,
+        _: &LogicVM,
+        printbuffer: U16String,
+    ) -> InstructionResult {
+        self.value = printbuffer;
+        on_building_change(
+            &self.on_building_change,
+            building.position,
+            "message",
+            u16str_to_js(&self.value),
+        );
+        InstructionResult::Ok
+    }
+
+    fn sensor(&mut self, _: &Building, _: &LogicVM, sensor: LAccess) -> Option<LValue> {
+        Some(match sensor {
+            LAccess::BufferSize => self.value.len().into(),
+            _ => return None,
+        })
+    }
+}
+
+pub struct WebSwitchData {
+    enabled: bool,
+    on_building_change: js_sys::Function,
+}
+
+impl WebSwitchData {
+    pub fn new(on_building_change: js_sys::Function) -> Self {
+        Self {
+            enabled: false,
+            on_building_change,
+        }
+    }
+}
+
+impl CustomBuildingData for WebSwitchData {
+    fn control(
+        &mut self,
+        building: &Building,
+        _: &LogicVM,
+        control: LAccess,
+        p1: Cow<'_, LValue>,
+        _: Cow<'_, LValue>,
+        _: Cow<'_, LValue>,
+    ) -> InstructionResult {
+        if control == LAccess::Enabled {
+            self.enabled = p1.bool();
+            on_building_change(
+                &self.on_building_change,
+                building.position,
+                "switch",
+                self.enabled,
+            );
+        }
+        InstructionResult::Ok
+    }
+
+    fn sensor(&mut self, _: &Building, _: &LogicVM, sensor: LAccess) -> Option<LValue> {
+        Some(match sensor {
+            LAccess::Enabled => self.enabled.into(),
+            _ => return None,
+        })
+    }
+}

mindy-website/src/buildings.rs

@@ -0,0 +1,76 @@
+use mindy::{
+    types::content,
+    vm::buildings::{
+        HYPER_PROCESSOR, LOGIC_PROCESSOR, MEMORY_BANK, MEMORY_CELL, MICRO_PROCESSOR, WORLD_CELL,
+        WORLD_PROCESSOR,
+    },
+};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub enum DisplayKind {
+    Logic,
+    Large,
+    Tiled,
+}
+
+impl DisplayKind {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Logic => "logic-display",
+            Self::Large => "large-logic-display",
+            Self::Tiled => "tile-logic-display",
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub fn display_size(kind: DisplayKind) -> i16 {
+    content::blocks::FROM_NAME[kind.name()].size
+}
+
+#[wasm_bindgen]
+pub enum MemoryKind {
+    Cell,
+    Bank,
+    WorldCell,
+}
+
+impl MemoryKind {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Cell => MEMORY_CELL,
+            Self::Bank => MEMORY_BANK,
+            Self::WorldCell => WORLD_CELL,
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub fn memory_size(kind: MemoryKind) -> i16 {
+    content::blocks::FROM_NAME[kind.name()].size
+}
+
+#[wasm_bindgen]
+pub enum ProcessorKind {
+    Micro,
+    Logic,
+    Hyper,
+    World,
+}
+
+impl ProcessorKind {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Micro => MICRO_PROCESSOR,
+            Self::Logic => LOGIC_PROCESSOR,
+            Self::Hyper => HYPER_PROCESSOR,
+            Self::World => WORLD_PROCESSOR,
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub fn processor_size(kind: ProcessorKind) -> i16 {
+    content::blocks::FROM_NAME[kind.name()].size
+}