nucleation 0.1.133__tar.gz → 0.1.135__tar.gz

{nucleation-0.1.133 → nucleation-0.1.135}/Cargo.lock

@@ -1687,7 +1687,7 @@ dependencies = [
 
 [[package]]
 name = "nucleation"
-version = "0.1.133"
+version = "0.1.135"
 dependencies = [
  "base64",
  "bytemuck",

{nucleation-0.1.133 → nucleation-0.1.135}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nucleation"
-version = "0.1.133"
+version = "0.1.135"
 edition = "2021"
 description = "A high-performance Minecraft schematic parser and utility library"
 authors = ["Nano nano@schem.at"]

{nucleation-0.1.133 → nucleation-0.1.135}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucleation
-Version: 0.1.133
+Version: 0.1.135
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3

{nucleation-0.1.133 → nucleation-0.1.135}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "nucleation"
-version = "0.1.133"
+version = "0.1.135"
 description = "A high-performance Minecraft schematic parser and utility library"
 authors = [{ name = "Nano", email = "nano@schem.at" }]
 license = { text = "AGPL-3.0-only" }

{nucleation-0.1.133 → nucleation-0.1.135}/release-artifacts/package.json

@@ -5,7 +5,7 @@
     "Nano nano@schem.at"
   ],
   "description": "A high-performance Minecraft schematic parser and utility library",
-  "version": "0.1.133",
+  "version": "0.1.135",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

{nucleation-0.1.133 → nucleation-0.1.135}/src/simulation/typed_executor/io_type.rs

@@ -130,6 +130,55 @@ impl IoType {
                 Ok(bit_array.clone())
             }
 
+            IoType::Array {
+                element_type,
+                length,
+            } => {
+                let values = value.as_array()?;
+                if values.len() != *length {
+                    return Err(format!(
+                        "Array length mismatch: expected {}, got {}",
+                        length,
+                        values.len()
+                    ));
+                }
+                let mut bits = Vec::new();
+                for v in values {
+                    bits.extend(element_type.to_binary(v)?);
+                }
+                Ok(bits)
+            }
+
+            IoType::Matrix {
+                element_type,
+                rows,
+                cols,
+            } => {
+                let values = value.as_array()?;
+                if values.len() != *rows {
+                    return Err(format!(
+                        "Matrix rows mismatch: expected {}, got {}",
+                        rows,
+                        values.len()
+                    ));
+                }
+                let mut bits = Vec::new();
+                for row_val in values {
+                    let row = row_val.as_array()?;
+                    if row.len() != *cols {
+                        return Err(format!(
+                            "Matrix cols mismatch: expected {}, got {}",
+                            cols,
+                            row.len()
+                        ));
+                    }
+                    for v in row {
+                        bits.extend(element_type.to_binary(v)?);
+                    }
+                }
+                Ok(bits)
+            }
+
             _ => Err(format!("to_binary not yet implemented for {:?}", self)),
         }
     }
@@ -208,6 +257,40 @@ impl IoType {
 
             IoType::BitArray { .. } => Ok(Value::BitArray(bits.to_vec())),
 
+            IoType::Array {
+                element_type,
+                length,
+            } => {
+                let element_bits = element_type.bit_count();
+                let mut values = Vec::with_capacity(*length);
+                for i in 0..*length {
+                    let start = i * element_bits;
+                    let end = start + element_bits;
+                    values.push(element_type.from_binary(&bits[start..end])?);
+                }
+                Ok(Value::Array(values))
+            }
+
+            IoType::Matrix {
+                element_type,
+                rows,
+                cols,
+            } => {
+                let element_bits = element_type.bit_count();
+                let mut rows_vec = Vec::with_capacity(*rows);
+                for r in 0..*rows {
+                    let mut cols_vec = Vec::with_capacity(*cols);
+                    for c in 0..*cols {
+                        let index = (r * cols + c) * element_bits;
+                        let start = index;
+                        let end = start + element_bits;
+                        cols_vec.push(element_type.from_binary(&bits[start..end])?);
+                    }
+                    rows_vec.push(Value::Array(cols_vec));
+                }
+                Ok(Value::Array(rows_vec))
+            }
+
             _ => Err(format!("from_binary not yet implemented for {:?}", self)),
         }
     }

{nucleation-0.1.133 → nucleation-0.1.135}/src/simulation/typed_executor/value.rs

@@ -125,6 +125,14 @@ impl Value {
             _ => Err(format!("Cannot convert {:?} to bytes", self)),
         }
     }
