Add sorter node

object-Object · object-Object · commit ae71b3d0505b · 2025-08-21T00:21:01.000-04:00
diff --git a/mindy-website/src/buildings.rs b/mindy-website/src/buildings.rs
@@ -1,8 +1,11 @@
 use std::borrow::Cow;
 
 use mindy::{
-    types::LAccess,
-    vm::{Building, CustomBuildingData, InstructionResult, LValue, LogicVM, instructions},
+    types::{LAccess, content::Item},
+    vm::{
+        Building, Content, CustomBuildingData, InstructionResult, LObject, LValue, LogicVM,
+        instructions,
+    },
 };
 use widestring::U16String;
 
@@ -51,6 +54,58 @@ impl CustomBuildingData for WebMessageData {
     }
 }
 
+pub struct WebSorterData {
+    item: Option<&'static Item>,
+    on_building_change: js_sys::Function,
+}
+
+impl WebSorterData {
+    pub fn new(on_building_change: js_sys::Function) -> Self {
+        Self {
+            item: None,
+            on_building_change,
+        }
+    }
+}
+
+impl CustomBuildingData for WebSorterData {
+    fn control(
+        &mut self,
+        building: &Building,
+        _: &LogicVM,
+        control: LAccess,
+        p1: Cow<'_, LValue>,
+        _: Cow<'_, LValue>,
+        _: Cow<'_, LValue>,
+    ) -> InstructionResult {
+        if control == LAccess::Config {
+            self.item = match p1.obj() {
+                Some(LObject::Content(Content::Item(item))) => Some(*item),
+                Some(LObject::Null) => None,
+                _ => return InstructionResult::Ok,
+            };
+
+            on_building_change(
+                &self.on_building_change,
+                building.position,
+                "sorter",
+                self.item.map(|v| v.logic_id),
+            );
+        }
+        InstructionResult::Ok
+    }
+
+    fn sensor(&mut self, _: &Building, _: &LogicVM, sensor: LAccess) -> Option<LValue> {
+        Some(match sensor {
+            LAccess::Config => match self.item {
+                Some(item) => Content::Item(item).into(),
+                None => LValue::NULL,
+            },
+            _ => return None,
+        })
+    }
+}
+
 pub struct WebSwitchData {
     enabled: bool,
     on_building_change: js_sys::Function,
diff --git a/mindy-website/src/lib.rs b/mindy-website/src/lib.rs
@@ -11,7 +11,8 @@ use mindy::{
     parser::LogicParser,
     types::{LAccess, Object, ProcessorConfig, ProcessorLinkConfig, content},
     vm::{
-        Building, BuildingData, EmbeddedDisplayData, InstructionResult, LVar, LogicVM,
+        Building, BuildingData, Content, EmbeddedDisplayData, InstructionResult, LValue, LVar,
+        LogicVM,
         buildings::{MESSAGE, SWITCH},
         variables::Constants,
     },
@@ -154,6 +155,19 @@ impl WebLogicVM {
             .map_err(|e| e.to_string())
     }
 
+    pub fn add_sorter(&mut self, position: u32) -> Result<(), String> {
+        self.vm
+            .add_building(
+                Building::new(
+                    content::blocks::FROM_NAME["sorter"],
+                    unpack_point(position),
+                    WebSorterData::new(self.on_building_change.clone()).into(),
+                ),
+                &self.globals,
+            )
+            .map_err(|e| e.to_string())
+    }
+
     pub fn add_switch(&mut self, position: u32) -> Result<(), String> {
         self.vm
             .add_building(
@@ -235,6 +249,47 @@ impl WebLogicVM {
         Ok(names)
     }
 
+    pub fn set_sorter_config(
+        &mut self,
+        position: u32,
+        logic_id: Option<i32>,
+    ) -> Result<(), String> {
+        let position = unpack_point(position);
+
+        let item = match logic_id {
+            Some(logic_id) => Content::Item(
+                *content::items::FROM_LOGIC_ID
+                    .get(&logic_id)
+                    .ok_or_else(|| format!("invalid logic id: {logic_id}"))?,
+            )
+            .into(),
+            None => LValue::NULL,
+        };
+
+        let building = self
+            .vm
+            .building(position)
+            .ok_or_else(|| format!("building does not exist: {position}"))?;
+
+        let BuildingData::Custom(custom) = &mut *building.data.borrow_mut() else {
+            return Err(format!(
+                "expected switch at {position} but got {}",
+                building.block.name
+            ));
+        };
+
+        let _ = custom.control(
+            building,
+            &self.vm,
+            LAccess::Config,
+            Cow::Owned(item),
+            Default::default(),
+            Default::default(),
+        );
+
+        Ok(())
+    }
+
     pub fn set_switch_enabled(&mut self, position: u32, value: bool) -> Result<(), String> {
         let position = unpack_point(position);
         let building = self
diff --git a/mindy-website/www/src/components/AddBuildingMenu.tsx b/mindy-website/www/src/components/AddBuildingMenu.tsx
@@ -230,6 +230,20 @@ export default function AddBuildingMenu() {
                             Message
                         </Menu.Item>
 
+                        <Menu.Item
+                            onClick={() =>
+                                reactFlow.addNodes(
+                                    createBuildingNode({
+                                        type: "sorter",
+                                        size: 1,
+                                        data: {},
+                                    }),
+                                )
+                            }
+                        >
+                            Sorter
+                        </Menu.Item>
+
                         <Menu.Item
                             onClick={() =>
                                 reactFlow.addNodes(
diff --git a/mindy-website/www/src/components/LogicVMFlow.tsx b/mindy-website/www/src/components/LogicVMFlow.tsx
@@ -24,20 +24,23 @@ import DisplayNode, { type DisplayNodeType } from "./nodes/DisplayNode";
 import MemoryNode, { type MemoryNodeType } from "./nodes/MemoryNode";
 import MessageNode, { type MessageNodeType } from "./nodes/MessageNode";
 import ProcessorNode, { type ProcessorNodeType } from "./nodes/ProcessorNode";
+import SorterNode, { type SorterNodeType } from "./nodes/SorterNode";
 import SwitchNode, { type SwitchNodeType } from "./nodes/SwitchNode";
 
 export type LogicVMNode =
     | DisplayNodeType
     | MemoryNodeType
     | MessageNodeType
     | ProcessorNodeType
+    | SorterNodeType
     | SwitchNodeType;
 
 const nodeTypes = {
     display: DisplayNode,
     memory: MemoryNode,
     message: MessageNode,
     processor: ProcessorNode,
+    sorter: SorterNode,
     switch: SwitchNode,
 };
 
diff --git a/mindy-website/www/src/components/nodes/SorterNode.module.css b/mindy-website/www/src/components/nodes/SorterNode.module.css
@@ -0,0 +1,3 @@
+.chip :global(.mantine-Chip-label) {
+    width: 100%;
+}
diff --git a/mindy-website/www/src/components/nodes/SorterNode.tsx b/mindy-website/www/src/components/nodes/SorterNode.tsx
@@ -0,0 +1,98 @@
+import { Center, Chip, SimpleGrid } from "@mantine/core";
+import type { NodeProps, Node } from "@xyflow/react";
+import { useEffect, useReducer } from "react";
+
+import { useLogicVM } from "../../hooks";
+import type { BuildingNodeData } from "./BuildingNode";
+import BuildingNode from "./BuildingNode";
+import classes from "./SorterNode.module.css";
+
+function reducer(
+    _: string | null,
+    action: number | string | null,
+): string | null {
+    return action?.toString() ?? null;
+}
+
+export type SorterNodeType = Node<BuildingNodeData, "sorter">;
+
+export default function SorterNode(props: NodeProps<SorterNodeType>) {
+    const {
+        data: { position },
+    } = props;
+
+    const vm = useLogicVM();
+
+    const [logicId, setLogicId] = useReducer(reducer, null);
+
+    useEffect(() => {
+        vm.postMessage({ type: "addSorter", position });
+
+        return () => {
+            vm.postMessage({ type: "removeBuilding", position });
+        };
+    }, [vm, position]);
+
+    return (
+        <BuildingNode buildingType="sorter" onUpdate={setLogicId} {...props}>
+            <Center>
+                <Chip.Group
+                    multiple={false}
+                    value={logicId}
+                    onChange={(value) => {
+                        setLogicId(value);
+                        vm.postMessage({
+                            type: "setSorterConfig",
+                            position,
+                            logicId: parseInt(value),
+                        });
+                    }}
+                >
+                    <SimpleGrid cols={4} spacing="xs" verticalSpacing="xs">
+                        {[
+                            "Copper",
+                            "Lead",
+                            "Metaglass",
+                            "Graphite",
+                            "Sand",
+                            "Coal",
+                            "Titanium",
+                            "Thorium",
+                            "Scrap",
+                            "Silicon",
+                            "Plastanium",
+                            "Phase Fabric",
+                            "Surge Alloy",
+                            "Spore Pod",
+                            "Blast Comp.",
+                            "Pyratite",
+                            "Beryllium",
+                            "Tungsten",
+                            "Oxide",
+                            "Carbide",
+                        ].map((name, i) => (
+                            <Chip
+                                key={name}
+                                value={i.toString()}
+                                className={classes.chip}
+                                size="xs"
+                                onClick={(e) => {
+                                    if (e.currentTarget.value === logicId) {
+                                        setLogicId(null);
+                                        vm.postMessage({
+                                            type: "setSorterConfig",
+                                            position,
+                                            logicId: null,
+                                        });
+                                    }
+                                }}
+                            >
+                                {name}
+                            </Chip>
+                        ))}
+                    </SimpleGrid>
+                </Chip.Group>
+            </Center>
+        </BuildingNode>
+    );
+}
diff --git a/mindy-website/www/src/workers/vm.ts b/mindy-website/www/src/workers/vm.ts
@@ -29,6 +29,11 @@ interface AddProcessorRequest {
     kind: ProcessorKind;
 }
 
+interface AddSorterRequest {
+    type: "addSorter";
+    position: number;
+}
+
 interface AddSwitchRequest {
     type: "addSwitch";
     position: number;
@@ -47,6 +52,12 @@ interface SetProcessorCodeRequest {
     links: Uint32Array;
 }
 
+interface SetSorterConfigRequest {
+    type: "setSorterConfig";
+    position: number;
+    logicId: number | null;
+}
+
 interface SetSwitchEnabledRequest {
     type: "setSwitchEnabled";
     position: number;
@@ -68,9 +79,11 @@ export type VMWorkerRequest =
     | AddMemoryRequest
     | AddMessageRequest
     | AddProcessorRequest
+    | AddSorterRequest
     | AddSwitchRequest
     | SetMessageTextRequest
     | SetProcessorCodeRequest
+    | SetSorterConfigRequest
     | SetSwitchEnabledRequest
     | RemoveBuildingRequest
     | SetTargetFPSRequest;
@@ -90,6 +103,7 @@ interface BuildingAddedResponse {
 export interface BuildingUpdateMap {
     message: string;
     processor: { links?: Map<number, string>; error?: string };
+    sorter: number | null;
     switch: boolean;
 }
 
diff --git a/mindy-website/www/src/workers/vm.worker.ts b/mindy-website/www/src/workers/vm.worker.ts
@@ -88,6 +88,19 @@ void init().then(() => {
                 break;
             }
 
+            case "addSorter": {
+                const { position } = request;
+
+                vm.add_sorter(position);
+                postMessage({
+                    type: "buildingAdded",
+                    position,
+                    name: vm.building_name(position),
+                });
+
+                break;
+            }
+
             case "addSwitch": {
                 const { position } = request;
 
@@ -130,6 +143,12 @@ void init().then(() => {
                 break;
             }
 
+            case "setSorterConfig": {
+                const { position, logicId } = request;
+                vm.set_sorter_config(position, logicId);
+                break;
+            }
+
             case "setSwitchEnabled": {
                 const { position, value } = request;
                 vm.set_switch_enabled(position, value);

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+.chip :global(.mantine-Chip-label) {`
	`2`	`+ width: 100%;`
	`3`	`+}`