init

Author: Mota-Link

.cargo/config.toml

@@ -0,0 +1,15 @@
+[build]
+target = "wasm32-unknown-unknown"
+
+[target.wasm32-unknown-unknown]
+rustflags = [
+    # Import memory from WASM-4
+    "-C", "link-arg=--import-memory",
+    "-C", "link-arg=--initial-memory=65536",
+    "-C", "link-arg=--max-memory=65536",
+
+    # Temporary workaround for #255 issue.
+    # Reserve 8192 bytes of Rust stack space, offset from 6560.
+    # Bump this value, 16-byte aligned, if the framebuffer gets corrupted.
+    "-C", "link-arg=-zstack-size=14752",
+]

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,23 @@
+[package]
+name = "untangle"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+buddy-alloc = { version = "0.5.1", optional = true }
+fastrand = "2.1.1"
+
+[profile.release]
+opt-level = "z"
+lto = true
+panic = "abort"
+strip = true
+codegen-units = 1
+
+[features]
+# use `--no-default-features` or comment out next line to disable allocator
+default = ["buddy-alloc"]

Cargo.toml

@@ -0,0 +1,42 @@
+# untangle-rs
+
+A game written in Rust for the [WASM-4](https://wasm4.org) fantasy console.
+
+## How to play
+
+You are presented with a collection of points on a plane, and some of these points are connected by straight lines. The challenge is to manipulate the positions of these points freely, with the ultimate objective of repositioning them in such a way that no line segment crosses another.
+
+**Controls**: Select a point by tapping or clicking on it, then drag it to a new position.
+
+## Building
+
+Build the game by running:
+
+```shell
+cargo build --release
+```
+
+Then run it with:
+
+```shell
+cd target/wasm32-unknown-unknown/release
+w4 run untangle.wasm
+```
+
+You can optimize the binary file size using `wasm-opt` or `wasm-snip`, and then bundle it into an HTML file using the `w4 bundle` subcommand. Please ensure that you have the necessary tools installed and that your environment is properly set up to execute these commands.
+
+```shell
+# In target/wasm32-unknown-unknown/release
+wasm-opt -Oz untangle.wasm -o untangle.wasm
+wasm-snip untangle.wasm -o untangle.wasm env::memory
+w4 bundle untangle.wasm --title "untangles" --html untangle.html
+```
+
+For more info about setting up WASM-4, see the [quickstart guide](https://wasm4.org/docs/getting-started/setup?code-lang=rust#quickstart).
+
+## Links
+
+- [Documentation](https://wasm4.org/docs): Learn more about WASM-4.
+- [Snake Tutorial](https://wasm4.org/docs/tutorials/snake/goal): Learn how to build a complete game
+  with a step-by-step tutorial.
+- [GitHub](https://github.com/aduros/wasm4): Submit an issue or PR. Contributions are welcome!

README.md

@@ -0,0 +1,16 @@
+use buddy_alloc::{BuddyAllocParam, FastAllocParam, NonThreadsafeAlloc};
+
+// These values can be tuned
+const FAST_HEAP_SIZE: usize = 4 * 1024; // 4 KB
+const HEAP_SIZE: usize = 16 * 1024; // 16 KB
+const LEAF_SIZE: usize = 16;
+
+static mut FAST_HEAP: [u8; FAST_HEAP_SIZE] = [0u8; FAST_HEAP_SIZE];
+static mut HEAP: [u8; HEAP_SIZE] = [0u8; HEAP_SIZE];
+
+#[global_allocator]
+static ALLOC: NonThreadsafeAlloc = unsafe {
+    let fast_param = FastAllocParam::new(FAST_HEAP.as_ptr(), FAST_HEAP_SIZE);
+    let buddy_param = BuddyAllocParam::new(HEAP.as_ptr(), HEAP_SIZE, LEAF_SIZE);
+    NonThreadsafeAlloc::new(fast_param, buddy_param)
+};

src/alloc.rs

@@ -0,0 +1,136 @@
+#[cfg(feature = "buddy-alloc")]
+mod alloc;
+mod line;
+mod point;
+mod resource;
+mod scene;
+mod wasm4;
+
+use line::{check_intersect, init_lines, Line, Lines};
+use point::{init_points, Point, Points, PointsSpeed};
+use scene::{update_finish, update_playing, update_title, update_end};
+use wasm4::{MOUSE_BUTTONS, MOUSE_LEFT};
+
+use GameState::*;
+use MouseButtonState::*;
+use TitleState::*;
+
+#[no_mangle]
+unsafe fn update() {
+    let mouse = mouse_state();
+    GAME.previous_mouse = *MOUSE_BUTTONS;
+    GAME.seed += 1;
+    match &GAME.state {
+        Title(speed) => update_title(mouse, speed),
+        Playing => update_playing(mouse),
+        Finish(state) => update_finish(mouse, state),
+        End => update_end(),
+    }
+}
+
+static mut GAME: Game = Game {
+    points: Points::new(),
+    lines: Lines::new(),
+    previous_mouse: 0,
+    holding_point: None,
+    intersect_lines: None,
+    state: Title(Screen(PointsSpeed::new())),
+    seed: 0,
+    difficulty: 6,
+    metronome: 0,
+};
+
+struct Game {
+    points: Points,
+    lines: Lines,
+    previous_mouse: u8,
+    holding_point: Option<usize>,
+    intersect_lines: Option<(Line, Line)>,
+    state: GameState,
+    seed: u64,
+    difficulty: u8,
+    metronome: u32,
+}
+
+unsafe fn init_game() {
+    GAME.holding_point = None;
+    GAME.previous_mouse = 0;
+    loop {
+        GAME.points = init_points(GAME.difficulty as usize, true);
+        GAME.lines = init_lines(GAME.difficulty as usize);
+        GAME.intersect_lines = get_intersect_lines();
+        if GAME.intersect_lines.is_some() {
+            break;
+        }
+        GAME.seed += 1;
+    }
+}
+
+fn mouse_state() -> MouseButtonState {
+    let previous = unsafe { GAME.previous_mouse } & MOUSE_LEFT;
+    let current = unsafe { *MOUSE_BUTTONS } & MOUSE_LEFT;
+    match (previous == 1, current == 1) {
+        (false, false) => Idle,
+        (false, true) => Pressed,
+        (true, false) => Released,
+        (true, true) => Held,
+    }
+}
+
+#[inline]
+fn get_point(idx: usize) -> Point {
+    unsafe { *unwrap(GAME.points.get(idx)) }
+}
+
+fn get_intersect_lines() -> Option<(Line, Line)> {
+    for l1 in unsafe { &GAME.lines } {
+        for l2 in unsafe { &GAME.lines } {
+            if l1.0 == l2.0 || l1.0 == l2.1 || l1.1 == l2.0 || l1.1 == l2.1 {
+                continue;
+            }
+            if check_intersect(*l1, *l2) {
+                return Some((*l1, *l2));
+            }
+        }
+    }
+    None
+}
+
+enum MouseButtonState {
+    Pressed,
+    Held,
+    Released,
+    Idle,
+}
+
+enum GameState {
+    Title(TitleState),
+    Playing,
+    Finish(FinishState),
+    End,
+}
+
+enum TitleState {
+    Screen(PointsSpeed),
+    Start,
+}
+
+enum FinishState {
+    Twinkle(String),
+    Win(String),
+    Arrow(ArrowState),
+    Curtain,
+}
+
+enum ArrowState {
+    Appear,
+    WaitClick,
+}
+
+#[inline]
+fn unwrap<T>(o: Option<T>) -> T {
+    match o {
+        Some(t) => t,
+        None => std::process::abort(),
+    }
+}