+
+    /// Try to get as array
+    pub fn as_array(&self) -> Result<&Vec<Value>, String> {
+        match self {
+            Value::Array(v) => Ok(v),
+            _ => Err(format!("Cannot convert {:?} to array", self)),
+        }
+    }
 }
 
 impl fmt::Display for Value {

{nucleation-0.1.133 → nucleation-0.1.135}/src/wasm/typed_executor.rs

@@ -74,10 +74,36 @@ impl ValueWrapper {
             Value::F32(v) => JsValue::from_f64(*v as f64),
             Value::Bool(v) => JsValue::from_bool(*v),
             Value::String(v) => JsValue::from_str(v),
-            Value::Array(_) => JsValue::from_str("[Array]"),
-            Value::Struct(_) => JsValue::from_str("[Struct]"),
-            Value::BitArray(_) => JsValue::from_str("[BitArray]"),
-            Value::Bytes(_) => JsValue::from_str("[Bytes]"),
+            Value::Array(arr) => {
+                let js_arr = Array::new();
+                for val in arr {
+                    let wrapper = ValueWrapper { inner: val.clone() };
+                    js_arr.push(&wrapper.to_js());
+                }
+                js_arr.into()
+            }
+            Value::Struct(fields) => {
+                let obj = Object::new();
+                for (key, val) in fields {
+                    let wrapper = ValueWrapper { inner: val.clone() };
+                    Reflect::set(&obj, &JsValue::from_str(key), &wrapper.to_js()).unwrap();
+                }
+                obj.into()
+            }
+            Value::BitArray(bits) => {
+                let js_arr = Array::new();
+                for bit in bits {
+                    js_arr.push(&JsValue::from_bool(*bit));
+                }
+                js_arr.into()
+            }
+            Value::Bytes(bytes) => {
+                let js_arr = Array::new();
+                for byte in bytes {
+                    js_arr.push(&JsValue::from_f64(*byte as f64));
+                }
+                js_arr.into()
+            }
         }
     }
 
@@ -845,16 +871,7 @@ impl TypedCircuitExecutorWrapper {
             let value_js = entry.get(1);
 
             // Try to convert JsValue to Value
-            let value = if let Some(b) = value_js.as_bool() {
-                Value::Bool(b)
-            } else if let Some(n) = value_js.as_f64() {
-                // Assume integers for now
-                Value::U32(n as u32)
-            } else if let Some(s) = value_js.as_string() {
-                Value::String(s)
-            } else {
-                return Err(JsValue::from_str("Unsupported input value type"));
-            };
+            let value = js_to_value(value_js)?;
 
             input_map.insert(key, value);
         }
@@ -1040,3 +1057,22 @@ impl TypedCircuitExecutorWrapper {
         result.into()
     }
 }
+
+fn js_to_value(value_js: JsValue) -> Result<Value, JsValue> {
+    if let Some(b) = value_js.as_bool() {
+        Ok(Value::Bool(b))
+    } else if let Some(n) = value_js.as_f64() {
+        Ok(Value::U32(n as u32))
+    } else if let Some(s) = value_js.as_string() {
+        Ok(Value::String(s))
+    } else if Array::is_array(&value_js) {
+        let arr = Array::from(&value_js);
+        let mut values = Vec::new();
+        for i in 0..arr.length() {
+            values.push(js_to_value(arr.get(i))?);
+        }
+        Ok(Value::Array(values))
+    } else {
+        Err(JsValue::from_str("Unsupported input value type"))
+    }
+}

nucleation-0.1.135/tests/connect4_test.js

@@ -0,0 +1,134 @@
+
+const fs = require('fs');
+const path = require('path');
+
+const wasmPath = path.join(__dirname, '../pkg/nucleation.js');
+
+async function runTests() {
+    let nucleation;
+    try {
+        nucleation = require(wasmPath);
+        if (nucleation.default && typeof nucleation.default === 'function') {
+            await nucleation.default();
+        }
+        console.log('✅ WASM module loaded successfully');
+    } catch (error) {
+        console.error('❌ Failed to load WASM module:', error);
+        process.exit(1);
+    }
+
+    const { SchematicWrapper, ExecutionModeWrapper } = nucleation;
+
+    async function testSchematic(filename, expectedBehavior) {
+        console.log(`\nTesting ${filename}...`);
+        const schemPath = path.join(__dirname, 'samples', filename);
+        const buffer = fs.readFileSync(schemPath);
+        const schem = new SchematicWrapper();
+        schem.from_data(buffer);
+
+        const input_min = {x:0,y:5,z:6};
+        const input_max = {x:0,y:25,z:32};
+        const output_min = {x:51,y:26,z:7};
+        const output_max = {x:51,y:26,z:31};
+        
+        // Map "oponent" to "player_a" and "self" to "player_b" for consistency with executor config
+        // User code:
+        // schem.createRegion("oponent", input_min, input_max).addFilter("yellow")...
+        // schem.createRegion("self", input_min, input_max).addFilter("red")...
+        
+        // We will use "player_a" for opponent (yellow) and "player_b" for self (red)
+        schem.createRegion("player_a", input_min, input_max)
+            .addFilter("yellow")
+            .setColor(0xffff00)
+            .shift(0,1,0);
+
+        schem.createRegion("player_b", input_min, input_max)
+            .addFilter("red")
+            .setColor(0xff0000)
+            .shift(0,1,0);
+            
+        schem.createRegion("output", output_min, output_max)
+            .addFilter("repeater")
+            .setColor(0x00ff00);
+
+        const executor = schem.buildExecutor({
+            inputs: [
+                { 
+                    name: "player_a", 
+                    region: "player_a",
+                    type: "matrix", 
+                    rows: 6, 
+                    cols: 7, 
+                    element: "boolean",
+                    sort: "-yxz" 
+                },
+                { 
+                    name: "player_b", 
+                    region: "player_b",
+                    type: "matrix", 
+                    rows: 6, 
+                    cols: 7, 
+                    element: "boolean",
+                    sort: "-yxz" 
+                }
+            ],
+            outputs: [
+                { 
+                    name: "output", 
+                    region: "output",
+                    type: "array", 
+                    length: 7, 
+                    element: "boolean" 
+                }
+            ]
+        });
+
+        // Empty board
+        const emptyInputs = { 
+            "player_a": Array(6).fill().map(() => Array(7).fill(false)), 
+            "player_b": Array(6).fill().map(() => Array(7).fill(false))
+        };
+        
+        const mode = ExecutionModeWrapper.fixedTicks(20);
+        // Warmup / Reset?
+        // executor.execute(emptyInputs, mode);
+
+        // Test Case: Opponent plays in column 3 (index 3)
+        // Note: User said "add a coin in the oponent column it should reply with a output with the same index column"
+        // Let's try placing a piece in the bottom row (index 5? or 0? depending on sort)
+        // Sort is "-yxz". y goes 5 to 25. -y means 25 down to 5? Or inverted axis?
+        // If rows=6, cols=7.
+        
+        // Let's just set one true in the matrix and see what happens.
+        const inputs = JSON.parse(JSON.stringify(emptyInputs));
+        // Set a piece in column 3. Which row? Let's try bottom row.
+        // If sort is -y, maybe index 0 is top or bottom?
+        // Let's just set the whole column to be sure, or just one piece.
+        inputs["player_a"][5][3] = true; // Bottom row?
+
+        console.log("Executing with input in col 3...");
+        const result = executor.execute(inputs, mode).outputs;
+        console.log("Result:", result);
+        
+        if (expectedBehavior === 'copy') {
+             // Expect output index 3 to be true
+             if (result.output[3]) {
+                 console.log("✅ Success: Output matches input column.");
+             } else {
+                 console.log("❌ Failure: Output did not match input column.");
+             }
+        } else if (expectedBehavior === 'leftmost') {
+            // Expect output index 0 (leftmost) to be true, assuming it's available
+            if (result.output[0]) {
+                console.log("✅ Success: Output is leftmost column.");
+            } else {
+                console.log("❌ Failure: Output is not leftmost column.");
+            }
+        }
+    }
+
+    await testSchematic('c4_ai_last_played.schem', 'copy');
+    await testSchematic('c4_ai_left_most.schem', 'leftmost');
+}
+
+runTests().catch(console.error);

{nucleation-0.1.133 → nucleation-0.1.135}/release-artifacts/nucleation-original.js

@@ -259,12 +259,12 @@ function passArray8ToWasm0(arg, malloc) {
  * @param {SchematicWrapper} schematic
  * @returns {string}
  */
-export function debug_schematic(schematic) {
+export function debug_json_schematic(schematic) {
     let deferred1_0;
     let deferred1_1;
     try {
         _assertClass(schematic, SchematicWrapper);
-        const ret = wasm.debug_schematic(schematic.__wbg_ptr);
+        const ret = wasm.debug_json_schematic(schematic.__wbg_ptr);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -273,23 +273,16 @@ export function debug_schematic(schematic) {
     }
 }
 
-/**
- * Initialize WASM module with panic hook for better error messages
- */
-export function start() {
-    wasm.start();
-}
-
 /**
  * @param {SchematicWrapper} schematic
  * @returns {string}
  */
-export function debug_json_schematic(schematic) {
+export function debug_schematic(schematic) {
     let deferred1_0;
     let deferred1_1;
     try {
         _assertClass(schematic, SchematicWrapper);
-        const ret = wasm.debug_json_schematic(schematic.__wbg_ptr);
+        const ret = wasm.debug_schematic(schematic.__wbg_ptr);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -298,6 +291,13 @@ export function debug_json_schematic(schematic) {
     }
 }
 
+/**
+ * Initialize WASM module with panic hook for better error messages
+ */
+export function start() {
+    wasm.start();
+}
+
 const BlockPositionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_blockposition_free(ptr >>> 0, 1));