curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

rustup target add wasm32-unknown-unknown

# Check Rust version
rustc --version

# Check WASM target is installed
rustup target list --installed | grep wasm32

Install wasi-sdk

wasi-sdk provides a clang toolchain configured for WebAssembly:

macOS (Homebrew):

brew install wasi-sdk

Linux/Windows:

Download from wasi-sdk releases:

# Linux example (adjust version as needed)
wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-linux.tar.gz
tar xzf wasi-sdk-24.0-x86_64-linux.tar.gz
sudo mv wasi-sdk-24.0 /opt/wasi-sdk

Windows (manual):

1. Download the Windows release from GitHub
2. Extract to C:\wasi-sdk
3. Add to PATH or set WASI_SDK_PATH environment variable

Get the Nethercore Header

Download zx.h from the Nethercore repository:

# From the nethercore repo
cp include/zx.h your-game/

Or add the include path to your build.

Verify Installation

# Check clang version
/opt/wasi-sdk/bin/clang --version

You should see:

Target: wasm32-unknown-wasi

Install Zig

macOS (Homebrew):

brew install zig

Linux/Windows:

Download from ziglang.org/download:

# Extract and add to PATH
wget https://ziglang.org/download/0.13.0/zig-linux-x86_64-0.13.0.tar.xz
tar xf zig-linux-x86_64-0.13.0.tar.xz
export PATH=$PATH:$(pwd)/zig-linux-x86_64-0.13.0

Get the Nethercore Bindings

Copy the native Zig bindings from the Nethercore repository:

cp include/zx.zig your-game/

Or declare the FFI imports directly in your code (see examples).

Verify Installation

zig version

You should see:

0.x.y

• VS Code with C/C++ extension (clangd)
• CLion (JetBrains IDE)
• Neovim with clangd LSP

• VS Code with Zig Language extension
• Neovim with zls (Zig Language Server)

cargo new --lib my-first-game
cd my-first-game

mkdir my-first-game
cd my-first-game

Copy zx.h from the Nethercore repository to your project folder.

mkdir my-first-game
cd my-first-game

Copy zx.h from the Nethercore repository to your project folder.

[package]
name = "my-first-game"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[profile.release]
opt-level = "s"
lto = true

Create a Makefile:

# Path to wasi-sdk (adjust for your system)
WASI_SDK_PATH ?= /opt/wasi-sdk

CC = $(WASI_SDK_PATH)/bin/clang
CFLAGS = -O2 -Wall -Wextra

# Export the three required functions
LDFLAGS = -Wl,--no-entry \
          -Wl,--export=init \
          -Wl,--export=update \
          -Wl,--export=render \
          -Wl,--allow-undefined

all: game.wasm

game.wasm: game.c
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^

clean:
	rm -f game.wasm

Key settings:

• --no-entry - No main() function, we use init/update/render
• --export=... - Make our functions visible to the runtime
• --allow-undefined - FFI functions are provided by the runtime

Create a build.zig:

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.resolveTargetQuery(.{
        .cpu_arch = .wasm32,
        .os_tag = .freestanding,
    });

    const exe = b.addExecutable(.{
        .name = "game",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = .ReleaseSmall,
    });

    // Export the required functions
    exe.entry = .disabled;
    exe.rdynamic = true;

    b.installArtifact(exe);
}

Key settings:

• .wasm32 + .freestanding - Compile to bare WASM
• .ReleaseSmall - Optimize for size
• .rdynamic = true - Export public functions

#![allow(unused)]
#![no_std]
#![no_main]

fn main() {
use core::panic::PanicInfo;

// Panic handler required for no_std
#[panic_handler]
fn panic(_: &PanicInfo) -> ! {
    core::arch::wasm32::unreachable()
}

// FFI imports from the Nethercore runtime
#[link(wasm_import_module = "env")]
extern "C" {
    fn set_clear_color(color: u32);
    fn button_pressed(player: u32, button: u32) -> u32;
    fn draw_rect(x: f32, y: f32, w: f32, h: f32, color: u32);
    fn draw_text(ptr: *const u8, len: u32, x: f32, y: f32, size: f32, color: u32);
}

// Game state - stored in static variables for rollback safety
static mut SQUARE_Y: f32 = 200.0;

// Button constants
const BUTTON_UP: u32 = 0;
const BUTTON_DOWN: u32 = 1;
const BUTTON_A: u32 = 4;

#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        // Set the background color (dark blue)
        set_clear_color(0x1a1a2eFF);
    }
}

#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        // Move square with D-pad
        if button_pressed(0, BUTTON_UP) != 0 {
            SQUARE_Y -= 10.0;
        }
        if button_pressed(0, BUTTON_DOWN) != 0 {
            SQUARE_Y += 10.0;
        }

        // Reset position with A button
        if button_pressed(0, BUTTON_A) != 0 {
            SQUARE_Y = 200.0;
        }

        // Keep square on screen
        SQUARE_Y = SQUARE_Y.clamp(20.0, 450.0);
    }
}

#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // Draw title text
        let title = b"Hello Nethercore!";
        draw_text(
            title.as_ptr(),
            title.len() as u32,
            80.0, 50.0, 32.0,
            0xFFFFFFFF,
        );

        // Draw the moving square
        draw_rect(200.0, SQUARE_Y, 80.0, 80.0, 0xFF6B6BFF);

        // Draw instructions
        let hint = b"D-pad: Move   A: Reset";
        draw_text(
            hint.as_ptr(),
            hint.len() as u32,
            60.0, 500.0, 18.0,
            0x888888FF,
        );
    }
}
}

Create game.c:

#include "zx.h"

/* Game state - stored in static variables for rollback safety */
static float square_y = 200.0f;

NCZX_EXPORT void init(void) {
    /* Set the background color (dark blue) */
    set_clear_color(0x1a1a2eFF);
}

NCZX_EXPORT void update(void) {
    /* Move square with D-pad */
    if (button_pressed(0, NCZX_BUTTON_UP)) {
        square_y -= 10.0f;
    }
    if (button_pressed(0, NCZX_BUTTON_DOWN)) {
        square_y += 10.0f;
    }

    /* Reset position with A button */
    if (button_pressed(0, NCZX_BUTTON_A)) {
        square_y = 200.0f;
    }

    /* Keep square on screen */
    square_y = nczx_clampf(square_y, 20.0f, 450.0f);
}

NCZX_EXPORT void render(void) {
    /* Draw title text */
    NCZX_DRAW_TEXT("Hello Nethercore!", 80.0f, 50.0f, 32.0f, NCZX_COLOR_WHITE);

    /* Draw the moving square */
    draw_rect(200.0f, square_y, 80.0f, 80.0f, 0xFF6B6BFF);

    /* Draw instructions */
    NCZX_DRAW_TEXT("D-pad: Move   A: Reset", 60.0f, 500.0f, 18.0f, 0x888888FF);
}

The header provides:

• NCZX_EXPORT - Marks functions for WASM export
• NCZX_BUTTON_* - Button constants
• NCZX_DRAW_TEXT() - Helper macro for string literals
• nczx_clampf() - Clamp float between min and max

Create src/main.zig:

// FFI imports from the Nethercore runtime
extern fn set_clear_color(color: u32) void;
extern fn button_pressed(player: u32, button: u32) u32;
extern fn draw_rect(x: f32, y: f32, w: f32, h: f32, color: u32) void;
extern fn draw_text(ptr: [*]const u8, len: u32, x: f32, y: f32, size: f32, color: u32) void;

// Button constants
const BUTTON_UP: u32 = 0;
const BUTTON_DOWN: u32 = 1;
const BUTTON_A: u32 = 4;

// Game state - stored in static variables for rollback safety
var square_y: f32 = 200.0;

export fn init() void {
    // Set the background color (dark blue)
    set_clear_color(0x1a1a2eFF);
}

export fn update() void {
    // Move square with D-pad
    if (button_pressed(0, BUTTON_UP) != 0) {
        square_y -= 10.0;
    }
    if (button_pressed(0, BUTTON_DOWN) != 0) {
        square_y += 10.0;
    }

    // Reset position with A button
    if (button_pressed(0, BUTTON_A) != 0) {
        square_y = 200.0;
    }

    // Keep square on screen
    square_y = @max(20.0, @min(square_y, 450.0));
}

export fn render() void {
    // Draw title text
    const title = "Hello Nethercore!";
    draw_text(title.ptr, title.len, 80.0, 50.0, 32.0, 0xFFFFFFFF);

    // Draw the moving square
    draw_rect(200.0, square_y, 80.0, 80.0, 0xFF6B6BFF);

    // Draw instructions
    const hint = "D-pad: Move   A: Reset";
    draw_text(hint.ptr, hint.len, 60.0, 500.0, 18.0, 0x888888FF);
}

Zig’s export fn automatically exports functions from the WASM module.

#![allow(unused)]
#![no_std]
#![no_main]
fn main() {
}

We compile with --no-entry and don’t link libc. The header provides everything you need. For advanced use cases, you can optionally link wasi-libc.

Zig compiles to freestanding WASM by default with .os_tag = .freestanding. The standard library’s OS-specific parts are unavailable, but math and memory functions work.

#![allow(unused)]
fn main() {
static mut SQUARE_Y: f32 = 200.0;
}

static float square_y = 200.0f;

var square_y: f32 = 200.0;

cargo build --target wasm32-unknown-unknown --release

nether run target/wasm32-unknown-unknown/release/my_first_game.wasm

Build the WASM file:

make

Output: game.wasm

Run in the Nethercore player:

nether run game.wasm

Build the WASM file:

zig build

Output: zig-out/bin/game.wasm

Run in the Nethercore player:

nether run zig-out/bin/game.wasm

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn init() {
    // Load resources
    // Configure graphics settings
    // Initialize game state
}
}

NCZX_EXPORT void init(void) {
    /* Load resources */
    /* Configure graphics settings */
    /* Initialize game state */
}

export fn init() void {
    // Load resources
    // Configure graphics settings
    // Initialize game state
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_resolution(1);        // 540p
        set_tick_rate(2);         // 60 FPS
        set_clear_color(0x000000FF);
        render_mode(2);           // PBR lighting

        // Load a texture
        PLAYER_TEXTURE = load_texture(8, 8, PIXELS.as_ptr());
    }
}
}

static uint32_t player_texture = 0;

NCZX_EXPORT void init(void) {
    set_resolution(1);        /* 540p */
    set_tick_rate(2);         /* 60 FPS */
    set_clear_color(0x000000FF);
    render_mode(NCZX_RENDER_PBR);

    /* Load a texture */
    player_texture = load_texture(8, 8, pixels);
}

var player_texture: u32 = 0;

export fn init() void {
    set_resolution(1);        // 540p
    set_tick_rate(2);         // 60 FPS
    set_clear_color(0x000000FF);
    render_mode(2);           // PBR lighting

    // Load a texture
    player_texture = load_texture(8, 8, &pixels);
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    // Read input
    // Update game logic
    // Handle physics
    // Check collisions
}
}

NCZX_EXPORT void update(void) {
    /* Read input */
    /* Update game logic */
    /* Handle physics */
    /* Check collisions */
}

export fn update() void {
    // Read input
    // Update game logic
    // Handle physics
    // Check collisions
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        let dt = delta_time();

        // Read input
        let move_x = left_stick_x(0);
        let jump = button_pressed(0, BUTTON_A) != 0;

        // Update physics
        PLAYER_VY -= GRAVITY;
        PLAYER_X += move_x * SPEED * dt;
        PLAYER_Y += PLAYER_VY * dt;

        // Handle jump
        if jump && ON_GROUND {
            PLAYER_VY = JUMP_FORCE;
        }
    }
}
}

NCZX_EXPORT void update(void) {
    float dt = delta_time();

    /* Read input */
    float move_x = left_stick_x(0);
    int jump = button_pressed(0, NCZX_BUTTON_A) != 0;

    /* Update physics */
    player_vy -= GRAVITY;
    player_x += move_x * SPEED * dt;
    player_y += player_vy * dt;

    /* Handle jump */
    if (jump && on_ground) {
        player_vy = JUMP_FORCE;
    }
}

export fn update() void {
    const dt = delta_time();

    // Read input
    const move_x = left_stick_x(0);
    const jump = button_pressed(0, BUTTON_A) != 0;

    // Update physics
    player_vy -= GRAVITY;
    player_x += move_x * SPEED * dt;
    player_y += player_vy * dt;

    // Handle jump
    if (jump and on_ground) {
        player_vy = JUMP_FORCE;
    }
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn render() {
    // Set up camera
    // Draw game objects
    // Draw UI
}
}

NCZX_EXPORT void render(void) {
    /* Set up camera */
    /* Draw game objects */
    /* Draw UI */
}

export fn render() void {
    // Set up camera
    // Draw game objects
    // Draw UI
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // Set camera
        camera_set(0.0, 5.0, 10.0, 0.0, 0.0, 0.0);

        // Draw player
        push_identity();
        push_translate(PLAYER_X, PLAYER_Y, 0.0);
        texture_bind(PLAYER_TEXTURE);
        draw_mesh(PLAYER_MESH);

        // Draw UI
        let score = b"Score: ";
        draw_text(score.as_ptr(), score.len() as u32, 10.0, 10.0, 20.0, 0xFFFFFFFF);
    }
}
}

NCZX_EXPORT void render(void) {
    /* Set camera */
    camera_set(0.0f, 5.0f, 10.0f, 0.0f, 0.0f, 0.0f);

    /* Draw player */
    push_identity();
    push_translate(player_x, player_y, 0.0f);
    texture_bind(player_texture);
    draw_mesh(player_mesh);

    /* Draw UI */
    NCZX_DRAW_TEXT("Score: ", 10.0f, 10.0f, 20.0f, NCZX_COLOR_WHITE);
}

export fn render() void {
    // Set camera
    camera_set(0.0, 5.0, 10.0, 0.0, 0.0, 0.0);

    // Draw player
    push_identity();
    push_translate(player_x, player_y, 0.0);
    texture_bind(player_texture);
    draw_mesh(player_mesh);

    // Draw UI
    const score = "Score: ";
    draw_text(score.ptr, score.len, 10.0, 10.0, 20.0, 0xFFFFFFFF);
}

#![allow(unused)]
fn main() {
set_tick_rate(0);  // 24 ticks per second (cinematic)
set_tick_rate(1);  // 30 ticks per second
set_tick_rate(2);  // 60 ticks per second (default)
set_tick_rate(3);  // 120 ticks per second (fighting games)
}

set_tick_rate(NCZX_TICK_RATE_24);   /* 24 ticks per second (cinematic) */
set_tick_rate(NCZX_TICK_RATE_30);   /* 30 ticks per second */
set_tick_rate(NCZX_TICK_RATE_60);   /* 60 ticks per second (default) */
set_tick_rate(NCZX_TICK_RATE_120);  /* 120 ticks per second (fighting games) */

set_tick_rate(0);  // 24 ticks per second (cinematic)
set_tick_rate(1);  // 30 ticks per second
set_tick_rate(2);  // 60 ticks per second (default)
set_tick_rate(3);  // 120 ticks per second (fighting games)

#![allow(unused)]
fn main() {
#[derive(Clone, Copy, PartialEq)]
enum GameState {
    Title,
    Playing,
    Paused,
    GameOver,
}

static mut STATE: GameState = GameState::Title;

#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        match STATE {
            GameState::Title => update_title(),
            GameState::Playing => update_gameplay(),
            GameState::Paused => update_pause(),
            GameState::GameOver => update_game_over(),
        }
    }
}
}

typedef enum {
    STATE_TITLE,
    STATE_PLAYING,
    STATE_PAUSED,
    STATE_GAME_OVER
} GameState;

static GameState state = STATE_TITLE;

NCZX_EXPORT void update(void) {
    switch (state) {
        case STATE_TITLE:    update_title();     break;
        case STATE_PLAYING:  update_gameplay();  break;
        case STATE_PAUSED:   update_pause();     break;
        case STATE_GAME_OVER: update_game_over(); break;
    }
}

const GameState = enum {
    title,
    playing,
    paused,
    game_over,
};

var state: GameState = .title;

export fn update() void {
    switch (state) {
        .title => update_title(),
        .playing => update_gameplay(),
        .paused => update_pause(),
        .game_over => update_game_over(),
    }
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        let dt = delta_time();

        // Movement is frame-rate independent
        PLAYER_X += SPEED * dt;
    }
}
}

NCZX_EXPORT void update(void) {
    float dt = delta_time();

    /* Movement is frame-rate independent */
    player_x += SPEED * dt;
}

export fn update() void {
    const dt = delta_time();

    // Movement is frame-rate independent
    player_x += SPEED * dt;
}

#![allow(unused)]
#![no_std]
#![no_main]

fn main() {
use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    core::arch::wasm32::unreachable()
}

// FFI imports from the Nethercore runtime
#[link(wasm_import_module = "env")]
extern "C" {
    fn set_clear_color(color: u32);
    fn set_color(color: u32);
    fn draw_rect(x: f32, y: f32, w: f32, h: f32);
}

#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        // Dark background
        set_clear_color(0x1a1a2eFF);
    }
}

#[no_mangle]
pub extern "C" fn update() {
    // Game logic will go here
}

#[no_mangle]
pub extern "C" fn render() {
    // Drawing will go here
}
}

#include <stdint.h>

// FFI imports from the Nethercore runtime
NCZX_IMPORT void set_clear_color(uint32_t color);
NCZX_IMPORT void set_color(uint32_t color);
NCZX_IMPORT void draw_rect(float x, float y, float w, float h);

NCZX_EXPORT void init(void) {
    // Dark background
    set_clear_color(0x1a1a2eFF);
}

NCZX_EXPORT void update(void) {
    // Game logic will go here
}

NCZX_EXPORT void render(void) {
    // Drawing will go here
}

// FFI imports from the Nethercore runtime
extern fn set_clear_color(color: u32) void;
extern fn set_color(color: u32) void;
extern fn draw_rect(x: f32, y: f32, w: f32, h: f32) void;

export fn init() void {
    // Dark background
    set_clear_color(0x1a1a2eFF);
}

export fn update() void {
    // Game logic will go here
}

export fn render() void {
    // Drawing will go here
}

#![allow(unused)]
fn main() {
// Screen dimensions (540p default resolution)
const SCREEN_WIDTH: f32 = 960.0;
const SCREEN_HEIGHT: f32 = 540.0;

// Paddle dimensions
const PADDLE_WIDTH: f32 = 15.0;
const PADDLE_HEIGHT: f32 = 80.0;
const PADDLE_MARGIN: f32 = 30.0;  // Distance from edge

// Ball size
const BALL_SIZE: f32 = 15.0;

// Colors
const COLOR_WHITE: u32 = 0xFFFFFFFF;
const COLOR_GRAY: u32 = 0x666666FF;
const COLOR_PLAYER1: u32 = 0x4a9fffFF;  // Blue
const COLOR_PLAYER2: u32 = 0xff6b6bFF;  // Red
}

// Screen dimensions (540p default resolution)
#define SCREEN_WIDTH 960.0f
#define SCREEN_HEIGHT 540.0f

// Paddle dimensions
#define PADDLE_WIDTH 15.0f
#define PADDLE_HEIGHT 80.0f
#define PADDLE_MARGIN 30.0f  // Distance from edge

// Ball size
#define BALL_SIZE 15.0f

// Colors
#define COLOR_WHITE 0xFFFFFFFF
#define COLOR_GRAY 0x666666FF
#define COLOR_PLAYER1 0x4a9fffFF  // Blue
#define COLOR_PLAYER2 0xff6b6bFF  // Red

// Screen dimensions (540p default resolution)
const SCREEN_WIDTH: f32 = 960.0;
const SCREEN_HEIGHT: f32 = 540.0;

// Paddle dimensions
const PADDLE_WIDTH: f32 = 15.0;
const PADDLE_HEIGHT: f32 = 80.0;
const PADDLE_MARGIN: f32 = 30.0;  // Distance from edge

// Ball size
const BALL_SIZE: f32 = 15.0;

// Colors
const COLOR_WHITE: u32 = 0xFFFFFFFF;
const COLOR_GRAY: u32 = 0x666666FF;
const COLOR_PLAYER1: u32 = 0x4a9fffFF;  // Blue
const COLOR_PLAYER2: u32 = 0xff6b6bFF;  // Red

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // Draw center line (dashed)
        let dash_height = 20.0;
        let dash_gap = 15.0;
        let dash_width = 4.0;
        let center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;

        set_color(COLOR_GRAY);
        let mut y = 10.0;
        while y < SCREEN_HEIGHT - 10.0 {
            draw_rect(center_x, y, dash_width, dash_height);
            y += dash_height + dash_gap;
        }
    }
}
}

NCZX_EXPORT void render(void) {
    // Draw center line (dashed)
    float dash_height = 20.0f;
    float dash_gap = 15.0f;
    float dash_width = 4.0f;
    float center_x = SCREEN_WIDTH / 2.0f - dash_width / 2.0f;

    set_color(COLOR_GRAY);
    float y = 10.0f;
    while (y < SCREEN_HEIGHT - 10.0f) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }
}

export fn render() void {
    // Draw center line (dashed)
    const dash_height = 20.0;
    const dash_gap = 15.0;
    const dash_width = 4.0;
    const center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;

    set_color(COLOR_GRAY);
    var y: f32 = 10.0;
    while (y < SCREEN_HEIGHT - 10.0) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }
}

#![allow(unused)]
fn main() {
// Add after constants
static mut PADDLE1_Y: f32 = 0.0;
static mut PADDLE2_Y: f32 = 0.0;

#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);

        // Center paddles vertically
        PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    }
}
}

// Add after constants
static float paddle1_y = 0.0f;
static float paddle2_y = 0.0f;

NCZX_EXPORT void init(void) {
    set_clear_color(0x1a1a2eFF);

    // Center paddles vertically
    paddle1_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    paddle2_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
}

// Add after constants
var paddle1_y: f32 = 0.0;
var paddle2_y: f32 = 0.0;

export fn init() void {
    set_clear_color(0x1a1a2eFF);

    // Center paddles vertically
    paddle1_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    paddle2_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // Draw center line (dashed)
        let dash_height = 20.0;
        let dash_gap = 15.0;
        let dash_width = 4.0;
        let center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;

        set_color(COLOR_GRAY);
        let mut y = 10.0;
        while y < SCREEN_HEIGHT - 10.0 {
            draw_rect(center_x, y, dash_width, dash_height);
            y += dash_height + dash_gap;
        }

        // Draw paddle 1 (left, blue)
        set_color(COLOR_PLAYER1);
        draw_rect(
            PADDLE_MARGIN,
            PADDLE1_Y,
            PADDLE_WIDTH,
            PADDLE_HEIGHT,
        );

        // Draw paddle 2 (right, red)
        set_color(COLOR_PLAYER2);
        draw_rect(
            SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH,
            PADDLE2_Y,
            PADDLE_WIDTH,
            PADDLE_HEIGHT,
        );
    }
}
}

NCZX_EXPORT void render(void) {
    // Draw center line (dashed)
    float dash_height = 20.0f;
    float dash_gap = 15.0f;
    float dash_width = 4.0f;
    float center_x = SCREEN_WIDTH / 2.0f - dash_width / 2.0f;

    set_color(COLOR_GRAY);
    float y = 10.0f;
    while (y < SCREEN_HEIGHT - 10.0f) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }

    // Draw paddle 1 (left, blue)
    set_color(COLOR_PLAYER1);
    draw_rect(
        PADDLE_MARGIN,
        paddle1_y,
        PADDLE_WIDTH,
        PADDLE_HEIGHT
    );

    // Draw paddle 2 (right, red)
    set_color(COLOR_PLAYER2);
    draw_rect(
        SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH,
        paddle2_y,
        PADDLE_WIDTH,
        PADDLE_HEIGHT
    );
}

export fn render() void {
    // Draw center line (dashed)
    const dash_height = 20.0;
    const dash_gap = 15.0;
    const dash_width = 4.0;
    const center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;

    set_color(COLOR_GRAY);
    var y: f32 = 10.0;
    while (y < SCREEN_HEIGHT - 10.0) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }

    // Draw paddle 1 (left, blue)
    set_color(COLOR_PLAYER1);
    draw_rect(
        PADDLE_MARGIN,
        paddle1_y,
        PADDLE_WIDTH,
        PADDLE_HEIGHT,
    );

    // Draw paddle 2 (right, red)
    set_color(COLOR_PLAYER2);
    draw_rect(
        SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH,
        paddle2_y,
        PADDLE_WIDTH,
        PADDLE_HEIGHT,
    );
}

#![allow(unused)]
fn main() {
static mut BALL_X: f32 = 0.0;
static mut BALL_Y: f32 = 0.0;
}

static float ball_x = 0.0f;
static float ball_y = 0.0f;

var ball_x: f32 = 0.0;
var ball_y: f32 = 0.0;

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);

        PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;

        // Center the ball
        BALL_X = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
        BALL_Y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;
    }
}
}

NCZX_EXPORT void init(void) {
    set_clear_color(0x1a1a2eFF);

    paddle1_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    paddle2_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;

    // Center the ball
    ball_x = SCREEN_WIDTH / 2.0f - BALL_SIZE / 2.0f;
    ball_y = SCREEN_HEIGHT / 2.0f - BALL_SIZE / 2.0f;
}

export fn init() void {
    set_clear_color(0x1a1a2eFF);

    paddle1_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    paddle2_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;

    // Center the ball
    ball_x = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
    ball_y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;
}

#![allow(unused)]
fn main() {
        // Draw ball
        set_color(COLOR_WHITE);
        draw_rect(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE);
}

    // Draw ball
    set_color(COLOR_WHITE);
    draw_rect(ball_x, ball_y, BALL_SIZE, BALL_SIZE);

    // Draw ball
    set_color(COLOR_WHITE);
    draw_rect(ball_x, ball_y, BALL_SIZE, BALL_SIZE);

#![allow(unused)]
#![no_std]
#![no_main]

fn main() {
use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    core::arch::wasm32::unreachable()
}

#[link(wasm_import_module = "env")]
extern "C" {
    fn set_clear_color(color: u32);
    fn set_color(color: u32);
    fn draw_rect(x: f32, y: f32, w: f32, h: f32);
}

const SCREEN_WIDTH: f32 = 960.0;
const SCREEN_HEIGHT: f32 = 540.0;
const PADDLE_WIDTH: f32 = 15.0;
const PADDLE_HEIGHT: f32 = 80.0;
const PADDLE_MARGIN: f32 = 30.0;
const BALL_SIZE: f32 = 15.0;
const COLOR_WHITE: u32 = 0xFFFFFFFF;
const COLOR_GRAY: u32 = 0x666666FF;
const COLOR_PLAYER1: u32 = 0x4a9fffFF;
const COLOR_PLAYER2: u32 = 0xff6b6bFF;

static mut PADDLE1_Y: f32 = 0.0;
static mut PADDLE2_Y: f32 = 0.0;
static mut BALL_X: f32 = 0.0;
static mut BALL_Y: f32 = 0.0;

#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);
        PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        BALL_X = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
        BALL_Y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;
    }
}

#[no_mangle]
pub extern "C" fn update() {}

#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // Center line
        let dash_height = 20.0;
        let dash_gap = 15.0;
        let dash_width = 4.0;
        let center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;
        set_color(COLOR_GRAY);
        let mut y = 10.0;
        while y < SCREEN_HEIGHT - 10.0 {
            draw_rect(center_x, y, dash_width, dash_height);
            y += dash_height + dash_gap;
        }

        // Paddles
        set_color(COLOR_PLAYER1);
        draw_rect(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT);
        set_color(COLOR_PLAYER2);
        draw_rect(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, PADDLE2_Y,
                  PADDLE_WIDTH, PADDLE_HEIGHT);

        // Ball
        set_color(COLOR_WHITE);
        draw_rect(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE);
    }
}
}

#include <stdint.h>

// FFI imports
NCZX_IMPORT void set_clear_color(uint32_t color);
NCZX_IMPORT void set_color(uint32_t color);
NCZX_IMPORT void draw_rect(float x, float y, float w, float h);

// Constants
#define SCREEN_WIDTH 960.0f
#define SCREEN_HEIGHT 540.0f
#define PADDLE_WIDTH 15.0f
#define PADDLE_HEIGHT 80.0f
#define PADDLE_MARGIN 30.0f
#define BALL_SIZE 15.0f
#define COLOR_WHITE 0xFFFFFFFF
#define COLOR_GRAY 0x666666FF
#define COLOR_PLAYER1 0x4a9fffFF
#define COLOR_PLAYER2 0xff6b6bFF

// State
static float paddle1_y = 0.0f;
static float paddle2_y = 0.0f;
static float ball_x = 0.0f;
static float ball_y = 0.0f;

NCZX_EXPORT void init(void) {
    set_clear_color(0x1a1a2eFF);
    paddle1_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    paddle2_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    ball_x = SCREEN_WIDTH / 2.0f - BALL_SIZE / 2.0f;
    ball_y = SCREEN_HEIGHT / 2.0f - BALL_SIZE / 2.0f;
}

NCZX_EXPORT void update(void) {}

NCZX_EXPORT void render(void) {
    // Center line
    float dash_height = 20.0f;
    float dash_gap = 15.0f;
    float dash_width = 4.0f;
    float center_x = SCREEN_WIDTH / 2.0f - dash_width / 2.0f;
    set_color(COLOR_GRAY);
    float y = 10.0f;
    while (y < SCREEN_HEIGHT - 10.0f) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }

    // Paddles
    set_color(COLOR_PLAYER1);
    draw_rect(PADDLE_MARGIN, paddle1_y, PADDLE_WIDTH, PADDLE_HEIGHT);
    set_color(COLOR_PLAYER2);
    draw_rect(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, paddle2_y,
              PADDLE_WIDTH, PADDLE_HEIGHT);

    // Ball
    set_color(COLOR_WHITE);
    draw_rect(ball_x, ball_y, BALL_SIZE, BALL_SIZE);
}

// FFI imports
extern fn set_clear_color(color: u32) void;
extern fn set_color(color: u32) void;
extern fn draw_rect(x: f32, y: f32, w: f32, h: f32) void;

// Constants
const SCREEN_WIDTH: f32 = 960.0;
const SCREEN_HEIGHT: f32 = 540.0;
const PADDLE_WIDTH: f32 = 15.0;
const PADDLE_HEIGHT: f32 = 80.0;
const PADDLE_MARGIN: f32 = 30.0;
const BALL_SIZE: f32 = 15.0;
const COLOR_WHITE: u32 = 0xFFFFFFFF;
const COLOR_GRAY: u32 = 0x666666FF;
const COLOR_PLAYER1: u32 = 0x4a9fffFF;
const COLOR_PLAYER2: u32 = 0xff6b6bFF;

// State
var paddle1_y: f32 = 0.0;
var paddle2_y: f32 = 0.0;
var ball_x: f32 = 0.0;
var ball_y: f32 = 0.0;

export fn init() void {
    set_clear_color(0x1a1a2eFF);
    paddle1_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    paddle2_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    ball_x = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
    ball_y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;
}

export fn update() void {}

export fn render() void {
    // Center line
    const dash_height = 20.0;
    const dash_gap = 15.0;
    const dash_width = 4.0;
    const center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;
    set_color(COLOR_GRAY);
    var y: f32 = 10.0;
    while (y < SCREEN_HEIGHT - 10.0) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }

    // Paddles
    set_color(COLOR_PLAYER1);
    draw_rect(PADDLE_MARGIN, paddle1_y, PADDLE_WIDTH, PADDLE_HEIGHT);
    set_color(COLOR_PLAYER2);
    draw_rect(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, paddle2_y,
              PADDLE_WIDTH, PADDLE_HEIGHT);

    // Ball
    set_color(COLOR_WHITE);
    draw_rect(ball_x, ball_y, BALL_SIZE, BALL_SIZE);
}

#![allow(unused)]
fn main() {
#[link(wasm_import_module = "env")]
extern "C" {
    fn set_clear_color(color: u32);
    fn set_color(color: u32);
    fn draw_rect(x: f32, y: f32, w: f32, h: f32);

    // Input functions
    fn left_stick_y(player: u32) -> f32;
    fn button_held(player: u32, button: u32) -> u32;
}
}

NCZX_IMPORT void set_clear_color(uint32_t color);
NCZX_IMPORT void set_color(uint32_t color);
NCZX_IMPORT void draw_rect(float x, float y, float w, float h);

// Input functions
NCZX_IMPORT float left_stick_y(uint32_t player);
NCZX_IMPORT uint32_t button_held(uint32_t player, uint32_t button);

pub extern fn set_clear_color(color: u32) void;
pub extern fn set_color(color: u32) void;
pub extern fn draw_rect(x: f32, y: f32, w: f32, h: f32) void;

// Input functions
pub extern fn left_stick_y(player: u32) f32;
pub extern fn button_held(player: u32, button: u32) u32;

#![allow(unused)]
fn main() {
// Button constants
const BUTTON_UP: u32 = 0;
const BUTTON_DOWN: u32 = 1;

// Movement speed
const PADDLE_SPEED: f32 = 8.0;
}

// Button constants
#define NCZX_BUTTON_UP 0
#define NCZX_BUTTON_DOWN 1

// Movement speed
#define PADDLE_SPEED 8.0f

// Button constants
const Button = struct {
    pub const up: u32 = 0;
    pub const down: u32 = 1;
};

// Movement speed
const PADDLE_SPEED: f32 = 8.0;

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        // Player 1 (left paddle)
        update_paddle(&mut PADDLE1_Y, 0);

        // Player 2 (right paddle) - we'll add AI later
        update_paddle(&mut PADDLE2_Y, 1);
    }
}

fn update_paddle(paddle_y: &mut f32, player: u32) {
    unsafe {
        // Read analog stick (Y axis is inverted: up is negative)
        let stick_y = left_stick_y(player);

        // Read D-pad buttons
        let up = button_held(player, BUTTON_UP) != 0;
        let down = button_held(player, BUTTON_DOWN) != 0;

        // Calculate movement
        let mut movement = -stick_y * PADDLE_SPEED;  // Invert stick

        if up {
            movement -= PADDLE_SPEED;
        }
        if down {
            movement += PADDLE_SPEED;
        }

        // Apply movement
        *paddle_y += movement;

        // Clamp to screen bounds
        *paddle_y = clamp(*paddle_y, 0.0, SCREEN_HEIGHT - PADDLE_HEIGHT);
    }
}

// Helper function
fn clamp(v: f32, min: f32, max: f32) -> f32 {
    if v < min { min } else if v > max { max } else { v }
}
}

void update_paddle(float *paddle_y, uint32_t player) {
    // Read analog stick (Y axis is inverted: up is negative)
    float stick_y = left_stick_y(player);

    // Read D-pad buttons
    bool up = button_held(player, NCZX_BUTTON_UP) != 0;
    bool down = button_held(player, NCZX_BUTTON_DOWN) != 0;

    // Calculate movement
    float movement = -stick_y * PADDLE_SPEED;  // Invert stick

    if (up) {
        movement -= PADDLE_SPEED;
    }
    if (down) {
        movement += PADDLE_SPEED;
    }

    // Apply movement
    *paddle_y += movement;

    // Clamp to screen bounds
    *paddle_y = clamp(*paddle_y, 0.0f, SCREEN_HEIGHT - PADDLE_HEIGHT);
}

NCZX_EXPORT void update() {
    // Player 1 (left paddle)
    update_paddle(&paddle1_y, 0);

    // Player 2 (right paddle) - we'll add AI later
    update_paddle(&paddle2_y, 1);
}

// Helper function
float clamp(float v, float min, float max) {
    if (v < min) return min;
    if (v > max) return max;
    return v;
}

fn update_paddle(paddle_y: *f32, player: u32) void {
    // Read analog stick (Y axis is inverted: up is negative)
    const stick_y = left_stick_y(player);

    // Read D-pad buttons
    const up = button_held(player, Button.up) != 0;
    const down = button_held(player, Button.down) != 0;

    // Calculate movement
    var movement = -stick_y * PADDLE_SPEED;  // Invert stick

    if (up) {
        movement -= PADDLE_SPEED;
    }
    if (down) {
        movement += PADDLE_SPEED;
    }

    // Apply movement
    paddle_y.* += movement;

    // Clamp to screen bounds
    paddle_y.* = clamp(paddle_y.*, 0.0, SCREEN_HEIGHT - PADDLE_HEIGHT);
}

export fn update() void {
    // Player 1 (left paddle)
    update_paddle(&paddle1_y, 0);

    // Player 2 (right paddle) - we'll add AI later
    update_paddle(&paddle2_y, 1);
}

// Helper function
fn clamp(v: f32, min: f32, max: f32) f32 {
    if (v < min) return min;
    if (v > max) return max;
    return v;
}

#![allow(unused)]
fn main() {
const BUTTON_UP: u32 = 0;
const BUTTON_DOWN: u32 = 1;
const BUTTON_LEFT: u32 = 2;
const BUTTON_RIGHT: u32 = 3;
const BUTTON_A: u32 = 4;
const BUTTON_B: u32 = 5;
const BUTTON_X: u32 = 6;
const BUTTON_Y: u32 = 7;
const BUTTON_LB: u32 = 8;
const BUTTON_RB: u32 = 9;
const BUTTON_START: u32 = 12;
const BUTTON_SELECT: u32 = 13;
}

#define NCZX_BUTTON_UP 0
#define NCZX_BUTTON_DOWN 1
#define NCZX_BUTTON_LEFT 2
#define NCZX_BUTTON_RIGHT 3
#define NCZX_BUTTON_A 4
#define NCZX_BUTTON_B 5
#define NCZX_BUTTON_X 6
#define NCZX_BUTTON_Y 7
#define NCZX_BUTTON_LB 8
#define NCZX_BUTTON_RB 9
#define NCZX_BUTTON_START 12
#define NCZX_BUTTON_SELECT 13

const Button = struct {
    pub const up: u32 = 0;
    pub const down: u32 = 1;
    pub const left: u32 = 2;
    pub const right: u32 = 3;
    pub const a: u32 = 4;
    pub const b: u32 = 5;
    pub const x: u32 = 6;
    pub const y: u32 = 7;
    pub const lb: u32 = 8;
    pub const rb: u32 = 9;
    pub const start: u32 = 12;
    pub const select: u32 = 13;
};

#![allow(unused)]
#![no_std]
#![no_main]

fn main() {
use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    core::arch::wasm32::unreachable()
}

#[link(wasm_import_module = "env")]
extern "C" {
    fn set_clear_color(color: u32);
    fn set_color(color: u32);
    fn draw_rect(x: f32, y: f32, w: f32, h: f32);
    fn left_stick_y(player: u32) -> f32;
    fn button_held(player: u32, button: u32) -> u32;
}

const SCREEN_WIDTH: f32 = 960.0;
const SCREEN_HEIGHT: f32 = 540.0;
const PADDLE_WIDTH: f32 = 15.0;
const PADDLE_HEIGHT: f32 = 80.0;
const PADDLE_MARGIN: f32 = 30.0;
const PADDLE_SPEED: f32 = 8.0;
const BALL_SIZE: f32 = 15.0;

const BUTTON_UP: u32 = 0;
const BUTTON_DOWN: u32 = 1;

const COLOR_WHITE: u32 = 0xFFFFFFFF;
const COLOR_GRAY: u32 = 0x666666FF;
const COLOR_PLAYER1: u32 = 0x4a9fffFF;
const COLOR_PLAYER2: u32 = 0xff6b6bFF;

static mut PADDLE1_Y: f32 = 0.0;
static mut PADDLE2_Y: f32 = 0.0;
static mut BALL_X: f32 = 0.0;
static mut BALL_Y: f32 = 0.0;

fn clamp(v: f32, min: f32, max: f32) -> f32 {
    if v < min { min } else if v > max { max } else { v }
}

fn update_paddle(paddle_y: &mut f32, player: u32) {
    unsafe {
        let stick_y = left_stick_y(player);
        let up = button_held(player, BUTTON_UP) != 0;
        let down = button_held(player, BUTTON_DOWN) != 0;

        let mut movement = -stick_y * PADDLE_SPEED;
        if up { movement -= PADDLE_SPEED; }
        if down { movement += PADDLE_SPEED; }

        *paddle_y += movement;
        *paddle_y = clamp(*paddle_y, 0.0, SCREEN_HEIGHT - PADDLE_HEIGHT);
    }
}

#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);
        PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        BALL_X = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
        BALL_Y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;
    }
}

#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        update_paddle(&mut PADDLE1_Y, 0);
        update_paddle(&mut PADDLE2_Y, 1);
    }
}

#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // Center line
        let dash_height = 20.0;
        let dash_gap = 15.0;
        let dash_width = 4.0;
        let center_x = SCREEN_WIDTH / 2.0 - dash_width / 2.0;
        set_color(COLOR_GRAY);
        let mut y = 10.0;
        while y < SCREEN_HEIGHT - 10.0 {
            draw_rect(center_x, y, dash_width, dash_height);
            y += dash_height + dash_gap;
        }

        // Paddles
        set_color(COLOR_PLAYER1);
        draw_rect(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT);
        set_color(COLOR_PLAYER2);
        draw_rect(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, PADDLE2_Y,
                  PADDLE_WIDTH, PADDLE_HEIGHT);

        // Ball
        set_color(COLOR_WHITE);
        draw_rect(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE);
    }
}
}

#include <stdint.h>
#include <stdbool.h>

NCZX_IMPORT void set_clear_color(uint32_t color);
NCZX_IMPORT void set_color(uint32_t color);
NCZX_IMPORT void draw_rect(float x, float y, float w, float h);
NCZX_IMPORT float left_stick_y(uint32_t player);
NCZX_IMPORT uint32_t button_held(uint32_t player, uint32_t button);

#define SCREEN_WIDTH 960.0f
#define SCREEN_HEIGHT 540.0f
#define PADDLE_WIDTH 15.0f
#define PADDLE_HEIGHT 80.0f
#define PADDLE_MARGIN 30.0f
#define PADDLE_SPEED 8.0f
#define BALL_SIZE 15.0f

#define NCZX_BUTTON_UP 0
#define NCZX_BUTTON_DOWN 1

#define COLOR_WHITE 0xFFFFFFFF
#define COLOR_GRAY 0x666666FF
#define COLOR_PLAYER1 0x4a9fffFF
#define COLOR_PLAYER2 0xff6b6bFF

static float paddle1_y = 0.0f;
static float paddle2_y = 0.0f;
static float ball_x = 0.0f;
static float ball_y = 0.0f;

float clamp(float v, float min, float max) {
    if (v < min) return min;
    if (v > max) return max;
    return v;
}

void update_paddle(float *paddle_y, uint32_t player) {
    float stick_y = left_stick_y(player);
    bool up = button_held(player, NCZX_BUTTON_UP) != 0;
    bool down = button_held(player, NCZX_BUTTON_DOWN) != 0;

    float movement = -stick_y * PADDLE_SPEED;
    if (up) movement -= PADDLE_SPEED;
    if (down) movement += PADDLE_SPEED;

    *paddle_y += movement;
    *paddle_y = clamp(*paddle_y, 0.0f, SCREEN_HEIGHT - PADDLE_HEIGHT);
}

NCZX_EXPORT void init() {
    set_clear_color(0x1a1a2eFF);
    paddle1_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    paddle2_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    ball_x = SCREEN_WIDTH / 2.0f - BALL_SIZE / 2.0f;
    ball_y = SCREEN_HEIGHT / 2.0f - BALL_SIZE / 2.0f;
}

NCZX_EXPORT void update() {
    update_paddle(&paddle1_y, 0);
    update_paddle(&paddle2_y, 1);
}

NCZX_EXPORT void render() {
    // Center line
    float dash_height = 20.0f;
    float dash_gap = 15.0f;
    float dash_width = 4.0f;
    float center_x = SCREEN_WIDTH / 2.0f - dash_width / 2.0f;
    set_color(COLOR_GRAY);
    float y = 10.0f;
    while (y < SCREEN_HEIGHT - 10.0f) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }

    // Paddles
    set_color(COLOR_PLAYER1);
    draw_rect(PADDLE_MARGIN, paddle1_y, PADDLE_WIDTH, PADDLE_HEIGHT);
    set_color(COLOR_PLAYER2);
    draw_rect(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, paddle2_y,
              PADDLE_WIDTH, PADDLE_HEIGHT);

    // Ball
    set_color(COLOR_WHITE);
    draw_rect(ball_x, ball_y, BALL_SIZE, BALL_SIZE);
}

const std = @import("std");

pub extern fn set_clear_color(color: u32) void;
pub extern fn set_color(color: u32) void;
pub extern fn draw_rect(x: f32, y: f32, w: f32, h: f32) void;
pub extern fn left_stick_y(player: u32) f32;
pub extern fn button_held(player: u32, button: u32) u32;

const SCREEN_WIDTH: f32 = 960.0;
const SCREEN_HEIGHT: f32 = 540.0;
const PADDLE_WIDTH: f32 = 15.0;
const PADDLE_HEIGHT: f32 = 80.0;
const PADDLE_MARGIN: f32 = 30.0;
const PADDLE_SPEED: f32 = 8.0;
const BALL_SIZE: f32 = 15.0;

const Button = struct {
    pub const up: u32 = 0;
    pub const down: u32 = 1;
};

const COLOR_WHITE: u32 = 0xFFFFFFFF;
const COLOR_GRAY: u32 = 0x666666FF;
const COLOR_PLAYER1: u32 = 0x4a9fffFF;
const COLOR_PLAYER2: u32 = 0xff6b6bFF;

var paddle1_y: f32 = 0.0;
var paddle2_y: f32 = 0.0;
var ball_x: f32 = 0.0;
var ball_y: f32 = 0.0;

fn clamp(v: f32, min: f32, max: f32) f32 {
    if (v < min) return min;
    if (v > max) return max;
    return v;
}

fn update_paddle(paddle_y: *f32, player: u32) void {
    const stick_y = left_stick_y(player);
    const up = button_held(player, Button.up) != 0;
    const down = button_held(player, Button.down) != 0;

    var movement = -stick_y * PADDLE_SPEED;
    if (up) movement -= PADDLE_SPEED;
    if (down) movement += PADDLE_SPEED;

    paddle_y.* += movement;
    paddle_y.* = clamp(paddle_y.*, 0.0, SCREEN_HEIGHT - PADDLE_HEIGHT);
}

export fn init() void {
    set_clear_color(0x1a1a2eFF);
    paddle1_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    paddle2_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    ball_x = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
    ball_y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;
}

export fn update() void {
    update_paddle(&paddle1_y, 0);
    update_paddle(&paddle2_y, 1);
}

export fn render() void {
    // Center line
    const dash_height: f32 = 20.0;
    const dash_gap: f32 = 15.0;
    const dash_width: f32 = 4.0;
    const center_x: f32 = SCREEN_WIDTH / 2.0 - dash_width / 2.0;
    set_color(COLOR_GRAY);
    var y: f32 = 10.0;
    while (y < SCREEN_HEIGHT - 10.0) {
        draw_rect(center_x, y, dash_width, dash_height);
        y += dash_height + dash_gap;
    }

    // Paddles
    set_color(COLOR_PLAYER1);
    draw_rect(PADDLE_MARGIN, paddle1_y, PADDLE_WIDTH, PADDLE_HEIGHT);
    set_color(COLOR_PLAYER2);
    draw_rect(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, paddle2_y,
              PADDLE_WIDTH, PADDLE_HEIGHT);

    // Ball
    set_color(COLOR_WHITE);
    draw_rect(ball_x, ball_y, BALL_SIZE, BALL_SIZE);
}

#![allow(unused)]
fn main() {
static mut BALL_X: f32 = 0.0;
static mut BALL_Y: f32 = 0.0;
static mut BALL_VX: f32 = 0.0;  // Horizontal velocity
static mut BALL_VY: f32 = 0.0;  // Vertical velocity
}

static float BALL_X = 0.0f;
static float BALL_Y = 0.0f;
static float BALL_VX = 0.0f;  // Horizontal velocity
static float BALL_VY = 0.0f;  // Vertical velocity

var BALL_X: f32 = 0.0;
var BALL_Y: f32 = 0.0;
var BALL_VX: f32 = 0.0;  // Horizontal velocity
var BALL_VY: f32 = 0.0;  // Vertical velocity

#![allow(unused)]
fn main() {
const BALL_SPEED_INITIAL: f32 = 5.0;
const BALL_SPEED_MAX: f32 = 12.0;
const BALL_SPEED_INCREMENT: f32 = 0.5;
}

#define BALL_SPEED_INITIAL 5.0f
#define BALL_SPEED_MAX 12.0f
#define BALL_SPEED_INCREMENT 0.5f

const BALL_SPEED_INITIAL: f32 = 5.0;
const BALL_SPEED_MAX: f32 = 12.0;
const BALL_SPEED_INCREMENT: f32 = 0.5;

#![allow(unused)]
fn main() {
#[link(wasm_import_module = "env")]
extern "C" {
    // ... existing imports ...
    fn random() -> u32;
}
}

// Add to imports section
NCZX_IMPORT uint32_t random_u32(void);

// Add to imports section
pub extern fn random_u32() u32;

#![allow(unused)]
fn main() {
fn reset_ball(direction: i32) {
    unsafe {
        // Center the ball
        BALL_X = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
        BALL_Y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;

        // Random vertical angle (-0.25 to 0.25)
        let rand = random() % 100;
        let angle = ((rand as f32 / 100.0) - 0.5) * 0.5;

        // Set velocity
        BALL_VX = BALL_SPEED_INITIAL * direction as f32;
        BALL_VY = BALL_SPEED_INITIAL * angle;
    }
}
}

void reset_ball(int32_t direction) {
    // Center the ball
    BALL_X = SCREEN_WIDTH / 2.0f - BALL_SIZE / 2.0f;
    BALL_Y = SCREEN_HEIGHT / 2.0f - BALL_SIZE / 2.0f;

    // Random vertical angle (-0.25 to 0.25)
    uint32_t rand = random_u32() % 100;
    float angle = ((rand / 100.0f) - 0.5f) * 0.5f;

    // Set velocity
    BALL_VX = BALL_SPEED_INITIAL * (float)direction;
    BALL_VY = BALL_SPEED_INITIAL * angle;
}

fn reset_ball(direction: i32) void {
    // Center the ball
    BALL_X = SCREEN_WIDTH / 2.0 - BALL_SIZE / 2.0;
    BALL_Y = SCREEN_HEIGHT / 2.0 - BALL_SIZE / 2.0;

    // Random vertical angle (-0.25 to 0.25)
    const rand = random_u32() % 100;
    const angle = ((@as(f32, @floatFromInt(rand)) / 100.0) - 0.5) * 0.5;

    // Set velocity
    BALL_VX = BALL_SPEED_INITIAL * @as(f32, @floatFromInt(direction));
    BALL_VY = BALL_SPEED_INITIAL * angle;
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);
        PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;

        reset_ball(-1);  // Start moving toward player 1
    }
}
}

NCZX_EXPORT void init(void) {
    set_clear_color(0x1a1a2eFF);
    PADDLE1_Y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    PADDLE2_Y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;

    reset_ball(-1);  // Start moving toward player 1
}

export fn init() void {
    set_clear_color(0x1a1a2eFF);
    PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;

    reset_ball(-1);  // Start moving toward player 1
}

#![allow(unused)]
fn main() {
fn update_ball() {
    unsafe {
        // Move ball
        BALL_X += BALL_VX;
        BALL_Y += BALL_VY;

        // Bounce off top wall
        if BALL_Y <= 0.0 {
            BALL_Y = 0.0;
            BALL_VY = -BALL_VY;
        }

        // Bounce off bottom wall
        if BALL_Y >= SCREEN_HEIGHT - BALL_SIZE {
            BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
            BALL_VY = -BALL_VY;
        }
    }
}
}

void update_ball(void) {
    // Move ball
    BALL_X += BALL_VX;
    BALL_Y += BALL_VY;

    // Bounce off top wall
    if (BALL_Y <= 0.0f) {
        BALL_Y = 0.0f;
        BALL_VY = -BALL_VY;
    }

    // Bounce off bottom wall
    if (BALL_Y >= SCREEN_HEIGHT - BALL_SIZE) {
        BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
        BALL_VY = -BALL_VY;
    }
}

fn update_ball() void {
    // Move ball
    BALL_X += BALL_VX;
    BALL_Y += BALL_VY;

    // Bounce off top wall
    if (BALL_Y <= 0.0) {
        BALL_Y = 0.0;
        BALL_VY = -BALL_VY;
    }

    // Bounce off bottom wall
    if (BALL_Y >= SCREEN_HEIGHT - BALL_SIZE) {
        BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
        BALL_VY = -BALL_VY;
    }
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        update_paddle(&mut PADDLE1_Y, 0);
        update_paddle(&mut PADDLE2_Y, 1);
        update_ball();
    }
}
}

NCZX_EXPORT void update(void) {
    update_paddle(&PADDLE1_Y, 0);
    update_paddle(&PADDLE2_Y, 1);
    update_ball();
}

export fn update() void {
    update_paddle(&PADDLE1_Y, 0);
    update_paddle(&PADDLE2_Y, 1);
    update_ball();
}

#![allow(unused)]
fn main() {
fn update_ball() {
    unsafe {
        // Move ball
        BALL_X += BALL_VX;
        BALL_Y += BALL_VY;

        // Bounce off top wall
        if BALL_Y <= 0.0 {
            BALL_Y = 0.0;
            BALL_VY = -BALL_VY;
        }

        // Bounce off bottom wall
        if BALL_Y >= SCREEN_HEIGHT - BALL_SIZE {
            BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
            BALL_VY = -BALL_VY;
        }

        // Paddle 1 (left) collision
        if BALL_VX < 0.0 {  // Ball moving left
            let paddle_x = PADDLE_MARGIN;
            let paddle_right = paddle_x + PADDLE_WIDTH;

            if BALL_X <= paddle_right
                && BALL_X + BALL_SIZE >= paddle_x
                && BALL_Y + BALL_SIZE >= PADDLE1_Y
                && BALL_Y <= PADDLE1_Y + PADDLE_HEIGHT
            {
                // Bounce
                BALL_X = paddle_right;
                BALL_VX = -BALL_VX;

                // Add spin based on where ball hit paddle
                let paddle_center = PADDLE1_Y + PADDLE_HEIGHT / 2.0;
                let ball_center = BALL_Y + BALL_SIZE / 2.0;
                let offset = (ball_center - paddle_center) / (PADDLE_HEIGHT / 2.0);
                BALL_VY += offset * 2.0;

                // Speed up (makes game more exciting)
                speed_up_ball();
            }
        }

        // Paddle 2 (right) collision
        if BALL_VX > 0.0 {  // Ball moving right
            let paddle_x = SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH;

            if BALL_X + BALL_SIZE >= paddle_x
                && BALL_X <= paddle_x + PADDLE_WIDTH
                && BALL_Y + BALL_SIZE >= PADDLE2_Y
                && BALL_Y <= PADDLE2_Y + PADDLE_HEIGHT
            {
                // Bounce
                BALL_X = paddle_x - BALL_SIZE;
                BALL_VX = -BALL_VX;

                // Add spin
                let paddle_center = PADDLE2_Y + PADDLE_HEIGHT / 2.0;
                let ball_center = BALL_Y + BALL_SIZE / 2.0;
                let offset = (ball_center - paddle_center) / (PADDLE_HEIGHT / 2.0);
                BALL_VY += offset * 2.0;

                speed_up_ball();
            }
        }

        // Ball goes off screen (scoring - we'll handle this properly later)
        if BALL_X < -BALL_SIZE || BALL_X > SCREEN_WIDTH {
            reset_ball(if BALL_X < 0.0 { 1 } else { -1 });
        }
    }
}

fn speed_up_ball() {
    unsafe {
        let speed = libm::sqrtf(BALL_VX * BALL_VX + BALL_VY * BALL_VY);
        if speed < BALL_SPEED_MAX {
            let factor = (speed + BALL_SPEED_INCREMENT) / speed;
            BALL_VX *= factor;
            BALL_VY *= factor;
        }
    }
}
}

void update_ball(void) {
    // Move ball
    BALL_X += BALL_VX;
    BALL_Y += BALL_VY;

    // Bounce off top wall
    if (BALL_Y <= 0.0f) {
        BALL_Y = 0.0f;
        BALL_VY = -BALL_VY;
    }

    // Bounce off bottom wall
    if (BALL_Y >= SCREEN_HEIGHT - BALL_SIZE) {
        BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
        BALL_VY = -BALL_VY;
    }

    // Paddle 1 (left) collision
    if (BALL_VX < 0.0f) {  // Ball moving left
        float paddle_x = PADDLE_MARGIN;
        float paddle_right = paddle_x + PADDLE_WIDTH;

        if (BALL_X <= paddle_right
            && BALL_X + BALL_SIZE >= paddle_x
            && BALL_Y + BALL_SIZE >= PADDLE1_Y
            && BALL_Y <= PADDLE1_Y + PADDLE_HEIGHT)
        {
            // Bounce
            BALL_X = paddle_right;
            BALL_VX = -BALL_VX;

            // Add spin based on where ball hit paddle
            float paddle_center = PADDLE1_Y + PADDLE_HEIGHT / 2.0f;
            float ball_center = BALL_Y + BALL_SIZE / 2.0f;
            float offset = (ball_center - paddle_center) / (PADDLE_HEIGHT / 2.0f);
            BALL_VY += offset * 2.0f;

            // Speed up (makes game more exciting)
            speed_up_ball();
        }
    }

    // Paddle 2 (right) collision
    if (BALL_VX > 0.0f) {  // Ball moving right
        float paddle_x = SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH;

        if (BALL_X + BALL_SIZE >= paddle_x
            && BALL_X <= paddle_x + PADDLE_WIDTH
            && BALL_Y + BALL_SIZE >= PADDLE2_Y
            && BALL_Y <= PADDLE2_Y + PADDLE_HEIGHT)
        {
            // Bounce
            BALL_X = paddle_x - BALL_SIZE;
            BALL_VX = -BALL_VX;

            // Add spin
            float paddle_center = PADDLE2_Y + PADDLE_HEIGHT / 2.0f;
            float ball_center = BALL_Y + BALL_SIZE / 2.0f;
            float offset = (ball_center - paddle_center) / (PADDLE_HEIGHT / 2.0f);
            BALL_VY += offset * 2.0f;

            speed_up_ball();
        }
    }

    // Ball goes off screen (scoring - we'll handle this properly later)
    if (BALL_X < -BALL_SIZE || BALL_X > SCREEN_WIDTH) {
        reset_ball(BALL_X < 0.0f ? 1 : -1);
    }
}

void speed_up_ball(void) {
    float speed = sqrtf(BALL_VX * BALL_VX + BALL_VY * BALL_VY);
    if (speed < BALL_SPEED_MAX) {
        float factor = (speed + BALL_SPEED_INCREMENT) / speed;
        BALL_VX *= factor;
        BALL_VY *= factor;
    }
}

fn update_ball() void {
    // Move ball
    BALL_X += BALL_VX;
    BALL_Y += BALL_VY;

    // Bounce off top wall
    if (BALL_Y <= 0.0) {
        BALL_Y = 0.0;
        BALL_VY = -BALL_VY;
    }

    // Bounce off bottom wall
    if (BALL_Y >= SCREEN_HEIGHT - BALL_SIZE) {
        BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
        BALL_VY = -BALL_VY;
    }

    // Paddle 1 (left) collision
    if (BALL_VX < 0.0) {  // Ball moving left
        const paddle_x = PADDLE_MARGIN;
        const paddle_right = paddle_x + PADDLE_WIDTH;

        if (BALL_X <= paddle_right and
            BALL_X + BALL_SIZE >= paddle_x and
            BALL_Y + BALL_SIZE >= PADDLE1_Y and
            BALL_Y <= PADDLE1_Y + PADDLE_HEIGHT)
        {
            // Bounce
            BALL_X = paddle_right;
            BALL_VX = -BALL_VX;

            // Add spin based on where ball hit paddle
            const paddle_center = PADDLE1_Y + PADDLE_HEIGHT / 2.0;
            const ball_center = BALL_Y + BALL_SIZE / 2.0;
            const offset = (ball_center - paddle_center) / (PADDLE_HEIGHT / 2.0);
            BALL_VY += offset * 2.0;

            // Speed up (makes game more exciting)
            speed_up_ball();
        }
    }

    // Paddle 2 (right) collision
    if (BALL_VX > 0.0) {  // Ball moving right
        const paddle_x = SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH;

        if (BALL_X + BALL_SIZE >= paddle_x and
            BALL_X <= paddle_x + PADDLE_WIDTH and
            BALL_Y + BALL_SIZE >= PADDLE2_Y and
            BALL_Y <= PADDLE2_Y + PADDLE_HEIGHT)
        {
            // Bounce
            BALL_X = paddle_x - BALL_SIZE;
            BALL_VX = -BALL_VX;

            // Add spin
            const paddle_center = PADDLE2_Y + PADDLE_HEIGHT / 2.0;
            const ball_center = BALL_Y + BALL_SIZE / 2.0;
            const offset = (ball_center - paddle_center) / (PADDLE_HEIGHT / 2.0);
            BALL_VY += offset * 2.0;

            speed_up_ball();
        }
    }

    // Ball goes off screen (scoring - we'll handle this properly later)
    if (BALL_X < -BALL_SIZE or BALL_X > SCREEN_WIDTH) {
        reset_ball(if (BALL_X < 0.0) 1 else -1);
    }
}

fn speed_up_ball() void {
    const speed = @sqrt(BALL_VX * BALL_VX + BALL_VY * BALL_VY);
    if (speed < BALL_SPEED_MAX) {
        const factor = (speed + BALL_SPEED_INCREMENT) / speed;
        BALL_VX *= factor;
        BALL_VY *= factor;
    }
}

#![allow(unused)]
fn main() {
#[link(wasm_import_module = "env")]
extern "C" {
    // ... existing imports ...
    fn player_count() -> u32;
}
}

// Add to your imports
NCZX_IMPORT uint32_t player_count(void);

// Add to your imports
pub extern fn player_count() u32;

#![allow(unused)]
fn main() {
static mut IS_TWO_PLAYER: bool = false;
}

static bool is_two_player = false;

var is_two_player: bool = false;

#![allow(unused)]
fn main() {
fn update_ai(paddle_y: &mut f32) {
    unsafe {
        // AI follows the ball
        let paddle_center = *paddle_y + PADDLE_HEIGHT / 2.0;
        let ball_center = BALL_Y + BALL_SIZE / 2.0;

        let diff = ball_center - paddle_center;

        // Only move if difference is significant (dead zone)
        if diff.abs() > 5.0 {
            // AI moves slower than max speed to be beatable
            let ai_speed = PADDLE_SPEED * 0.7;

            if diff > 0.0 {
                *paddle_y += ai_speed;
            } else {
                *paddle_y -= ai_speed;
            }
        }

        // Clamp to screen bounds
        *paddle_y = clamp(*paddle_y, 0.0, SCREEN_HEIGHT - PADDLE_HEIGHT);
    }
}
}

void update_ai(float* paddle_y) {
    // AI follows the ball
    float paddle_center = *paddle_y + PADDLE_HEIGHT / 2.0f;
    float ball_center = ball_y + BALL_SIZE / 2.0f;

    float diff = ball_center - paddle_center;

    // Only move if difference is significant (dead zone)
    if (fabsf(diff) > 5.0f) {
        // AI moves slower than max speed to be beatable
        float ai_speed = PADDLE_SPEED * 0.7f;

        if (diff > 0.0f) {
            *paddle_y += ai_speed;
        } else {
            *paddle_y -= ai_speed;
        }
    }

    // Clamp to screen bounds
    *paddle_y = clamp(*paddle_y, 0.0f, SCREEN_HEIGHT - PADDLE_HEIGHT);
}

fn updateAi(paddle_y: *f32) void {
    // AI follows the ball
    const paddle_center = paddle_y.* + PADDLE_HEIGHT / 2.0;
    const ball_center = ball_y + BALL_SIZE / 2.0;

    const diff = ball_center - paddle_center;

    // Only move if difference is significant (dead zone)
    if (@abs(diff) > 5.0) {
        // AI moves slower than max speed to be beatable
        const ai_speed = PADDLE_SPEED * 0.7;

        if (diff > 0.0) {
            paddle_y.* += ai_speed;
        } else {
            paddle_y.* -= ai_speed;
        }
    }

    // Clamp to screen bounds
    paddle_y.* = clamp(paddle_y.*, 0.0, SCREEN_HEIGHT - PADDLE_HEIGHT);
}

#![allow(unused)]
fn main() {
fn abs(v: f32) -> f32 {
    if v < 0.0 { -v } else { v }
}
}

// Use fabsf() from math.h (already shown in update_ai above)

// Use @abs() builtin (already shown in updateAi above)

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        // Check if a second player is connected
        IS_TWO_PLAYER = player_count() >= 2;

        // Player 1 always uses input
        update_paddle(&mut PADDLE1_Y, 0);

        // Player 2: human or AI
        if IS_TWO_PLAYER {
            update_paddle(&mut PADDLE2_Y, 1);
        } else {
            update_ai(&mut PADDLE2_Y);
        }

        update_ball();
    }
}
}

NCZX_EXPORT void update(void) {
    // Check if a second player is connected
    is_two_player = player_count() >= 2;

    // Player 1 always uses input
    update_paddle(&paddle1_y, 0);

    // Player 2: human or AI
    if (is_two_player) {
        update_paddle(&paddle2_y, 1);
    } else {
        update_ai(&paddle2_y);
    }

    update_ball();
}

export fn update() void {
    // Check if a second player is connected
    is_two_player = player_count() >= 2;

    // Player 1 always uses input
    updatePaddle(&paddle1_y, 0);

    // Player 2: human or AI
    if (is_two_player) {
        updatePaddle(&paddle2_y, 1);
    } else {
        updateAi(&paddle2_y);
    }

    updateBall();
}

#![allow(unused)]
fn main() {
#[link(wasm_import_module = "env")]
extern "C" {
    // ... existing imports ...
    fn set_color(color: u32);
    fn draw_text(ptr: *const u8, len: u32, x: f32, y: f32, size: f32);
}
}

// Add to your imports
NCZX_IMPORT void set_color(uint32_t color);
NCZX_IMPORT void draw_text(const uint8_t* ptr, uint32_t len, float x, float y, float size);

// Add to your imports
pub extern fn set_color(color: u32) void;
pub extern fn draw_text(ptr: [*]const u8, len: u32, x: f32, y: f32, size: f32) void;

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        // ... existing drawing code ...

        // Show mode indicator
        set_color(COLOR_GRAY);
        if IS_TWO_PLAYER {
            let text = b"2 PLAYERS";
            draw_text(text.as_ptr(), text.len() as u32, 10.0, 10.0, 16.0);
        } else {
            let text = b"vs AI";
            draw_text(text.as_ptr(), text.len() as u32, 10.0, 10.0, 16.0);
        }
    }
}
}

NCZX_EXPORT void render(void) {
    // ... existing drawing code ...

    // Show mode indicator
    set_color(COLOR_GRAY);
    if (is_two_player) {
        draw_text((uint8_t*)"2 PLAYERS", 9, 10.0f, 10.0f, 16.0f);
    } else {
        draw_text((uint8_t*)"vs AI", 5, 10.0f, 10.0f, 16.0f);
    }
}

export fn render() void {
    // ... existing drawing code ...

    // Show mode indicator
    set_color(COLOR_GRAY);
    if (is_two_player) {
        draw_text("2 PLAYERS", 9, 10.0, 10.0, 16.0);
    } else {
        draw_text("vs AI", 5, 10.0, 10.0, 16.0);
    }
}

#![allow(unused)]
fn main() {
// Easier AI (50% speed)
let ai_speed = PADDLE_SPEED * 0.5;

// Harder AI (90% speed)
let ai_speed = PADDLE_SPEED * 0.9;

// Perfect AI (instant tracking) - not fun!
*paddle_y = ball_center - PADDLE_HEIGHT / 2.0;
}

// Easier AI (50% speed)
float ai_speed = PADDLE_SPEED * 0.5f;

// Harder AI (90% speed)
float ai_speed = PADDLE_SPEED * 0.9f;

// Perfect AI (instant tracking) - not fun!
*paddle_y = ball_center - PADDLE_HEIGHT / 2.0f;

// Easier AI (50% speed)
const ai_speed = PADDLE_SPEED * 0.5;

// Harder AI (90% speed)
const ai_speed = PADDLE_SPEED * 0.9;

// Perfect AI (instant tracking) - not fun!
paddle_y.* = ball_center - PADDLE_HEIGHT / 2.0;

#![allow(unused)]
fn main() {
static mut PLAYER_X: f32 = 0.0;
static mut SCORE: u32 = 0;
}

static float player_x = 0.0f;
static uint32_t score = 0;

var player_x: f32 = 0.0;
var score: u32 = 0;

#![allow(unused)]
fn main() {
// Don't try to use external state!
// (Rust's no_std prevents most of this anyway)
}

// Don't try to use external state!
// All state must be in static variables

// Don't try to use external state!
// All state must be in global variables

#![allow(unused)]
fn main() {
let rand = random();  // Deterministic, seeded by runtime
}

uint32_t rand = random_u32();  // Deterministic, seeded by runtime

const rand = random_u32();  // Deterministic, seeded by runtime

#![allow(unused)]
fn main() {
// let time = get_system_time();  // Non-deterministic!
}

// uint64_t time = get_system_time();  // Non-deterministic!

// const time = get_system_time();  // Non-deterministic!

#![allow(unused)]
fn main() {
fn render() {
    // Only READ state
    draw_rect(BALL_X, BALL_Y, ...);
}
}

NCZX_EXPORT void render(void) {
    // Only READ state
    draw_rect(ball_x, ball_y, ...);
}

export fn render() void {
    // Only READ state
    draw_rect(ball_x, ball_y, ...);
}

#![allow(unused)]
fn main() {
fn render() {
    ANIMATION_FRAME += 1;  // This won't replay during rollback!
}
}

NCZX_EXPORT void render(void) {
    animation_frame += 1;  // This won't replay during rollback!
}

export fn render() void {
    animation_frame += 1;  // This won't replay during rollback!
}

#![allow(unused)]
fn main() {
static mut PADDLE1_Y: f32 = 0.0;
static mut PADDLE2_Y: f32 = 0.0;
static mut BALL_X: f32 = 0.0;
static mut BALL_Y: f32 = 0.0;
static mut BALL_VX: f32 = 0.0;
static mut BALL_VY: f32 = 0.0;
}

static float paddle1_y = 0.0f;
static float paddle2_y = 0.0f;
static float ball_x = 0.0f;
static float ball_y = 0.0f;
static float ball_vx = 0.0f;
static float ball_vy = 0.0f;

var paddle1_y: f32 = 0.0;
var paddle2_y: f32 = 0.0;
var ball_x: f32 = 0.0;
var ball_y: f32 = 0.0;
var ball_vx: f32 = 0.0;
var ball_vy: f32 = 0.0;

#![allow(unused)]
fn main() {
fn reset_ball(direction: i32) {
    let rand = random() % 100;  // Uses runtime's seeded RNG
    // ...
}
}

void reset_ball(int32_t direction) {
    uint32_t rand = random_u32() % 100;  // Uses runtime's seeded RNG
    // ...
}

fn reset_ball(direction: i32) void {
    const rand = random_u32() % 100;  // Uses runtime's seeded RNG
    // ...
}

#![allow(unused)]
fn main() {
fn update() {
    // Read input
    let stick_y = left_stick_y(player);
    // Modify state
    PADDLE1_Y += movement;
}

fn render() {
    // Only draw, never modify state
    draw_rect(PADDLE_MARGIN, PADDLE1_Y, ...);
}
}

NCZX_EXPORT void update(void) {
    // Read input
    int8_t stick_y = left_stick_y(player);
    // Modify state
    paddle1_y += movement;
}

NCZX_EXPORT void render(void) {
    // Only draw, never modify state
    draw_rect(PADDLE_MARGIN, paddle1_y, ...);
}

export fn update() void {
    // Read input
    const stick_y = left_stick_y(player);
    // Modify state
    paddle1_y += movement;
}

export fn render() void {
    // Only draw, never modify state
    draw_rect(PADDLE_MARGIN, paddle1_y, ...);
}

#![allow(unused)]
fn main() {
#[derive(Clone, Copy, PartialEq)]
enum GameState {
    Title,
    Playing,
    GameOver,
}

static mut STATE: GameState = GameState::Title;
static mut SCORE1: u32 = 0;
static mut SCORE2: u32 = 0;
static mut WINNER: u32 = 0;  // 1 or 2

const WIN_SCORE: u32 = 5;
}

typedef enum {
    TITLE,
    PLAYING,
    GAME_OVER
} GameState;

static GameState state = TITLE;
static uint32_t score1 = 0;
static uint32_t score2 = 0;
static uint32_t winner = 0;  // 1 or 2

#define WIN_SCORE 5

const GameState = enum {
    title,
    playing,
    game_over,
};

var state: GameState = .title;
var score1: u32 = 0;
var score2: u32 = 0;
var winner: u32 = 0;  // 1 or 2

const WIN_SCORE: u32 = 5;

#![allow(unused)]
fn main() {
const BUTTON_A: u32 = 4;
}

#![allow(unused)]
fn main() {
fn button_pressed(player: u32, button: u32) -> u32;
}

#define NCZX_BUTTON_A 4

Add to FFI imports:

NCZX_IMPORT uint32_t button_pressed(uint32_t player, uint32_t button);

const Button = struct {
    pub const a: u32 = 4;
};

Add to FFI imports:

pub extern fn button_pressed(player: u32, button: u32) u32;

#![allow(unused)]
fn main() {
fn reset_game() {
    unsafe {
        // Reset paddles
        PADDLE1_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
        PADDLE2_Y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;

        // Reset scores
        SCORE1 = 0;
        SCORE2 = 0;
        WINNER = 0;

        // Check player count
        IS_TWO_PLAYER = player_count() >= 2;

        // Reset ball
        reset_ball(-1);
    }
}
}

void reset_game(void) {
    // Reset paddles
    paddle1_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;
    paddle2_y = SCREEN_HEIGHT / 2.0f - PADDLE_HEIGHT / 2.0f;

    // Reset scores
    score1 = 0;
    score2 = 0;
    winner = 0;

    // Check player count
    is_two_player = player_count() >= 2;

    // Reset ball
    reset_ball(-1);
}

fn resetGame() void {
    // Reset paddles
    paddle1_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;
    paddle2_y = SCREEN_HEIGHT / 2.0 - PADDLE_HEIGHT / 2.0;

    // Reset scores
    score1 = 0;
    score2 = 0;
    winner = 0;

    // Check player count
    is_two_player = player_count() >= 2;

    // Reset ball
    resetBall(-1);
}

#![allow(unused)]
fn main() {
fn update_ball() {
    unsafe {
        // ... existing movement and collision code ...

        // Ball goes off left side - Player 2 scores
        if BALL_X < -BALL_SIZE {
            SCORE2 += 1;

            if SCORE2 >= WIN_SCORE {
                WINNER = 2;
                STATE = GameState::GameOver;
            } else {
                reset_ball(-1);  // Serve toward player 1
            }
        }

        // Ball goes off right side - Player 1 scores
        if BALL_X > SCREEN_WIDTH {
            SCORE1 += 1;

            if SCORE1 >= WIN_SCORE {
                WINNER = 1;
                STATE = GameState::GameOver;
            } else {
                reset_ball(1);  // Serve toward player 2
            }
        }
    }
}
}

void update_ball(void) {
    // ... existing movement and collision code ...

    // Ball goes off left side - Player 2 scores
    if (ball_x < -BALL_SIZE) {
        score2++;

        if (score2 >= WIN_SCORE) {
            winner = 2;
            state = GAME_OVER;
        } else {
            reset_ball(-1);  // Serve toward player 1
        }
    }

    // Ball goes off right side - Player 1 scores
    if (ball_x > SCREEN_WIDTH) {
        score1++;

        if (score1 >= WIN_SCORE) {
            winner = 1;
            state = GAME_OVER;
        } else {
            reset_ball(1);  // Serve toward player 2
        }
    }
}

fn updateBall() void {
    // ... existing movement and collision code ...

    // Ball goes off left side - Player 2 scores
    if (ball_x < -BALL_SIZE) {
        score2 += 1;

        if (score2 >= WIN_SCORE) {
            winner = 2;
            state = .game_over;
        } else {
            resetBall(-1);  // Serve toward player 1
        }
    }

    // Ball goes off right side - Player 1 scores
    if (ball_x > SCREEN_WIDTH) {
        score1 += 1;

        if (score1 >= WIN_SCORE) {
            winner = 1;
            state = .game_over;
        } else {
            resetBall(1);  // Serve toward player 2
        }
    }
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        // Always check player count
        IS_TWO_PLAYER = player_count() >= 2;

        match STATE {
            GameState::Title => {
                // Press A to start
                if button_pressed(0, BUTTON_A) != 0 {
                    reset_game();
                    STATE = GameState::Playing;
                }
            }

            GameState::Playing => {
                // Normal gameplay
                update_paddle(&mut PADDLE1_Y, 0);

                if IS_TWO_PLAYER {
                    update_paddle(&mut PADDLE2_Y, 1);
                } else {
                    update_ai(&mut PADDLE2_Y);
                }

                update_ball();
            }

            GameState::GameOver => {
                // Press A to restart
                if button_pressed(0, BUTTON_A) != 0 || button_pressed(1, BUTTON_A) != 0 {
                    reset_game();
                    STATE = GameState::Playing;
                }
            }
        }
    }
}
}

NCZX_EXPORT void update(void) {
    // Always check player count
    is_two_player = player_count() >= 2;

    switch (state) {
        case TITLE:
            // Press A to start
            if (button_pressed(0, NCZX_BUTTON_A) != 0) {
                reset_game();
                state = PLAYING;
            }
            break;

        case PLAYING:
            // Normal gameplay
            update_paddle(&paddle1_y, 0);

            if (is_two_player) {
                update_paddle(&paddle2_y, 1);
            } else {
                update_ai(&paddle2_y);
            }

            update_ball();
            break;

        case GAME_OVER:
            // Press A to restart
            if (button_pressed(0, NCZX_BUTTON_A) != 0 || button_pressed(1, NCZX_BUTTON_A) != 0) {
                reset_game();
                state = PLAYING;
            }
            break;
    }
}

export fn update() void {
    // Always check player count
    is_two_player = player_count() >= 2;

    switch (state) {
        .title => {
            // Press A to start
            if (button_pressed(0, Button.a) != 0) {
                resetGame();
                state = .playing;
            }
        },

        .playing => {
            // Normal gameplay
            updatePaddle(&paddle1_y, 0);

            if (is_two_player) {
                updatePaddle(&paddle2_y, 1);
            } else {
                updateAi(&paddle2_y);
            }

            updateBall();
        },

        .game_over => {
            // Press A to restart
            if (button_pressed(0, Button.a) != 0 or button_pressed(1, Button.a) != 0) {
                resetGame();
                state = .playing;
            }
        },
    }
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);
        reset_game();
        STATE = GameState::Title;
    }
}
}

NCZX_EXPORT void init(void) {
    set_clear_color(0x1a1a2eFF);
    reset_game();
    state = TITLE;
}

export fn init() void {
    set_clear_color(0x1a1a2eFF);
    resetGame();
    state = .title;
}

#![allow(unused)]
fn main() {
fn draw_text_bytes(text: &[u8], x: f32, y: f32, size: f32) {
    unsafe {
        draw_text(text.as_ptr(), text.len() as u32, x, y, size);
    }
}
}

#![allow(unused)]
fn main() {
fn render_scores() {
    unsafe {
        // Convert scores to single digits
        let score1_char = b'0' + (SCORE1 % 10) as u8;
        let score2_char = b'0' + (SCORE2 % 10) as u8;

        // Draw scores
        set_color(COLOR_PLAYER1);
        draw_text(&[score1_char], 1, SCREEN_WIDTH / 4.0, 30.0, 48.0);
        set_color(COLOR_PLAYER2);
        draw_text(&[score2_char], 1, SCREEN_WIDTH * 3.0 / 4.0, 30.0, 48.0);
    }
}
}

void draw_text_bytes(const uint8_t* text, uint32_t len, float x, float y, float size) {
    draw_text(text, len, x, y, size);
}

Add score display in render:

void render_scores(void) {
    // Convert scores to single digits
    uint8_t score1_char = '0' + (score1 % 10);
    uint8_t score2_char = '0' + (score2 % 10);

    // Draw scores
    set_color(COLOR_PLAYER1);
    draw_text(&score1_char, 1, SCREEN_WIDTH / 4.0f, 30.0f, 48.0f);
    set_color(COLOR_PLAYER2);
    draw_text(&score2_char, 1, SCREEN_WIDTH * 3.0f / 4.0f, 30.0f, 48.0f);
}

fn drawTextBytes(text: []const u8, x: f32, y: f32, size: f32) void {
    draw_text(text.ptr, @intCast(text.len), x, y, size);
}

Add score display in render:

fn renderScores() void {
    // Convert scores to single digits
    const score1_char = '0' + @as(u8, @intCast(score1 % 10));
    const score2_char = '0' + @as(u8, @intCast(score2 % 10));

    // Draw scores
    set_color(COLOR_PLAYER1);
    draw_text(&score1_char, 1, SCREEN_WIDTH / 4.0, 30.0, 48.0);
    set_color(COLOR_PLAYER2);
    draw_text(&score2_char, 1, SCREEN_WIDTH * 3.0 / 4.0, 30.0, 48.0);
}

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn render() {
    unsafe {
        match STATE {
            GameState::Title => {
                render_court();
                render_title();
            }

            GameState::Playing => {
                render_court();
                render_scores();
                render_paddles();
                render_ball();
                render_mode_indicator();
            }

            GameState::GameOver => {
                render_court();
                render_scores();
                render_paddles();
                render_ball();
                render_game_over();
            }
        }
    }
}

fn render_title() {
    unsafe {
        set_color(COLOR_WHITE);
        draw_text_bytes(b"PADDLE", SCREEN_WIDTH / 2.0 - 100.0, 150.0, 64.0);

        if IS_TWO_PLAYER {
            draw_text_bytes(b"2 PLAYER MODE", SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
        } else {
            draw_text_bytes(b"1 PLAYER VS AI", SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
        }

        set_color(COLOR_GRAY);
        draw_text_bytes(b"Press A to Start", SCREEN_WIDTH / 2.0 - 120.0, 350.0, 24.0);
    }
}

fn render_game_over() {
    unsafe {
        // Dark overlay
        set_color(0x000000CC);
        draw_rect(SCREEN_WIDTH / 4.0, SCREEN_HEIGHT / 3.0,
                  SCREEN_WIDTH / 2.0, SCREEN_HEIGHT / 3.0);

        // Winner text
        let (text, color) = if WINNER == 1 {
            (b"PLAYER 1 WINS!" as &[u8], COLOR_PLAYER1)
        } else if IS_TWO_PLAYER {
            (b"PLAYER 2 WINS!" as &[u8], COLOR_PLAYER2)
        } else {
            (b"AI WINS!" as &[u8], COLOR_PLAYER2)
        };

        set_color(color);
        draw_text(text.as_ptr(), text.len() as u32,
                  SCREEN_WIDTH / 2.0 - 120.0, SCREEN_HEIGHT / 2.0 - 20.0, 32.0);

        set_color(COLOR_GRAY);
        draw_text_bytes(b"Press A to Play Again",
                       SCREEN_WIDTH / 2.0 - 140.0, SCREEN_HEIGHT / 2.0 + 30.0, 20.0);
    }
}

fn render_mode_indicator() {
    unsafe {
        set_color(COLOR_GRAY);
        if IS_TWO_PLAYER {
            draw_text_bytes(b"2P", 10.0, 10.0, 16.0);
        } else {
            draw_text_bytes(b"vs AI", 10.0, 10.0, 16.0);
        }
    }
}
}

NCZX_EXPORT void render(void) {
    switch (state) {
        case TITLE:
            render_court();
            render_title();
            break;

        case PLAYING:
            render_court();
            render_scores();
            render_paddles();
            render_ball();
            render_mode_indicator();
            break;

        case GAME_OVER:
            render_court();
            render_scores();
            render_paddles();
            render_ball();
            render_game_over();
            break;
    }
}

void render_title(void) {
    set_color(COLOR_WHITE);
    draw_text_bytes((const uint8_t*)"PADDLE", 6, SCREEN_WIDTH / 2.0f - 100.0f, 150.0f, 64.0f);

    if (is_two_player) {
        draw_text_bytes((const uint8_t*)"2 PLAYER MODE", 13, SCREEN_WIDTH / 2.0f - 100.0f, 250.0f, 24.0f);
    } else {
        draw_text_bytes((const uint8_t*)"1 PLAYER VS AI", 14, SCREEN_WIDTH / 2.0f - 100.0f, 250.0f, 24.0f);
    }

    set_color(COLOR_GRAY);
    draw_text_bytes((const uint8_t*)"Press A to Start", 16, SCREEN_WIDTH / 2.0f - 120.0f, 350.0f, 24.0f);
}

void render_game_over(void) {
    // Dark overlay
    set_color(0x000000CC);
    draw_rect(SCREEN_WIDTH / 4.0f, SCREEN_HEIGHT / 3.0f,
              SCREEN_WIDTH / 2.0f, SCREEN_HEIGHT / 3.0f);

    // Winner text
    const uint8_t* text;
    uint32_t text_len;
    uint32_t color;

    if (winner == 1) {
        text = (const uint8_t*)"PLAYER 1 WINS!";
        text_len = 14;
        color = COLOR_PLAYER1;
    } else if (is_two_player) {
        text = (const uint8_t*)"PLAYER 2 WINS!";
        text_len = 14;
        color = COLOR_PLAYER2;
    } else {
        text = (const uint8_t*)"AI WINS!";
        text_len = 8;
        color = COLOR_PLAYER2;
    }

    set_color(color);
    draw_text(text, text_len,
              SCREEN_WIDTH / 2.0f - 120.0f, SCREEN_HEIGHT / 2.0f - 20.0f, 32.0f);

    set_color(COLOR_GRAY);
    draw_text_bytes((const uint8_t*)"Press A to Play Again", 21,
                   SCREEN_WIDTH / 2.0f - 140.0f, SCREEN_HEIGHT / 2.0f + 30.0f, 20.0f);
}

void render_mode_indicator(void) {
    set_color(COLOR_GRAY);
    if (is_two_player) {
        draw_text_bytes((const uint8_t*)"2P", 2, 10.0f, 10.0f, 16.0f);
    } else {
        draw_text_bytes((const uint8_t*)"vs AI", 5, 10.0f, 10.0f, 16.0f);
    }
}

export fn render() void {
    switch (state) {
        .title => {
            renderCourt();
            renderTitle();
        },

        .playing => {
            renderCourt();
            renderScores();
            renderPaddles();
            renderBall();
            renderModeIndicator();
        },

        .game_over => {
            renderCourt();
            renderScores();
            renderPaddles();
            renderBall();
            renderGameOver();
        },
    }
}

fn renderTitle() void {
    set_color(COLOR_WHITE);
    drawTextBytes("PADDLE", SCREEN_WIDTH / 2.0 - 100.0, 150.0, 64.0);

    if (is_two_player) {
        drawTextBytes("2 PLAYER MODE", SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
    } else {
        drawTextBytes("1 PLAYER VS AI", SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
    }

    set_color(COLOR_GRAY);
    drawTextBytes("Press A to Start", SCREEN_WIDTH / 2.0 - 120.0, 350.0, 24.0);
}

fn renderGameOver() void {
    // Dark overlay
    set_color(0x000000CC);
    draw_rect(SCREEN_WIDTH / 4.0, SCREEN_HEIGHT / 3.0,
              SCREEN_WIDTH / 2.0, SCREEN_HEIGHT / 3.0);

    // Winner text
    const text: []const u8 = if (winner == 1)
        "PLAYER 1 WINS!"
    else if (is_two_player)
        "PLAYER 2 WINS!"
    else
        "AI WINS!";

    const color: u32 = if (winner == 1) COLOR_PLAYER1 else COLOR_PLAYER2;

    set_color(color);
    draw_text(text.ptr, @intCast(text.len),
              SCREEN_WIDTH / 2.0 - 120.0, SCREEN_HEIGHT / 2.0 - 20.0, 32.0);

    set_color(COLOR_GRAY);
    drawTextBytes("Press A to Play Again",
                 SCREEN_WIDTH / 2.0 - 140.0, SCREEN_HEIGHT / 2.0 + 30.0, 20.0);
}

fn renderModeIndicator() void {
    set_color(COLOR_GRAY);
    if (is_two_player) {
        drawTextBytes("2P", 10.0, 10.0, 16.0);
    } else {
        drawTextBytes("vs AI", 10.0, 10.0, 16.0);
    }
}

#![allow(unused)]
fn main() {
#[link(wasm_import_module = "env")]
extern "C" {
    // ... existing imports ...

    // ROM loading
    fn rom_sound(id_ptr: *const u8, id_len: u32) -> u32;

    // Audio playback
    fn play_sound(sound: u32, volume: f32, pan: f32);
}
}

// ROM loading
NCZX_IMPORT uint32_t rom_sound(const uint8_t* id_ptr, uint32_t id_len);

// Audio playback
NCZX_IMPORT void play_sound(uint32_t sound, float volume, float pan);

// ROM loading
pub extern fn rom_sound(id_ptr: [*]const u8, id_len: u32) u32;

// Audio playback
pub extern fn play_sound(sound: u32, volume: f32, pan: f32) void;

#![allow(unused)]
fn main() {
static mut SFX_HIT: u32 = 0;
static mut SFX_SCORE: u32 = 0;
static mut SFX_WIN: u32 = 0;
}

static uint32_t SFX_HIT = 0;
static uint32_t SFX_SCORE = 0;
static uint32_t SFX_WIN = 0;

var SFX_HIT: u32 = 0;
var SFX_SCORE: u32 = 0;
var SFX_WIN: u32 = 0;

#![allow(unused)]
fn main() {
#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        set_clear_color(0x1a1a2eFF);

        // Load sounds from ROM
        SFX_HIT = rom_sound(b"hit".as_ptr(), 3);
        SFX_SCORE = rom_sound(b"score".as_ptr(), 5);
        SFX_WIN = rom_sound(b"win".as_ptr(), 3);

        reset_game();
        STATE = GameState::Title;
    }
}
}

void init() {
    set_clear_color(0x1a1a2eFF);

    // Load sounds from ROM
    SFX_HIT = rom_sound("hit", 3);
    SFX_SCORE = rom_sound("score", 5);
    SFX_WIN = rom_sound("win", 3);

    reset_game();
    STATE = TITLE;
}

export fn init() void {
    set_clear_color(0x1a1a2eFF);

    // Load sounds from ROM
    SFX_HIT = rom_sound("hit", 3);
    SFX_SCORE = rom_sound("score", 5);
    SFX_WIN = rom_sound("win", 3);

    reset_game();
    STATE = .Title;
}

#![allow(unused)]
fn main() {
// In update_ball(), after wall bounce:
if BALL_Y <= 0.0 {
    BALL_Y = 0.0;
    BALL_VY = -BALL_VY;
    play_sound(SFX_HIT, 0.3, 0.0);  // Center pan
}

if BALL_Y >= SCREEN_HEIGHT - BALL_SIZE {
    BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
    BALL_VY = -BALL_VY;
    play_sound(SFX_HIT, 0.3, 0.0);
}
}

// In update_ball(), after wall bounce:
if (BALL_Y <= 0.0f) {
    BALL_Y = 0.0f;
    BALL_VY = -BALL_VY;
    play_sound(SFX_HIT, 0.3f, 0.0f);  // Center pan
}

if (BALL_Y >= SCREEN_HEIGHT - BALL_SIZE) {
    BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
    BALL_VY = -BALL_VY;
    play_sound(SFX_HIT, 0.3f, 0.0f);
}

// In update_ball(), after wall bounce:
if (BALL_Y <= 0.0) {
    BALL_Y = 0.0;
    BALL_VY = -BALL_VY;
    play_sound(SFX_HIT, 0.3, 0.0);  // Center pan
}

if (BALL_Y >= SCREEN_HEIGHT - BALL_SIZE) {
    BALL_Y = SCREEN_HEIGHT - BALL_SIZE;
    BALL_VY = -BALL_VY;
    play_sound(SFX_HIT, 0.3, 0.0);
}

#![allow(unused)]
fn main() {
// In paddle 1 collision:
play_sound(SFX_HIT, 0.5, -0.5);  // Pan left

// In paddle 2 collision:
play_sound(SFX_HIT, 0.5, 0.5);   // Pan right
}

// In paddle 1 collision:
play_sound(SFX_HIT, 0.5f, -0.5f);  // Pan left

// In paddle 2 collision:
play_sound(SFX_HIT, 0.5f, 0.5f);   // Pan right

// In paddle 1 collision:
play_sound(SFX_HIT, 0.5, -0.5);  // Pan left

// In paddle 2 collision:
play_sound(SFX_HIT, 0.5, 0.5);   // Pan right

#![allow(unused)]
fn main() {
// When player 2 scores (ball exits left):
SCORE2 += 1;
play_sound(SFX_SCORE, 0.6, 0.5);  // Pan right (scorer's side)

// When player 1 scores (ball exits right):
SCORE1 += 1;
play_sound(SFX_SCORE, 0.6, -0.5);  // Pan left (scorer's side)
}

// When player 2 scores (ball exits left):
SCORE2 += 1;
play_sound(SFX_SCORE, 0.6f, 0.5f);  // Pan right (scorer's side)

// When player 1 scores (ball exits right):
SCORE1 += 1;
play_sound(SFX_SCORE, 0.6f, -0.5f);  // Pan left (scorer's side)

// When player 2 scores (ball exits left):
SCORE2 += 1;
play_sound(SFX_SCORE, 0.6, 0.5);  // Pan right (scorer's side)

// When player 1 scores (ball exits right):
SCORE1 += 1;
play_sound(SFX_SCORE, 0.6, -0.5);  // Pan left (scorer's side)

#![allow(unused)]
fn main() {
// When either player wins:
if SCORE1 >= WIN_SCORE || SCORE2 >= WIN_SCORE {
    STATE = GameState::GameOver;
    play_sound(SFX_WIN, 0.8, 0.0);  // Center, louder
}
}

// When either player wins:
if (SCORE1 >= WIN_SCORE || SCORE2 >= WIN_SCORE) {
    STATE = GAME_OVER;
    play_sound(SFX_WIN, 0.8f, 0.0f);  // Center, louder
}

// When either player wins:
if (SCORE1 >= WIN_SCORE or SCORE2 >= WIN_SCORE) {
    STATE = .GameOver;
    play_sound(SFX_WIN, 0.8, 0.0);  // Center, louder
}

#![allow(unused)]
fn main() {
fn play_sound(sound: u32, volume: f32, pan: f32);
}

void play_sound(uint32_t sound, float volume, float pan);

pub extern fn play_sound(sound: u32, volume: f32, pan: f32) void;

#![allow(unused)]
fn main() {
#[link(wasm_import_module = "env")]
extern "C" {
    // ... existing imports ...

    // Texture loading and drawing
    fn rom_texture(id_ptr: *const u8, id_len: u32) -> u32;
    fn texture_bind(texture: u32);
    fn draw_sprite(x: f32, y: f32, w: f32, h: f32);
}
}

// Texture loading and drawing
NCZX_IMPORT uint32_t rom_texture(const uint8_t* id_ptr, uint32_t id_len);
NCZX_IMPORT void texture_bind(uint32_t texture);
NCZX_IMPORT void draw_sprite(float x, float y, float w, float h);

// Texture loading and drawing
pub extern fn rom_texture(id_ptr: [*]const u8, id_len: u32) u32;
pub extern fn texture_bind(texture: u32) void;
pub extern fn draw_sprite(x: f32, y: f32, w: f32, h: f32) void;

#![allow(unused)]
fn main() {
static mut TEX_PADDLE: u32 = 0;
static mut TEX_BALL: u32 = 0;

// In init():
TEX_PADDLE = rom_texture(b"paddle".as_ptr(), 6);
TEX_BALL = rom_texture(b"ball".as_ptr(), 4);
}

static uint32_t TEX_PADDLE = 0;
static uint32_t TEX_BALL = 0;

// In init():
TEX_PADDLE = rom_texture("paddle", 6);
TEX_BALL = rom_texture("ball", 4);

var TEX_PADDLE: u32 = 0;
var TEX_BALL: u32 = 0;

// In init():
TEX_PADDLE = rom_texture("paddle", 6);
TEX_BALL = rom_texture("ball", 4);

#![allow(unused)]
fn main() {
// Instead of: draw_rect(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT, COLOR_PLAYER1);
texture_bind(TEX_PADDLE);
draw_sprite(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT);

// Second paddle
draw_sprite(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, PADDLE2_Y, PADDLE_WIDTH, PADDLE_HEIGHT);

// Instead of: draw_rect(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE, COLOR_WHITE);
texture_bind(TEX_BALL);
draw_sprite(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE);
}

// Instead of: draw_rect(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT, COLOR_PLAYER1);
texture_bind(TEX_PADDLE);
draw_sprite(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT);

// Second paddle
draw_sprite(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, PADDLE2_Y, PADDLE_WIDTH, PADDLE_HEIGHT);

// Instead of: draw_rect(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE, COLOR_WHITE);
texture_bind(TEX_BALL);
draw_sprite(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE);

// Instead of: draw_rect(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT, COLOR_PLAYER1);
texture_bind(TEX_PADDLE);
draw_sprite(PADDLE_MARGIN, PADDLE1_Y, PADDLE_WIDTH, PADDLE_HEIGHT);

// Second paddle
draw_sprite(SCREEN_WIDTH - PADDLE_MARGIN - PADDLE_WIDTH, PADDLE2_Y, PADDLE_WIDTH, PADDLE_HEIGHT);

// Instead of: draw_rect(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE, COLOR_WHITE);
texture_bind(TEX_BALL);
draw_sprite(BALL_X, BALL_Y, BALL_SIZE, BALL_SIZE);

#![allow(unused)]
fn main() {
fn render_title() {
    unsafe {
        // Title
        set_color(COLOR_WHITE);
        draw_text_bytes(b"PADDLE", SCREEN_WIDTH / 2.0 - 100.0, 150.0, 64.0);

        // Mode indicator
        if IS_TWO_PLAYER {
            draw_text_bytes(b"2 PLAYER MODE", SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
        } else {
            draw_text_bytes(b"1 PLAYER VS AI", SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
        }

        // Start prompt
        set_color(COLOR_GRAY);
        draw_text_bytes(b"Press A to Start", SCREEN_WIDTH / 2.0 - 120.0, 350.0, 24.0);

        // Controls hint
        draw_text_bytes(b"Controls: Left Stick or D-Pad Up/Down",
                       250.0, 450.0, 18.0);
    }
}
}

void render_title() {
    // Title
    set_color(COLOR_WHITE);
    draw_text("PADDLE", 6, SCREEN_WIDTH / 2.0 - 100.0, 150.0, 64.0);

    // Mode indicator
    if (IS_TWO_PLAYER) {
        draw_text("2 PLAYER MODE", 13, SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
    } else {
        draw_text("1 PLAYER VS AI", 14, SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
    }

    // Start prompt
    set_color(COLOR_GRAY);
    draw_text("Press A to Start", 16, SCREEN_WIDTH / 2.0 - 120.0, 350.0, 24.0);

    // Controls hint
    draw_text("Controls: Left Stick or D-Pad Up/Down", 38,
              250.0, 450.0, 18.0);
}

fn render_title() void {
    // Title
    set_color(COLOR_WHITE);
    draw_text("PADDLE", "PADDLE".len, SCREEN_WIDTH / 2.0 - 100.0, 150.0, 64.0);

    // Mode indicator
    if (IS_TWO_PLAYER) {
        draw_text("2 PLAYER MODE", "2 PLAYER MODE".len, SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
    } else {
        draw_text("1 PLAYER VS AI", "1 PLAYER VS AI".len, SCREEN_WIDTH / 2.0 - 100.0, 250.0, 24.0);
    }

    // Start prompt
    set_color(COLOR_GRAY);
    draw_text("Press A to Start", "Press A to Start".len, SCREEN_WIDTH / 2.0 - 120.0, 350.0, 24.0);

    // Controls hint
    draw_text("Controls: Left Stick or D-Pad Up/Down", "Controls: Left Stick or D-Pad Up/Down".len,
              250.0, 450.0, 18.0);
}

#![allow(unused)]
fn main() {
// nether.toml: render_mode = 0

fn render() {
    // Color comes purely from texture + set_color tint
    texture_bind(sprite_tex);
    set_color(0xFFFFFFFF);
    draw_mesh(quad);
}
}

// nether.toml: render_mode = 0

NCZX_EXPORT void render(void) {
    // Color comes purely from texture + set_color tint
    texture_bind(sprite_tex);
    set_color(0xFFFFFFFF);
    draw_mesh(quad);
}

// nether.toml: render_mode = 0

export fn render() void {
    // Color comes purely from texture + set_color tint
    texture_bind(sprite_tex);
    set_color(0xFFFFFFFF);
    draw_mesh(quad);
}

#![allow(unused)]
fn main() {
// nether.toml: render_mode = 1

fn init() {
    SHADOW_MATCAP = rom_texture(b"matcap_shadow".as_ptr(), 13);
    HIGHLIGHT_MATCAP = rom_texture(b"matcap_highlight".as_ptr(), 16);
}

fn render() {
    texture_bind(character_albedo);
    matcap_set(1, SHADOW_MATCAP);
    matcap_blend_mode(1, 0); // Multiply
    matcap_set(2, HIGHLIGHT_MATCAP);
    matcap_blend_mode(2, 1); // Add
    draw_mesh(character);
}
}

// nether.toml: render_mode = 1

NCZX_EXPORT void init(void) {
    SHADOW_MATCAP = rom_texture("matcap_shadow", 13);
    HIGHLIGHT_MATCAP = rom_texture("matcap_highlight", 16);
}

NCZX_EXPORT void render(void) {
    texture_bind(character_albedo);
    matcap_set(1, SHADOW_MATCAP);
    matcap_blend_mode(1, 0); // Multiply
    matcap_set(2, HIGHLIGHT_MATCAP);
    matcap_blend_mode(2, 1); // Add
    draw_mesh(character);
}

// nether.toml: render_mode = 1

export fn init() void {
    SHADOW_MATCAP = rom_texture("matcap_shadow", 13);
    HIGHLIGHT_MATCAP = rom_texture("matcap_highlight", 16);
}

export fn render() void {
    texture_bind(character_albedo);
    matcap_set(1, SHADOW_MATCAP);
    matcap_blend_mode(1, 0); // Multiply
    matcap_set(2, HIGHLIGHT_MATCAP);
    matcap_blend_mode(2, 1); // Add
    draw_mesh(character);
}

#![allow(unused)]
fn main() {
material_metallic(0.0);    // 0 = dielectric, 1 = metal
material_roughness(0.5);   // 0 = mirror, 1 = rough
material_emissive(0.0);    // Self-illumination
material_rim(0.2, 0.15);   // Rim light intensity and power
}

material_metallic(0.0f);    // 0 = dielectric, 1 = metal
material_roughness(0.5f);   // 0 = mirror, 1 = rough
material_emissive(0.0f);    // Self-illumination
material_rim(0.2f, 0.15f);  // Rim light intensity and power

material_metallic(0.0);    // 0 = dielectric, 1 = metal
material_roughness(0.5);   // 0 = mirror, 1 = rough
material_emissive(0.0);    // Self-illumination
material_rim(0.2, 0.15);   // Rim light intensity and power

#![allow(unused)]
fn main() {
// nether.toml: render_mode = 2

fn render() {
    // Set up lighting
    light_set(0, 0.5, -0.7, 0.5);
    light_color(0, 0xFFF2E6FF);
    light_enable(0);

    // Shiny metal
    material_metallic(1.0);
    material_roughness(0.2);
    material_rim(0.1, 0.2);
    texture_bind(sword_tex);
    draw_mesh(sword);

    // Rough stone
    material_metallic(0.0);
    material_roughness(0.9);
    material_rim(0.0, 0.0);
    texture_bind(stone_tex);
    draw_mesh(wall);
}
}

// nether.toml: render_mode = 2

NCZX_EXPORT void render(void) {
    // Set up lighting
    light_set(0, 0.5f, -0.7f, 0.5f);
    light_color(0, 0xFFF2E6FF);
    light_enable(0);

    // Shiny metal
    material_metallic(1.0f);
    material_roughness(0.2f);
    material_rim(0.1f, 0.2f);
    texture_bind(sword_tex);
    draw_mesh(sword);

    // Rough stone
    material_metallic(0.0f);
    material_roughness(0.9f);
    material_rim(0.0f, 0.0f);
    texture_bind(stone_tex);
    draw_mesh(wall);
}

// nether.toml: render_mode = 2

export fn render() void {
    // Set up lighting
    light_set(0, 0.5, -0.7, 0.5);
    light_color(0, 0xFFF2E6FF);
    light_enable(0);

    // Shiny metal
    material_metallic(1.0);
    material_roughness(0.2);
    material_rim(0.1, 0.2);
    texture_bind(sword_tex);
    draw_mesh(sword);

    // Rough stone
    material_metallic(0.0);
    material_roughness(0.9);
    material_rim(0.0, 0.0);
    texture_bind(stone_tex);
    draw_mesh(wall);
}

#![allow(unused)]
fn main() {
material_shininess(0.7);           // 0-1 → maps to 1-256
material_specular(0xFFD700FF);     // Specular highlight color
material_emissive(0.0);            // Self-illumination
material_rim(0.2, 0.15);           // Rim light
}

material_shininess(0.7f);           // 0-1 → maps to 1-256
material_specular(0xFFD700FF);      // Specular highlight color
material_emissive(0.0f);            // Self-illumination
material_rim(0.2f, 0.15f);          // Rim light

material_shininess(0.7);           // 0-1 → maps to 1-256
material_specular(0xFFD700FF);     // Specular highlight color
material_emissive(0.0);            // Self-illumination
material_rim(0.2, 0.15);           // Rim light

#![allow(unused)]
fn main() {
// nether.toml: render_mode = 3

fn render() {
    // Gold armor
    set_color(0xE6B84DFF);
    material_shininess(0.8);
    material_specular(0xFFD700FF);
    material_rim(0.2, 0.15);
    draw_mesh(armor);

    // Wet skin
    set_color(0xD9B399FF);
    material_shininess(0.7);
    material_specular(0xFFFFFFFF);
    material_rim(0.3, 0.25);
    draw_mesh(character);
}
}

// nether.toml: render_mode = 3

NCZX_EXPORT void render(void) {
    // Gold armor
    set_color(0xE6B84DFF);
    material_shininess(0.8f);
    material_specular(0xFFD700FF);
    material_rim(0.2f, 0.15f);
    draw_mesh(armor);

    // Wet skin
    set_color(0xD9B399FF);
    material_shininess(0.7f);
    material_specular(0xFFFFFFFF);
    material_rim(0.3f, 0.25f);
    draw_mesh(character);
}

// nether.toml: render_mode = 3

export fn render() void {
    // Gold armor
    set_color(0xE6B84DFF);
    material_shininess(0.8);
    material_specular(0xFFD700FF);
    material_rim(0.2, 0.15);
    draw_mesh(armor);

    // Wet skin
    set_color(0xD9B399FF);
    material_shininess(0.7);
    material_specular(0xFFFFFFFF);
    material_rim(0.3, 0.25);
    draw_mesh(character);
}

#![allow(unused)]
fn main() {
// nether.toml: render_mode = 1, 2, or 3

// 8 x [hi, lo] = 128 bytes (16 x u64).
// For presets and packing helpers, see `examples/3-inspectors/epu-showcase/`.
static ENV: [[u64; 2]; 8] = [
    [0, 0], [0, 0], [0, 0], [0, 0],
    [0, 0], [0, 0], [0, 0], [0, 0],
];

fn render() {
    // Set environment config.
    unsafe { epu_set(ENV.as_ptr().cast()); }

    // Main directional light
    light_set(0, 0.5, -0.7, 0.5);
    light_color(0, 0xFFF2E6FF);
    light_intensity(0, 1.0);
    light_enable(0);

    // Fill light
    light_set(1, -0.8, -0.3, 0.0);
    light_color(1, 0x8899BBFF);
    light_intensity(1, 0.3);
    light_enable(1);

    // Draw scene...

    // Draw environment background last (fills only background pixels).
    unsafe { draw_epu(); }
}
}

// nether.toml: render_mode = 1, 2, or 3

static const uint64_t env_config[16] = {
    /* hi0, lo0, hi1, lo1, ... */
};

NCZX_EXPORT void render(void) {
    epu_set(env_config);  // Set environment config

    // Main directional light
    light_set(0, 0.5f, -0.7f, 0.5f);
    light_color(0, 0xFFF2E6FF);
    light_intensity(0, 1.0f);
    light_enable(0);

    // Fill light
    light_set(1, -0.8f, -0.3f, 0.0f);
    light_color(1, 0x8899BBFF);
    light_intensity(1, 0.3f);
    light_enable(1);

    // Draw scene...

    // Draw environment background last (fills only background pixels).
    draw_epu();
}

// nether.toml: render_mode = 1, 2, or 3

const env_config: [16]u64 = .{
    // hi0, lo0, hi1, lo1, ...
};

export fn render() void {
    epu_set(&env_config);  // Set environment config

    // Main directional light
    light_set(0, 0.5, -0.7, 0.5);
    light_color(0, 0xFFF2E6FF);
    light_intensity(0, 1.0);
    light_enable(0);

    // Fill light
    light_set(1, -0.8, -0.3, 0.0);
    light_color(1, 0x8899BBFF);
    light_intensity(1, 0.3);
    light_enable(1);

    // Draw scene...

    // Draw environment background last (fills only background pixels).
    draw_epu();
}

// 8 x [hi, lo]
static ENV: [[u64; 2]; 8] = [
    [0, 0], [0, 0], [0, 0], [0, 0],
    [0, 0], [0, 0], [0, 0], [0, 0],
];

fn render() {
    unsafe {
        epu_set(ENV.as_ptr().cast()); // Set environment config
        // ... draw scene geometry
        draw_epu(); // Draw environment background
    }
}

static const uint64_t env_config[16] = {
    /* hi0, lo0, hi1, lo1, ... */
};

void render(void) {
    epu_set(env_config);  // Set environment config
    // ... draw scene geometry
    draw_epu();           // Draw environment background
}

const env_config: [16]u64 = .{
    // hi0, lo0, hi1, lo1, ...
};

export fn render() void {
    epu_set(&env_config);  // Set environment config
    // ... draw scene geometry
    draw_epu();            // Draw environment background
}

#![allow(unused)]
fn main() {
// GOOD - Deterministic
let spawn_x = (random() % 320) as f32;
let damage = 10 + (random() % 5) as i32;

// BAD - Non-deterministic
let spawn_x = system_time_nanos() % 320;  // Different on each client!
let damage = 10 + (thread_rng().next_u32() % 5); // Different seeds!
}

// GOOD - Deterministic
float spawn_x = (float)(random_u32() % 320);
int32_t damage = 10 + (int32_t)(random_u32() % 5);

// BAD - Non-deterministic
float spawn_x = (float)(time(NULL) % 320);  // Different on each client!
int32_t damage = 10 + (rand() % 5); // Different seeds!

// GOOD - Deterministic
const spawn_x: f32 = @floatFromInt(random_u32() % 320);
const damage: i32 = 10 + @intCast(random_u32() % 5);

// BAD - Non-deterministic
const spawn_x: f32 = @floatFromInt(std.time.nanoTimestamp() % 320);  // Different on each client!
const damage: i32 = 10 + @intCast(rand.next() % 5); // Different seeds!

#![allow(unused)]
fn main() {
// GOOD - State in WASM memory (snapshotted)
static mut PLAYER_X: f32 = 0.0;
static mut ENEMIES: [Enemy; 10] = [Enemy::new(); 10];

// BAD - State outside WASM memory
// (external systems, thread-locals, etc. are not snapshotted)
}

// GOOD - State in WASM memory (snapshotted)
static float player_x = 0.0f;
static Enemy enemies[10] = {0};

// BAD - State outside WASM memory
// (external systems, thread-locals, etc. are not snapshotted)

// GOOD - State in WASM memory (snapshotted)
var player_x: f32 = 0.0;
var enemies: [10]Enemy = [_]Enemy{Enemy{}} ** 10;

// BAD - State outside WASM memory
// (external systems, thread-locals, etc. are not snapshotted)

#![allow(unused)]
fn main() {
fn update() {
    // All calculations based only on:
    // - Current state (in WASM memory)
    // - Player inputs (from GGRS)
    // - delta_time() / elapsed_time() / tick_count() (synchronized)
    // - random() (synchronized)

    let dt = delta_time();
    for p in 0..player_count() {
        if button_pressed(p, BUTTON_A) != 0 {
            players[p].jump();
        }
        players[p].x += left_stick_x(p) * SPEED * dt;
    }
}
}

NCZX_EXPORT void update(void) {
    // All calculations based only on:
    // - Current state (in WASM memory)
    // - Player inputs (from GGRS)
    // - delta_time() / elapsed_time() / tick_count() (synchronized)
    // - random_u32() (synchronized)

    float dt = delta_time();
    for (uint32_t p = 0; p < player_count(); p++) {
        if (button_pressed(p, NCZX_BUTTON_A) != 0) {
            player_jump(&players[p]);
        }
        players[p].x += left_stick_x(p) * SPEED * dt;
    }
}

export fn update() void {
    // All calculations based only on:
    // - Current state (in WASM memory)
    // - Player inputs (from GGRS)
    // - delta_time() / elapsed_time() / tick_count() (synchronized)
    // - random_u32() (synchronized)

    const dt = delta_time();
    var p: u32 = 0;
    while (p < player_count()) : (p += 1) {
        if (button_pressed(p, Button.a) != 0) {
            players[p].jump();
        }
        players[p].x += left_stick_x(p) * SPEED * dt;
    }
}

#![allow(unused)]
fn main() {
// GOOD - Logic in update()
fn update() {
    ANIMATION_FRAME = (tick_count() as u32 / 6) % 4;
}

fn render() {
    // Just draw, no state changes
    draw_sprite_region(..., ANIMATION_FRAME as f32 * 32.0, ...);
}

// BAD - Logic in render()
fn render() {
    ANIMATION_FRAME += 1;  // Skipped during rollback = desynced!
    draw_sprite_region(...);
}
}

// GOOD - Logic in update()
NCZX_EXPORT void update(void) {
    animation_frame = (tick_count() / 6) % 4;
}

NCZX_EXPORT void render(void) {
    // Just draw, no state changes
    draw_sprite_region(..., (float)animation_frame * 32.0f, ...);
}

// BAD - Logic in render()
NCZX_EXPORT void render(void) {
    animation_frame++;  // Skipped during rollback = desynced!
    draw_sprite_region(...);
}

// GOOD - Logic in update()
export fn update() void {
    animation_frame = (tick_count() / 6) % 4;
}

export fn render() void {
    // Just draw, no state changes
    draw_sprite_region(..., @as(f32, @floatFromInt(animation_frame)) * 32.0, ...);
}

// BAD - Logic in render()
export fn render() void {
    animation_frame += 1;  // Skipped during rollback = desynced!
    draw_sprite_region(...);
}

#![allow(unused)]
fn main() {
// Potentially problematic
let angle = (y / x).atan();  // atan can differ slightly

// Safer alternatives
// - Use integer math where possible
// - Use lookup tables for trig
// - Accept small visual differences (for rendering only)
}

// Potentially problematic
float angle = atanf(y / x);  // atan can differ slightly

// Safer alternatives
// - Use integer math where possible
// - Use lookup tables for trig
// - Accept small visual differences (for rendering only)

// Potentially problematic
const angle = std.math.atan(y / x);  // atan can differ slightly

// Safer alternatives
// - Use integer math where possible
// - Use lookup tables for trig
// - Accept small visual differences (for rendering only)

#![allow(unused)]
fn main() {
// BAD - Non-deterministic order
for (id, enemy) in enemies.iter() {
    enemy.update();  // Order matters for collisions!
}

// GOOD - Fixed order
for i in 0..enemies.len() {
    enemies[i].update();
}
}

// BAD - Non-deterministic order
// (using a hash map or unordered container)

// GOOD - Fixed order
for (size_t i = 0; i < enemy_count; i++) {
    enemy_update(&enemies[i]);
}

// BAD - Non-deterministic order
// (using a hash map)

// GOOD - Fixed order
var i: usize = 0;
while (i < enemies.len) : (i += 1) {
    enemies[i].update();
}

#![allow(unused)]
fn main() {
// BAD
let now = SystemTime::now();  // Different on each client
let file = read_file("data.txt");  // Files can differ
let response = http_get("api.com");  // Network varies

// GOOD - All data from ROM or synchronized state
let data = rom_data(b"level".as_ptr(), 5, ...);
}

// BAD
time_t now = time(NULL);  // Different on each client
// Reading files or network requests  // Can differ

// GOOD - All data from ROM or synchronized state
uint32_t data = rom_data((uint32_t)"level", 5, ...);

// BAD
const now = std.time.timestamp();  // Different on each client
// Reading files or network requests  // Can differ

// GOOD - All data from ROM or synchronized state
const data = rom_data("level".ptr, 5, ...);

#![allow(unused)]
fn main() {
fn update() {
    // Core gameplay - must be deterministic
    if player_hit_enemy() {
        ENEMY_HEALTH -= DAMAGE;

        // Audio/VFX triggers are fine here
        // (they'll replay during rollback, but that's OK)
        play_sound(HIT_SFX, 1.0, 0.0);
    }
}

fn render() {
    // Visual-only effects
    spawn_particles(PLAYER_X, PLAYER_Y);  // Not critical
}
}

NCZX_EXPORT void update(void) {
    // Core gameplay - must be deterministic
    if (player_hit_enemy()) {
        enemy_health -= DAMAGE;

        // Audio/VFX triggers are fine here
        // (they'll replay during rollback, but that's OK)
        play_sound(HIT_SFX, 1.0f, 0.0f);
    }
}

NCZX_EXPORT void render(void) {
    // Visual-only effects
    spawn_particles(player_x, player_y);  // Not critical
}

export fn update() void {
    // Core gameplay - must be deterministic
    if (player_hit_enemy()) {
        enemy_health -= DAMAGE;

        // Audio/VFX triggers are fine here
        // (they'll replay during rollback, but that's OK)
        play_sound(HIT_SFX, 1.0, 0.0);
    }
}

export fn render() void {
    // Visual-only effects
    spawn_particles(player_x, player_y);  // Not critical
}

#![allow(unused)]
fn main() {
fn update() {
    // After each update, log state hash
    let hash = calculate_state_hash();
    log_fmt(b"Tick {} hash: {}", tick_count(), hash);
}
}

NCZX_EXPORT void update(void) {
    // After each update, log state hash
    uint32_t hash = calculate_state_hash();
    log_fmt((uint32_t)"Tick %u hash: %u", tick_count(), hash);
}

export fn update() void {
    // After each update, log state hash
    const hash = calculate_state_hash();
    log_fmt("Tick {} hash: {}", .{tick_count(), hash});
}

#![allow(unused)]
fn main() {
static mut ENEMIES: [Enemy; 10] = [Enemy::new(); 10];
static mut ENEMY_COUNT: usize = 0;

#[derive(Clone, Copy)]
struct Enemy {
    x: f32,
    y: f32,
    health: i32,
    ai_state: u8,
    ai_timer: u32,
}

impl Enemy {
    const fn new() -> Self {
        Self { x: 0.0, y: 0.0, health: 100, ai_state: 0, ai_timer: 0 }
    }

    fn update(&mut self, player_x: f32, player_y: f32) {
        match self.ai_state {
            0 => {
                // Idle - random chance to start patrol
                if random() % 100 < 5 {  // 5% chance per tick
                    self.ai_state = 1;
                    self.ai_timer = 60 + (random() % 60);  // 1-2 seconds
                }
            }
            1 => {
                // Patrol - move toward random target
                self.ai_timer -= 1;
                if self.ai_timer == 0 {
                    self.ai_state = 0;
                }
                // Movement...
            }
            _ => {}
        }
    }
}

fn update() {
    unsafe {
        let px = PLAYER_X;
        let py = PLAYER_Y;

        // Fixed iteration order
        for i in 0..ENEMY_COUNT {
            ENEMIES[i].update(px, py);
        }
    }
}
}

typedef struct {
    float x;
    float y;
    int32_t health;
    uint8_t ai_state;
    uint32_t ai_timer;
} Enemy;

static Enemy enemies[10] = {0};
static size_t enemy_count = 0;

void enemy_update(Enemy* enemy, float player_x, float player_y) {
    switch (enemy->ai_state) {
        case 0:
            // Idle - random chance to start patrol
            if (random_u32() % 100 < 5) {  // 5% chance per tick
                enemy->ai_state = 1;
                enemy->ai_timer = 60 + (random_u32() % 60);  // 1-2 seconds
            }
            break;
        case 1:
            // Patrol - move toward random target
            enemy->ai_timer--;
            if (enemy->ai_timer == 0) {
                enemy->ai_state = 0;
            }
            // Movement...
            break;
    }
}

NCZX_EXPORT void update(void) {
    float px = player_x;
    float py = player_y;

    // Fixed iteration order
    for (size_t i = 0; i < enemy_count; i++) {
        enemy_update(&enemies[i], px, py);
    }
}

const Enemy = struct {
    x: f32 = 0.0,
    y: f32 = 0.0,
    health: i32 = 100,
    ai_state: u8 = 0,
    ai_timer: u32 = 0,

    pub fn update(self: *Enemy, player_x: f32, player_y: f32) void {
        switch (self.ai_state) {
            0 => {
                // Idle - random chance to start patrol
                if (random_u32() % 100 < 5) {  // 5% chance per tick
                    self.ai_state = 1;
                    self.ai_timer = 60 + (random_u32() % 60);  // 1-2 seconds
                }
            },
            1 => {
                // Patrol - move toward random target
                self.ai_timer -= 1;
                if (self.ai_timer == 0) {
                    self.ai_state = 0;
                }
                // Movement...
            },
            else => {},
        }
    }
};

var enemies: [10]Enemy = [_]Enemy{Enemy{}} ** 10;
var enemy_count: usize = 0;

export fn update() void {
    const px = player_x;
    const py = player_y;

    // Fixed iteration order
    var i: usize = 0;
    while (i < enemy_count) : (i += 1) {
        enemies[i].update(px, py);
    }
}

#![allow(unused)]
fn main() {
static PLAYER_MESH: &[u8] = include_bytes!("assets/player.nczxmesh");
static GRASS_TEX: &[u8] = include_bytes!("assets/grass.nczxtex");

fn init() {
    let player = load_zmesh(PLAYER_MESH.as_ptr() as u32, PLAYER_MESH.len() as u32);
    let grass = load_ztex(GRASS_TEX.as_ptr() as u32, GRASS_TEX.len() as u32);
}
}

// Embed assets at compile time (platform-specific)
extern const unsigned char player_nczxmesh_data[];
extern const unsigned int player_nczxmesh_size;
extern const unsigned char grass_nczxtex_data[];
extern const unsigned int grass_nczxtex_size;

NCZX_EXPORT void init(void) {
    uint32_t player = load_zmesh((uint32_t)player_nczxmesh_data, player_nczxmesh_size);
    uint32_t grass = load_ztex((uint32_t)grass_nczxtex_data, grass_nczxtex_size);
}

const player_mesh = @embedFile("assets/player.nczxmesh");
const grass_tex = @embedFile("assets/grass.nczxtex");

export fn init() void {
    const player = load_zmesh(@intFromPtr(player_mesh.ptr), player_mesh.len);
    const grass = load_ztex(@intFromPtr(grass_tex.ptr), grass_tex.len);
}

#![allow(unused)]
fn main() {
const FORMAT_UV: u8 = 1;      // Texture coordinates
const FORMAT_COLOR: u8 = 2;   // Per-vertex color
const FORMAT_NORMAL: u8 = 4;  // Surface normals
const FORMAT_SKINNED: u8 = 8; // Bone weights for skeletal animation
}

#define FORMAT_UV      1   // Texture coordinates
#define FORMAT_COLOR   2   // Per-vertex color
#define FORMAT_NORMAL  4   // Surface normals
#define FORMAT_SKINNED 8   // Bone weights for skeletal animation

const FORMAT_UV: u8 = 1;      // Texture coordinates
const FORMAT_COLOR: u8 = 2;   // Per-vertex color
const FORMAT_NORMAL: u8 = 4;  // Surface normals
const FORMAT_SKINNED: u8 = 8; // Bone weights for skeletal animation

#![allow(unused)]
fn main() {
// FFI declarations
extern "C" {
    fn load_zmesh(data_ptr: u32, data_len: u32) -> u32;
    fn load_ztex(data_ptr: u32, data_len: u32) -> u32;
    fn load_zsound(data_ptr: u32, data_len: u32) -> u32;
}

// Embed assets at compile time
static PLAYER_MESH: &[u8] = include_bytes!("assets/player.nczxmesh");
static GRASS_TEX: &[u8] = include_bytes!("assets/grass.nczxtex");
static JUMP_SFX: &[u8] = include_bytes!("assets/jump.nczxsnd");

fn init() {
    let player = load_zmesh(PLAYER_MESH.as_ptr() as u32, PLAYER_MESH.len() as u32);
    let grass = load_ztex(GRASS_TEX.as_ptr() as u32, GRASS_TEX.len() as u32);
    let jump = load_zsound(JUMP_SFX.as_ptr() as u32, JUMP_SFX.len() as u32);
}
}

// FFI declarations
NCZX_IMPORT uint32_t load_zmesh(uint32_t data_ptr, uint32_t data_len);
NCZX_IMPORT uint32_t load_ztex(uint32_t data_ptr, uint32_t data_len);
NCZX_IMPORT uint32_t load_zsound(uint32_t data_ptr, uint32_t data_len);

// Embed assets at compile time (platform-specific)
extern const unsigned char player_nczxmesh_data[];
extern const unsigned int player_nczxmesh_size;
extern const unsigned char grass_nczxtex_data[];
extern const unsigned int grass_nczxtex_size;
extern const unsigned char jump_nczxsnd_data[];
extern const unsigned int jump_nczxsnd_size;

NCZX_EXPORT void init(void) {
    uint32_t player = load_zmesh((uint32_t)player_nczxmesh_data, player_nczxmesh_size);
    uint32_t grass = load_ztex((uint32_t)grass_nczxtex_data, grass_nczxtex_size);
    uint32_t jump = load_zsound((uint32_t)jump_nczxsnd_data, jump_nczxsnd_size);
}

// FFI declarations
pub extern fn load_zmesh(data_ptr: u32, data_len: u32) u32;
pub extern fn load_ztex(data_ptr: u32, data_len: u32) u32;
pub extern fn load_zsound(data_ptr: u32, data_len: u32) u32;

// Embed assets at compile time
const player_mesh = @embedFile("assets/player.nczxmesh");
const grass_tex = @embedFile("assets/grass.nczxtex");
const jump_sfx = @embedFile("assets/jump.nczxsnd");

export fn init() void {
    const player = load_zmesh(@intFromPtr(player_mesh.ptr), player_mesh.len);
    const grass = load_ztex(@intFromPtr(grass_tex.ptr), grass_tex.len);
    const jump = load_zsound(@intFromPtr(jump_sfx.ptr), jump_sfx.len);
}

#![allow(unused)]
fn main() {
extern "C" {
    fn load_mesh(data_ptr: u32, vertex_count: u32, format: u8) -> u32;
    fn load_mesh_indexed(data_ptr: u32, vertex_count: u32, index_ptr: u32, index_count: u32, format: u8) -> u32;
}
}

NCZX_IMPORT uint32_t load_mesh(uint32_t data_ptr, uint32_t vertex_count, uint8_t format);
NCZX_IMPORT uint32_t load_mesh_indexed(uint32_t data_ptr, uint32_t vertex_count, uint32_t index_ptr, uint32_t index_count, uint8_t format);

pub extern fn load_mesh(data_ptr: u32, vertex_count: u32, format: u8) u32;
pub extern fn load_mesh_indexed(data_ptr: u32, vertex_count: u32, index_ptr: u32, index_count: u32, format: u8) u32;

#![allow(unused)]
fn main() {
extern "C" {
    fn load_mesh_packed(data_ptr: u32, vertex_count: u32, format: u8) -> u32;
    fn load_mesh_indexed_packed(data_ptr: u32, vertex_count: u32, index_ptr: u32, index_count: u32, format: u8) -> u32;
}
}

NCZX_IMPORT uint32_t load_mesh_packed(uint32_t data_ptr, uint32_t vertex_count, uint8_t format);
NCZX_IMPORT uint32_t load_mesh_indexed_packed(uint32_t data_ptr, uint32_t vertex_count, uint32_t index_ptr, uint32_t index_count, uint8_t format);

pub extern fn load_mesh_packed(data_ptr: u32, vertex_count: u32, format: u8) u32;
pub extern fn load_mesh_indexed_packed(data_ptr: u32, vertex_count: u32, index_ptr: u32, index_count: u32, format: u8) u32;

#![allow(unused)]
fn main() {
const CHECKERBOARD: [u8; 256] = {
    let mut pixels = [0u8; 256];
    let white = [0xFF, 0xFF, 0xFF, 0xFF];
    let gray = [0x88, 0x88, 0x88, 0xFF];
    let mut y = 0;
    while y < 8 {
        let mut x = 0;
        while x < 8 {
            let idx = (y * 8 + x) * 4;
            let color = if (x + y) % 2 == 0 { white } else { gray };
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
            x += 1;
        }
        y += 1;
    }
    pixels
};
}

static const uint8_t CHECKERBOARD[256] = {
    0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,
    0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,
    0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,
    0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,
    0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,  0x88, 0x88, 0x88, 0xFF,  0xFF, 0xFF, 0xFF, 0xFF,
};

const CHECKERBOARD: [256]u8 = blk: {
    var pixels: [256]u8 = undefined;
    const white = [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };
    const gray = [4]u8{ 0x88, 0x88, 0x88, 0xFF };
    var y: usize = 0;
    while (y < 8) : (y += 1) {
        var x: usize = 0;
        while (x < 8) : (x += 1) {
            const idx = (y * 8 + x) * 4;
            const color = if ((x + y) % 2 == 0) white else gray;
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
        }
    }
    break :blk pixels;
};

#![allow(unused)]
fn main() {
const PLAYER_SPRITE: [u8; 256] = {
    let mut pixels = [0u8; 256];
    let white = [0xFF, 0xFF, 0xFF, 0xFF];
    let trans = [0x00, 0x00, 0x00, 0x00];
    let pattern: [[u8; 8]; 8] = [
        [0, 0, 1, 1, 1, 1, 0, 0],
        [0, 1, 1, 1, 1, 1, 1, 0],
        [0, 1, 1, 1, 1, 1, 1, 0],
        [0, 0, 1, 1, 1, 1, 0, 0],
        [0, 1, 1, 1, 1, 1, 1, 0],
        [1, 1, 1, 1, 1, 1, 1, 1],
        [0, 0, 1, 0, 0, 1, 0, 0],
        [0, 0, 1, 0, 0, 1, 0, 0],
    ];
    let mut y = 0;
    while y < 8 {
        let mut x = 0;
        while x < 8 {
            let idx = (y * 8 + x) * 4;
            let color = if pattern[y][x] == 1 { white } else { trans };
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
            x += 1;
        }
        y += 1;
    }
    pixels
};
}

static void generate_player_sprite(uint8_t pixels[256]) {
    const uint8_t white[4] = {0xFF, 0xFF, 0xFF, 0xFF};
    const uint8_t trans[4] = {0x00, 0x00, 0x00, 0x00};
    const uint8_t pattern[8][8] = {
        {0, 0, 1, 1, 1, 1, 0, 0},
        {0, 1, 1, 1, 1, 1, 1, 0},
        {0, 1, 1, 1, 1, 1, 1, 0},
        {0, 0, 1, 1, 1, 1, 0, 0},
        {0, 1, 1, 1, 1, 1, 1, 0},
        {1, 1, 1, 1, 1, 1, 1, 1},
        {0, 0, 1, 0, 0, 1, 0, 0},
        {0, 0, 1, 0, 0, 1, 0, 0},
    };
    for (int y = 0; y < 8; y++) {
        for (int x = 0; x < 8; x++) {
            int idx = (y * 8 + x) * 4;
            const uint8_t *color = pattern[y][x] == 1 ? white : trans;
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
        }
    }
}

const PLAYER_SPRITE: [256]u8 = blk: {
    var pixels: [256]u8 = undefined;
    const white = [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };
    const trans = [4]u8{ 0x00, 0x00, 0x00, 0x00 };
    const pattern = [8][8]u8{
        .{ 0, 0, 1, 1, 1, 1, 0, 0 },
        .{ 0, 1, 1, 1, 1, 1, 1, 0 },
        .{ 0, 1, 1, 1, 1, 1, 1, 0 },
        .{ 0, 0, 1, 1, 1, 1, 0, 0 },
        .{ 0, 1, 1, 1, 1, 1, 1, 0 },
        .{ 1, 1, 1, 1, 1, 1, 1, 1 },
        .{ 0, 0, 1, 0, 0, 1, 0, 0 },
        .{ 0, 0, 1, 0, 0, 1, 0, 0 },
    };
    var y: usize = 0;
    while (y < 8) : (y += 1) {
        var x: usize = 0;
        while (x < 8) : (x += 1) {
            const idx = (y * 8 + x) * 4;
            const color = if (pattern[y][x] == 1) white else trans;
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
        }
    }
    break :blk pixels;
};

#![allow(unused)]
fn main() {
const COIN_SPRITE: [u8; 256] = {
    let mut pixels = [0u8; 256];
    let gold = [0xFF, 0xD7, 0x00, 0xFF];
    let shine = [0xFF, 0xFF, 0x88, 0xFF];
    let trans = [0x00, 0x00, 0x00, 0x00];
    let pattern: [[u8; 8]; 8] = [
        [0, 0, 1, 1, 1, 1, 0, 0],
        [0, 1, 2, 2, 1, 1, 1, 0],
        [1, 2, 2, 1, 1, 1, 1, 1],
        [1, 2, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1],
        [0, 1, 1, 1, 1, 1, 1, 0],
        [0, 0, 1, 1, 1, 1, 0, 0],
    ];
    let mut y = 0;
    while y < 8 {
        let mut x = 0;
        while x < 8 {
            let idx = (y * 8 + x) * 4;
            let color = match pattern[y][x] {
                0 => trans, 1 => gold, _ => shine,
            };
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
            x += 1;
        }
        y += 1;
    }
    pixels
};
}

static void generate_coin_sprite(uint8_t pixels[256]) {
    const uint8_t gold[4] = {0xFF, 0xD7, 0x00, 0xFF};
    const uint8_t shine[4] = {0xFF, 0xFF, 0x88, 0xFF};
    const uint8_t trans[4] = {0x00, 0x00, 0x00, 0x00};
    const uint8_t pattern[8][8] = {
        {0, 0, 1, 1, 1, 1, 0, 0},
        {0, 1, 2, 2, 1, 1, 1, 0},
        {1, 2, 2, 1, 1, 1, 1, 1},
        {1, 2, 1, 1, 1, 1, 1, 1},
        {1, 1, 1, 1, 1, 1, 1, 1},
        {1, 1, 1, 1, 1, 1, 1, 1},
        {0, 1, 1, 1, 1, 1, 1, 0},
        {0, 0, 1, 1, 1, 1, 0, 0},
    };
    for (int y = 0; y < 8; y++) {
        for (int x = 0; x < 8; x++) {
            int idx = (y * 8 + x) * 4;
            const uint8_t *color = (pattern[y][x] == 0) ? trans : (pattern[y][x] == 1) ? gold : shine;
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
        }
    }
}

const COIN_SPRITE: [256]u8 = blk: {
    var pixels: [256]u8 = undefined;
    const gold = [4]u8{ 0xFF, 0xD7, 0x00, 0xFF };
    const shine = [4]u8{ 0xFF, 0xFF, 0x88, 0xFF };
    const trans = [4]u8{ 0x00, 0x00, 0x00, 0x00 };
    const pattern = [8][8]u8{
        .{ 0, 0, 1, 1, 1, 1, 0, 0 },
        .{ 0, 1, 2, 2, 1, 1, 1, 0 },
        .{ 1, 2, 2, 1, 1, 1, 1, 1 },
        .{ 1, 2, 1, 1, 1, 1, 1, 1 },
        .{ 1, 1, 1, 1, 1, 1, 1, 1 },
        .{ 1, 1, 1, 1, 1, 1, 1, 1 },
        .{ 0, 1, 1, 1, 1, 1, 1, 0 },
        .{ 0, 0, 1, 1, 1, 1, 0, 0 },
    };
    var y: usize = 0;
    while (y < 8) : (y += 1) {
        var x: usize = 0;
        while (x < 8) : (x += 1) {
            const idx = (y * 8 + x) * 4;
            const color = if (pattern[y][x] == 0) trans else if (pattern[y][x] == 1) gold else shine;
            pixels[idx] = color[0];
            pixels[idx + 1] = color[1];
            pixels[idx + 2] = color[2];
            pixels[idx + 3] = color[3];
        }
    }
    break :blk pixels;
};

#![allow(unused)]
fn main() {
fn generate_beep() -> [i16; 2205] {
    let mut samples = [0i16; 2205]; // 0.1 sec @ 22050 Hz
    for i in 0..2205 {
        let t = i as f32 / 22050.0;
        let envelope = 1.0 - (i as f32 / 2205.0);
        let value = libm::sinf(2.0 * core::f32::consts::PI * 440.0 * t) * envelope;
        samples[i] = (value * 32767.0 * 0.3) as i16;
    }
    samples
}
}

#include <math.h>

void generate_beep(int16_t samples[2205]) {
    for (int i = 0; i < 2205; i++) {
        float t = (float)i / 22050.0f;
        float envelope = 1.0f - ((float)i / 2205.0f);
        float value = sinf(2.0f * 3.14159265f * 440.0f * t) * envelope;
        samples[i] = (int16_t)(value * 32767.0f * 0.3f);
    }
}

fn generate_beep() [2205]i16 {
    var samples: [2205]i16 = undefined;
    for (0..2205) |i| {
        const t = @as(f32, @floatFromInt(i)) / 22050.0;
        const envelope = 1.0 - (@as(f32, @floatFromInt(i)) / 2205.0);
        const value = @sin(2.0 * std.math.pi * 440.0 * t) * envelope;
        samples[i] = @intFromFloat(value * 32767.0 * 0.3);
    }
    return samples;
}

#![allow(unused)]
fn main() {
fn generate_jump() -> [i16; 4410] {
    let mut samples = [0i16; 4410]; // 0.2 sec
    for i in 0..4410 {
        let t = i as f32 / 22050.0;
        let progress = i as f32 / 4410.0;
        let freq = 200.0 + (400.0 * progress); // 200 → 600 Hz
        let envelope = 1.0 - progress;
        let value = libm::sinf(2.0 * core::f32::consts::PI * freq * t) * envelope;
        samples[i] = (value * 32767.0 * 0.3) as i16;
    }
    samples
}
}

void generate_jump(int16_t samples[4410]) {
    for (int i = 0; i < 4410; i++) {
        float t = (float)i / 22050.0f;
        float progress = (float)i / 4410.0f;
        float freq = 200.0f + (400.0f * progress); // 200 → 600 Hz
        float envelope = 1.0f - progress;
        float value = sinf(2.0f * 3.14159265f * freq * t) * envelope;
        samples[i] = (int16_t)(value * 32767.0f * 0.3f);
    }
}

fn generate_jump() [4410]i16 {
    var samples: [4410]i16 = undefined;
    for (0..4410) |i| {
        const t = @as(f32, @floatFromInt(i)) / 22050.0;
        const progress = @as(f32, @floatFromInt(i)) / 4410.0;
        const freq = 200.0 + (400.0 * progress); // 200 → 600 Hz
        const envelope = 1.0 - progress;
        const value = @sin(2.0 * std.math.pi * freq * t) * envelope;
        samples[i] = @intFromFloat(value * 32767.0 * 0.3);
    }
    return samples;
}

#![allow(unused)]
fn main() {
fn generate_collect() -> [i16; 6615] {
    let mut samples = [0i16; 6615]; // 0.3 sec
    for i in 0..6615 {
        let t = i as f32 / 22050.0;
        let progress = i as f32 / 6615.0;
        // Two frequencies for shimmer effect
        let f1 = 880.0;
        let f2 = 1320.0; // Perfect fifth
        let envelope = 1.0 - progress;
        let v1 = libm::sinf(2.0 * core::f32::consts::PI * f1 * t);
        let v2 = libm::sinf(2.0 * core::f32::consts::PI * f2 * t);
        let value = (v1 + v2 * 0.5) * envelope;
        samples[i] = (value * 32767.0 * 0.2) as i16;
    }
    samples
}
}

void generate_collect(int16_t samples[6615]) {
    for (int i = 0; i < 6615; i++) {
        float t = (float)i / 22050.0f;
        float progress = (float)i / 6615.0f;
        // Two frequencies for shimmer effect
        float f1 = 880.0f;
        float f2 = 1320.0f; // Perfect fifth
        float envelope = 1.0f - progress;
        float v1 = sinf(2.0f * 3.14159265f * f1 * t);
        float v2 = sinf(2.0f * 3.14159265f * f2 * t);
        float value = (v1 + v2 * 0.5f) * envelope;
        samples[i] = (int16_t)(value * 32767.0f * 0.2f);
    }
}

fn generate_collect() [6615]i16 {
    var samples: [6615]i16 = undefined;
    for (0..6615) |i| {
        const t = @as(f32, @floatFromInt(i)) / 22050.0;
        const progress = @as(f32, @floatFromInt(i)) / 6615.0;
        // Two frequencies for shimmer effect
        const f1 = 880.0;
        const f2 = 1320.0; // Perfect fifth
        const envelope = 1.0 - progress;
        const v1 = @sin(2.0 * std.math.pi * f1 * t);
        const v2 = @sin(2.0 * std.math.pi * f2 * t);
        const value = (v1 + v2 * 0.5) * envelope;
        samples[i] = @intFromFloat(value * 32767.0 * 0.2);
    }
    return samples;
}

#![allow(unused)]
fn main() {
static mut PLAYER_TEX: u32 = 0;
static mut JUMP_SFX: u32 = 0;

#[no_mangle]
pub extern "C" fn init() {
    unsafe {
        // Load texture
        PLAYER_TEX = load_texture(8, 8, PLAYER_SPRITE.as_ptr());
        texture_filter(0); // Nearest-neighbor for crisp pixels

        // Load sound
        let jump = generate_jump();
        JUMP_SFX = load_sound(jump.as_ptr(), (jump.len() * 2) as u32);
    }
}
}

static uint32_t PLAYER_TEX = 0;
static uint32_t JUMP_SFX = 0;

NCZX_EXPORT void init(void) {
    // Load texture
    uint8_t player_sprite[256];
    generate_player_sprite(player_sprite);
    PLAYER_TEX = load_texture(8, 8, (uint32_t)player_sprite);
    texture_filter(0); // Nearest-neighbor for crisp pixels

    // Load sound
    int16_t jump[4410];
    generate_jump(jump);
    JUMP_SFX = load_sound((uint32_t)jump, sizeof(jump));
}

var PLAYER_TEX: u32 = 0;
var JUMP_SFX: u32 = 0;

export fn init() void {
    // Load texture
    PLAYER_TEX = load_texture(8, 8, @intFromPtr(&PLAYER_SPRITE));
    texture_filter(0); // Nearest-neighbor for crisp pixels

    // Load sound
    const jump = generate_jump();
    JUMP_SFX = load_sound(@intFromPtr(&jump), jump.len * 2);
}

#![allow(unused)]
fn main() {
let player_tex = rom_texture(b"player".as_ptr(), 6);
let jump_sfx = rom_sound(b"jump".as_ptr(), 4);
}

uint32_t player_tex = rom_texture((uint32_t)"player", 6);
uint32_t jump_sfx = rom_sound((uint32_t)"jump", 4);

const player_tex = rom_texture(@intFromPtr("player".ptr), 6);
const jump_sfx = rom_sound(@intFromPtr("jump".ptr), 4);

#![allow(unused)]
fn main() {
// Compile-time embedding
static TEXTURE_DATA: &[u8] = include_bytes!("../assets/player.nczxtex");

// Or generate at runtime
const PIXELS: [u8; 256] = generate_pixels();
}

// Compile-time embedding (platform-specific)
extern const unsigned char player_nczxtex_data[];
extern const unsigned int player_nczxtex_size;

// Or generate at runtime
uint8_t pixels[256];
generate_pixels(pixels);

// Compile-time embedding
const texture_data = @embedFile("../assets/player.nczxtex");

// Or generate at runtime
const pixels: [256]u8 = generate_pixels();

#![allow(unused)]
fn main() {
delta_time() -> f32                    // Seconds since last tick
elapsed_time() -> f32                  // Total seconds since start
tick_count() -> u64                    // Current tick number
log(ptr, len)                          // Log message to console
quit()                                 // Exit to library
random() -> u32                        // Deterministic random u32
random_range(min, max) -> i32          // Random i32 in [min, max)
random_f32() -> f32                    // Random f32 in [0.0, 1.0)
random_f32_range(min, max) -> f32      // Random f32 in [min, max)
player_count() -> u32                  // Number of players (1-4)
local_player_mask() -> u32             // Bitmask of local players
}

float delta_time(void);                // Seconds since last tick
float elapsed_time(void);              // Total seconds since start
uint64_t tick_count(void);             // Current tick number
void log_msg(ptr, len);                // Log message to console
void quit(void);                       // Exit to library
uint32_t random(void);                 // Deterministic random u32
int32_t random_range(int32_t min, int32_t max);    // Random i32 in [min, max)
float random_f32(void);                // Random f32 in [0.0, 1.0)
float random_f32_range(float min, float max);      // Random f32 in [min, max)
uint32_t player_count(void);           // Number of players (1-4)
uint32_t local_player_mask(void);      // Bitmask of local players

Screen Constants: NCZX_SCREEN_WIDTH=960, NCZX_SCREEN_HEIGHT=540

delta_time() f32                       // Seconds since last tick
elapsed_time() f32                     // Total seconds since start
tick_count() u64                       // Current tick number
log_msg(ptr, len) void                 // Log message to console
quit() void                            // Exit to library
random() u32                           // Deterministic random u32
random_range(min: i32, max: i32) i32   // Random i32 in [min, max)
random_f32() f32                       // Random f32 in [0.0, 1.0)
random_f32_range(min: f32, max: f32) f32  // Random f32 in [min, max)
player_count() u32                     // Number of players (1-4)
local_player_mask() u32                // Bitmask of local players

Screen Constants: Screen.width=960, Screen.height=540

#![allow(unused)]
fn main() {
set_tick_rate(fps)                     // 0=24, 1=30, 2=60, 3=120
set_clear_color(0xRRGGBBAA)            // Background color
// render_mode set via nether.toml     // 0=Lambert, 1=Matcap, 2=MR, 3=SS
}

void set_tick_rate(uint32_t fps);      // NCZX_TICK_RATE_24/30/60/120
void set_clear_color(uint32_t color);  // Background color
// render_mode set via nether.toml     // NCZX_RENDER_LAMBERT/MATCAP/MR_BLINN_PHONG/SPECULAR_SHININESS

set_tick_rate(fps: u32) void           // 0=24, 1=30, 2=60, 3=120
set_clear_color(color: u32) void       // Background color
// render_mode set via nether.toml     // 0=Lambert, 1=Matcap, 2=MR, 3=SS

#![allow(unused)]
fn main() {
// Buttons (player: 0-3, button: 0-13)
button_held(player, button) -> u32     // 1 if held
button_pressed(player, button) -> u32  // 1 if just pressed
button_released(player, button) -> u32 // 1 if just released
buttons_held(player) -> u32            // Bitmask of held
buttons_pressed(player) -> u32         // Bitmask of pressed
buttons_released(player) -> u32        // Bitmask of released

// Sticks (-1.0 to 1.0)
left_stick_x(player) -> f32
left_stick_y(player) -> f32
right_stick_x(player) -> f32
right_stick_y(player) -> f32
left_stick(player, &mut x, &mut y)     // Both axes
right_stick(player, &mut x, &mut y)

// Triggers (0.0 to 1.0)
trigger_left(player) -> f32
trigger_right(player) -> f32
}

// Buttons (player: 0-3, button: NCZX_BUTTON_*)
uint32_t button_held(player, button);     // 1 if held
uint32_t button_pressed(player, button);  // 1 if just pressed
uint32_t button_released(player, button); // 1 if just released
uint32_t buttons_held(player);            // Bitmask of held
uint32_t buttons_pressed(player);         // Bitmask of pressed
uint32_t buttons_released(player);        // Bitmask of released

// Sticks (-1.0 to 1.0)
float left_stick_x(player);
float left_stick_y(player);
float right_stick_x(player);
float right_stick_y(player);
void left_stick(player, float* x, float* y);   // Both axes
void right_stick(player, float* x, float* y);

// Triggers (0.0 to 1.0)
float trigger_left(player);
float trigger_right(player);

Button Constants: NCZX_BUTTON_UP=0, NCZX_BUTTON_DOWN=1, NCZX_BUTTON_LEFT=2, NCZX_BUTTON_RIGHT=3, NCZX_BUTTON_A=4, NCZX_BUTTON_B=5, NCZX_BUTTON_X=6, NCZX_BUTTON_Y=7, NCZX_BUTTON_L1=8, NCZX_BUTTON_R1=9, NCZX_BUTTON_L3=10, NCZX_BUTTON_R3=11, NCZX_BUTTON_START=12, NCZX_BUTTON_SELECT=13

// Buttons (player: 0-3, button: Button.*)
button_held(player: u32, button: u32) u32     // 1 if held
button_pressed(player: u32, button: u32) u32  // 1 if just pressed
button_released(player: u32, button: u32) u32 // 1 if just released
buttons_held(player: u32) u32                 // Bitmask of held
buttons_pressed(player: u32) u32              // Bitmask of pressed
buttons_released(player: u32) u32             // Bitmask of released

// Sticks (-1.0 to 1.0)
left_stick_x(player: u32) f32
left_stick_y(player: u32) f32
right_stick_x(player: u32) f32
right_stick_y(player: u32) f32
left_stick(player: u32, x: *f32, y: *f32) void  // Both axes
right_stick(player: u32, x: *f32, y: *f32) void

// Triggers (0.0 to 1.0)
trigger_left(player: u32) f32
trigger_right(player: u32) f32

Button Constants: Button.up=0, Button.down=1, Button.left=2, Button.right=3, Button.a=4, Button.b=5, Button.x=6, Button.y=7, Button.l1=8, Button.r1=9, Button.l3=10, Button.r3=11, Button.start=12, Button.select=13

#![allow(unused)]
fn main() {
camera_set(x, y, z, target_x, target_y, target_z)
camera_fov(degrees)                    // Default: 60
push_view_matrix(m0..m15)              // Custom 4x4 view matrix
push_projection_matrix(m0..m15)        // Custom 4x4 projection
}

void camera_set(x, y, z, target_x, target_y, target_z);
void camera_fov(float degrees);        // Default: 60
void push_view_matrix(m0..m15);        // Custom 4x4 view matrix
void push_projection_matrix(m0..m15);  // Custom 4x4 projection

camera_set(x: f32, y: f32, z: f32, target_x: f32, target_y: f32, target_z: f32) void
camera_fov(degrees: f32) void          // Default: 60
// push_view_matrix and push_projection_matrix take 16 f32 parameters

#![allow(unused)]
fn main() {
push_identity()                        // Reset to identity
transform_set(matrix_ptr)              // Set from 4x4 matrix
push_translate(x, y, z)
push_rotate_x(degrees)
push_rotate_y(degrees)
push_rotate_z(degrees)
push_rotate(degrees, axis_x, axis_y, axis_z)
push_scale(x, y, z)
push_scale_uniform(s)
}

void push_identity(void);              // Reset to identity
void transform_set(const float* matrix_ptr);  // Set from 4x4 matrix
void push_translate(float x, float y, float z);
void push_rotate_x(float degrees);
void push_rotate_y(float degrees);
void push_rotate_z(float degrees);
void push_rotate(float degrees, float axis_x, float axis_y, float axis_z);
void push_scale(float x, float y, float z);
void push_scale_uniform(float s);

push_identity() void                   // Reset to identity
transform_set(matrix_ptr: [*]const f32) void  // Set from 4x4 matrix
push_translate(x: f32, y: f32, z: f32) void
push_rotate_x(degrees: f32) void
push_rotate_y(degrees: f32) void
push_rotate_z(degrees: f32) void
push_rotate(degrees: f32, axis_x: f32, axis_y: f32, axis_z: f32) void
push_scale(x: f32, y: f32, z: f32) void
push_scale_uniform(s: f32) void

#![allow(unused)]
fn main() {
set_color(0xRRGGBBAA)                  // Tint color
cull_mode(mode)                        // 0=none (default), 1=back, 2=front
texture_filter(filter)                 // 0=nearest, 1=linear
uniform_alpha(level)                   // 0-15 dither alpha
dither_offset(x, y)                    // 0-3 pattern offset
z_index(n)                             // 2D ordering within pass (0=back, higher=front)
}

void set_color(uint32_t color);        // Tint color
void cull_mode(uint32_t mode);         // NCZX_CULL_NONE (default)/BACK/FRONT
void texture_filter(uint32_t filter);  // 0=nearest, 1=linear
void uniform_alpha(uint32_t level);    // 0-15 dither alpha
void dither_offset(uint32_t x, uint32_t y);  // 0-3 pattern offset
void z_index(uint32_t n);              // 2D ordering within pass (0=back, higher=front)

set_color(color: u32) void             // Tint color
cull_mode(mode: u32) void              // CullMode.none (default)/back/front
texture_filter(filter: u32) void       // 0=nearest, 1=linear
uniform_alpha(level: u32) void         // 0-15 dither alpha
dither_offset(x: u32, y: u32) void     // 0-3 pattern offset
z_index(n: u32) void                   // 2D ordering within pass (0=back, higher=front)

#![allow(unused)]
fn main() {
begin_pass(clear_depth)                // New pass with optional depth clear
begin_pass_stencil_write(ref_val, clear_depth)  // Create stencil mask
begin_pass_stencil_test(ref_val, clear_depth)   // Render inside mask
begin_pass_full(...)                   // Full control (8 params)
}

void begin_pass(uint32_t clear_depth); // New pass with optional depth clear
void begin_pass_stencil_write(uint32_t ref_val, uint32_t clear_depth);
void begin_pass_stencil_test(uint32_t ref_val, uint32_t clear_depth);
void begin_pass_full(uint32_t depth_compare, uint32_t depth_write,
                     uint32_t clear_depth, uint32_t stencil_compare,
                     uint32_t stencil_ref, uint32_t stencil_pass_op,
                     uint32_t stencil_fail_op, uint32_t stencil_depth_fail_op);

Constants: NCZX_COMPARE_*, NCZX_STENCIL_OP_*

begin_pass(clear_depth: u32) void
begin_pass_stencil_write(ref_val: u32, clear_depth: u32) void
begin_pass_stencil_test(ref_val: u32, clear_depth: u32) void
begin_pass_full(...) void              // Full control (8 params)

Constants: compare.*, stencil_op.*

#![allow(unused)]
fn main() {
load_texture(w, h, pixels_ptr) -> u32  // Init-only, returns handle
texture_bind(handle)                   // Bind to slot 0
texture_bind_slot(handle, slot)        // Bind to slot 0-3
matcap_blend_mode(slot, mode)          // 0=mul, 1=add, 2=hsv
}

uint32_t load_texture(uint32_t w, uint32_t h, const uint8_t* pixels);  // Init-only
void texture_bind(uint32_t handle);    // Bind to slot 0
void texture_bind_slot(uint32_t handle, uint32_t slot);  // Bind to slot 0-3
void matcap_blend_mode(uint32_t slot, uint32_t mode);    // 0=mul, 1=add, 2=hsv

load_texture(w: u32, h: u32, pixels: [*]const u8) u32  // Init-only
texture_bind(handle: u32) void         // Bind to slot 0
texture_bind_slot(handle: u32, slot: u32) void  // Bind to slot 0-3
matcap_blend_mode(slot: u32, mode: u32) void    // 0=mul, 1=add, 2=hsv

#![allow(unused)]
fn main() {
// Retained (init-only)
load_mesh(data_ptr, vertex_count, format) -> u32
load_mesh_indexed(data_ptr, vcount, idx_ptr, icount, fmt) -> u32
load_mesh_packed(data_ptr, vertex_count, format) -> u32
load_mesh_indexed_packed(data_ptr, vcount, idx_ptr, icount, fmt) -> u32
draw_mesh(handle)

// Immediate
draw_triangles(data_ptr, vertex_count, format)
draw_triangles_indexed(data_ptr, vcount, idx_ptr, icount, fmt)
}

// Retained (init-only)
uint32_t load_mesh(const float* data, uint32_t vcount, uint32_t fmt);
uint32_t load_mesh_indexed(const float* data, uint32_t vcount,
                           const uint16_t* idx, uint32_t icount, uint32_t fmt);
uint32_t load_mesh_packed(const uint8_t* data, uint32_t vcount, uint32_t fmt);
uint32_t load_mesh_indexed_packed(const uint8_t* data, uint32_t vcount,
                                  const uint16_t* idx, uint32_t icount, uint32_t fmt);
void draw_mesh(uint32_t handle);

// Immediate
void draw_triangles(const float* data, uint32_t vcount, uint32_t fmt);
void draw_triangles_indexed(const float* data, uint32_t vcount,
                            const uint16_t* idx, uint32_t icount, uint32_t fmt);

Vertex Formats: NCZX_FORMAT_POS=0, NCZX_FORMAT_UV=1, NCZX_FORMAT_COLOR=2, NCZX_FORMAT_NORMAL=4, NCZX_FORMAT_SKINNED=8, NCZX_FORMAT_TANGENT=16 (combinable, TANGENT requires NORMAL)

// Retained (init-only)
load_mesh(data: [*]const f32, vcount: u32, fmt: u32) u32
load_mesh_indexed(data: [*]const f32, vcount: u32, idx: [*]const u16, icount: u32, fmt: u32) u32
draw_mesh(handle: u32) void

// Immediate
draw_triangles(data: [*]const f32, vcount: u32, fmt: u32) void
draw_triangles_indexed(data: [*]const f32, vcount: u32, idx: [*]const u16, icount: u32, fmt: u32) void

Vertex Formats: Format.pos=0, Format.uv=1, Format.color=2, Format.normal=4, Format.skinned=8, Format.tangent=16 (combinable, tangent requires normal)

#![allow(unused)]
fn main() {
cube(sx, sy, sz) -> u32
sphere(radius, segments, rings) -> u32
cylinder(r_bot, r_top, height, segments) -> u32
plane(sx, sz, subdiv_x, subdiv_z) -> u32
torus(major_r, minor_r, major_seg, minor_seg) -> u32
capsule(radius, height, segments, rings) -> u32

// With explicit UV naming (same behavior)
cube_uv, sphere_uv, cylinder_uv, plane_uv, torus_uv, capsule_uv
}

uint32_t cube(float sx, float sy, float sz);
uint32_t sphere(float radius, uint32_t segments, uint32_t rings);
uint32_t cylinder(float r_bot, float r_top, float height, uint32_t segments);
uint32_t plane(float sx, float sz, uint32_t subdiv_x, uint32_t subdiv_z);
uint32_t torus(float major_r, float minor_r, uint32_t major_seg, uint32_t minor_seg);
uint32_t capsule(float radius, float height, uint32_t segments, uint32_t rings);

// With explicit UV naming (same behavior)
cube_uv, sphere_uv, cylinder_uv, plane_uv, torus_uv, capsule_uv

cube(sx: f32, sy: f32, sz: f32) u32
sphere(radius: f32, segments: u32, rings: u32) u32
cylinder(r_bot: f32, r_top: f32, height: f32, segments: u32) u32
plane(sx: f32, sz: f32, subdiv_x: u32, subdiv_z: u32) u32
torus(major_r: f32, minor_r: f32, major_seg: u32, minor_seg: u32) u32
capsule(radius: f32, height: f32, segments: u32, rings: u32) u32

// With explicit UV naming (same behavior)
cube_uv, sphere_uv, cylinder_uv, plane_uv, torus_uv, capsule_uv

#![allow(unused)]
fn main() {
// Mode 2 (Metallic-Roughness)
material_metallic(value)               // 0.0-1.0
material_roughness(value)              // 0.0-1.0
material_emissive(value)               // Glow intensity
material_rim(intensity, power)         // Rim light
material_albedo(texture)               // Bind to slot 0
material_mre(texture)                  // Bind MRE to slot 1
material_normal(texture)               // Bind normal map to slot 3

// Mode 3 (Specular-Shininess)
material_shininess(value)              // 0.0-1.0 → 1-256
material_specular(0xRRGGBBAA)          // Specular color

// Override flags
use_uniform_color(enabled)
use_uniform_metallic(enabled)
use_uniform_roughness(enabled)
use_uniform_emissive(enabled)
skip_normal_map(skip)                  // 0=use normal map, 1=use vertex normal
}

// Mode 2 (Metallic-Roughness)
void material_metallic(float value);   // 0.0-1.0
void material_roughness(float value);  // 0.0-1.0
void material_emissive(float value);   // Glow intensity
void material_rim(float intensity, float power);  // Rim light
void material_albedo(uint32_t texture);    // Bind to slot 0
void material_mre(uint32_t texture);       // Bind MRE to slot 1
void material_normal(uint32_t texture);    // Bind normal map to slot 3

// Mode 3 (Specular-Shininess)
void material_shininess(float value);  // 0.0-1.0 → 1-256
void material_specular(uint32_t color);    // Specular color

// Override flags
void use_uniform_color(uint32_t enabled);
void use_uniform_metallic(uint32_t enabled);
void use_uniform_roughness(uint32_t enabled);
void use_uniform_emissive(uint32_t enabled);
void skip_normal_map(uint32_t skip);       // 0=use normal map, 1=use vertex normal

// Mode 2 (Metallic-Roughness)
material_metallic(value: f32) void     // 0.0-1.0
material_roughness(value: f32) void    // 0.0-1.0
material_emissive(value: f32) void     // Glow intensity
material_rim(intensity: f32, power: f32) void  // Rim light
material_albedo(texture: u32) void     // Bind to slot 0
material_mre(texture: u32) void        // Bind MRE to slot 1
material_normal(texture: u32) void     // Bind normal map to slot 3

// Mode 3 (Specular-Shininess)
material_shininess(value: f32) void    // 0.0-1.0 → 1-256
material_specular(color: u32) void     // Specular color

// Override flags
use_uniform_color(enabled: u32) void
use_uniform_metallic(enabled: u32) void
use_uniform_roughness(enabled: u32) void
use_uniform_emissive(enabled: u32) void
skip_normal_map(skip: u32) void        // 0=use normal map, 1=use vertex normal

#![allow(unused)]
fn main() {
// Directional lights (index 0-3)
light_set(index, dir_x, dir_y, dir_z)
light_color(index, 0xRRGGBBAA)
light_intensity(index, intensity)      // 0.0-8.0
light_enable(index)
light_disable(index)

// Point lights
light_set_point(index, x, y, z)
light_range(index, range)
}

// Directional lights (index 0-3)
void light_set(uint32_t index, float dir_x, float dir_y, float dir_z);
void light_color(uint32_t index, uint32_t color);
void light_intensity(uint32_t index, float intensity);  // 0.0-8.0
void light_enable(uint32_t index);
void light_disable(uint32_t index);

// Point lights
void light_set_point(uint32_t index, float x, float y, float z);
void light_range(uint32_t index, float range);

// Directional lights (index 0-3)
light_set(index: u32, dir_x: f32, dir_y: f32, dir_z: f32) void
light_color(index: u32, color: u32) void
light_intensity(index: u32, intensity: f32) void  // 0.0-8.0
light_enable(index: u32) void
light_disable(index: u32) void

// Point lights
light_set_point(index: u32, x: f32, y: f32, z: f32) void
light_range(index: u32, range: f32) void

#![allow(unused)]
fn main() {
fn environment_index(env_id: u32);
fn epu_set(config_ptr: *const u64);
fn draw_epu();
}

void environment_index(uint32_t env_id);
void epu_set(const uint64_t* config_ptr);
void draw_epu(void);

pub extern fn environment_index(env_id: u32) void;
pub extern fn epu_set(config_ptr: [*]const u64) void;
pub extern fn draw_epu() void;

#![allow(unused)]
fn main() {
// Sprites (use set_color() for tinting)
draw_sprite(x, y, w, h)
draw_sprite_region(x, y, w, h, src_x, src_y, src_w, src_h)  // UV coords (0.0-1.0)
draw_sprite_ex(x, y, w, h, src_x, src_y, src_w, src_h, ox, oy, angle)

// Primitives (use set_color() for color)
draw_rect(x, y, w, h)
draw_line(x1, y1, x2, y2, thickness)
draw_circle(x, y, radius)                      // Filled, 16 segments
draw_circle_outline(x, y, radius, thickness)

// Text (use set_color() for color)
draw_text(ptr, len, x, y, size)
text_width(ptr, len, size) -> f32              // Measure text width
load_font(tex, char_w, char_h, first_cp, count) -> u32
load_font_ex(tex, widths_ptr, char_h, first_cp, count) -> u32
font_bind(handle)
}

// Sprites (use set_color() for tinting)
void draw_sprite(float x, float y, float w, float h);
void draw_sprite_region(float x, float y, float w, float h,
                        float src_x, float src_y, float src_w, float src_h);  // UV coords (0.0-1.0)
void draw_sprite_ex(float x, float y, float w, float h,
                    float src_x, float src_y, float src_w, float src_h,
                    float ox, float oy, float angle);

// Primitives (use set_color() for color)
void draw_rect(float x, float y, float w, float h);
void draw_line(float x1, float y1, float x2, float y2, float thickness);
void draw_circle(float x, float y, float radius);
void draw_circle_outline(float x, float y, float radius, float thickness);

// Text (use set_color() for color)
void draw_text(const uint8_t* ptr, uint32_t len, float x, float y, float size);
float text_width(const uint8_t* ptr, uint32_t len, float size);
uint32_t load_font(uint32_t tex, uint32_t char_w, uint32_t char_h, uint32_t first_cp, uint32_t count);
uint32_t load_font_ex(uint32_t tex, const uint8_t* widths, uint32_t char_h, uint32_t first_cp, uint32_t count);
void font_bind(uint32_t handle);

// Sprites (use set_color() for tinting)
draw_sprite(x: f32, y: f32, w: f32, h: f32) void
draw_sprite_region(x: f32, y: f32, w: f32, h: f32, src_x: f32, src_y: f32, src_w: f32, src_h: f32) void  // UV coords (0.0-1.0)
draw_sprite_ex(x: f32, y: f32, w: f32, h: f32, src_x: f32, src_y: f32, src_w: f32, src_h: f32, ox: f32, oy: f32, angle: f32) void

// Primitives (use set_color() for color)
draw_rect(x: f32, y: f32, w: f32, h: f32) void
draw_line(x1: f32, y1: f32, x2: f32, y2: f32, thickness: f32) void
draw_circle(x: f32, y: f32, radius: f32) void
draw_circle_outline(x: f32, y: f32, radius: f32, thickness: f32) void

// Text (use set_color() for color)
draw_text(ptr: [*]const u8, len: u32, x: f32, y: f32, size: f32) void
text_width(ptr: [*]const u8, len: u32, size: f32) f32
load_font(tex: u32, char_w: u32, char_h: u32, first_cp: u32, count: u32) u32
load_font_ex(tex: u32, widths: [*]const u8, char_h: u32, first_cp: u32, count: u32) u32
font_bind(handle: u32) void

#![allow(unused)]
fn main() {
draw_billboard(w, h, mode)             // mode: 1=sphere, 2=cylY, 3=cylX, 4=cylZ
draw_billboard_region(w, h, sx, sy, sw, sh, mode)  // UV coords (0.0-1.0)
}

void draw_billboard(float w, float h, uint32_t mode);
void draw_billboard_region(float w, float h, float sx, float sy, float sw, float sh, uint32_t mode);
// Modes: NCZX_BILLBOARD_SPHERICAL, NCZX_BILLBOARD_CYLINDRICAL_Y/X/Z

draw_billboard(w: f32, h: f32, mode: u32) void
draw_billboard_region(w: f32, h: f32, sx: f32, sy: f32, sw: f32, sh: f32, mode: u32) void
// Modes: Billboard.spherical, Billboard.cylindrical_y/x/z

#![allow(unused)]
fn main() {
load_skeleton(inverse_bind_ptr, bone_count) -> u32  // Init-only
skeleton_bind(skeleton)                // 0 to disable
set_bones(matrices_ptr, count)         // 12 floats per bone (3x4)
set_bones_4x4(matrices_ptr, count)     // 16 floats per bone (4x4)
}

uint32_t load_skeleton(const float* inverse_bind_ptr, uint32_t bone_count);  // Init-only
void skeleton_bind(uint32_t skeleton); // 0 to disable
void set_bones(const float* matrices_ptr, uint32_t count);  // 12 floats per bone (3x4)
void set_bones_4x4(const float* matrices_ptr, uint32_t count);  // 16 floats per bone (4x4)

load_skeleton(inverse_bind: [*]const f32, bone_count: u32) u32  // Init-only
skeleton_bind(skeleton: u32) void      // 0 to disable
set_bones(matrices: [*]const f32, count: u32) void  // 12 floats per bone (3x4)
set_bones_4x4(matrices: [*]const f32, count: u32) void  // 16 floats per bone (4x4)

#![allow(unused)]
fn main() {
keyframes_load(data_ptr, byte_size) -> u32  // Init-only
rom_keyframes(id_ptr, id_len) -> u32        // Init-only
keyframes_bone_count(handle) -> u32
keyframes_frame_count(handle) -> u32
keyframe_bind(handle, frame_index)          // GPU-side, no CPU decode
keyframe_read(handle, frame_index, out_ptr) // Read to WASM for blending
}

uint32_t keyframes_load(const uint8_t* data, uint32_t byte_size);  // Init-only
uint32_t rom_keyframes(uint32_t id_ptr, uint32_t id_len);          // Init-only
uint32_t keyframes_bone_count(uint32_t handle);
uint32_t keyframes_frame_count(uint32_t handle);
void keyframe_bind(uint32_t handle, uint32_t frame_index);  // GPU-side
void keyframe_read(uint32_t handle, uint32_t frame_index, float* out_ptr);  // Read for blending

keyframes_load(data: [*]const u8, byte_size: u32) u32  // Init-only
rom_keyframes(id_ptr: u32, id_len: u32) u32            // Init-only
keyframes_bone_count(handle: u32) u32
keyframes_frame_count(handle: u32) u32
keyframe_bind(handle: u32, frame_index: u32) void      // GPU-side
keyframe_read(handle: u32, frame_index: u32, out: [*]f32) void  // Read for blending

#![allow(unused)]
fn main() {
load_sound(data_ptr, byte_len) -> u32  // Init-only, 22kHz 16-bit mono
play_sound(sound, volume, pan)         // Auto-select channel
channel_play(ch, sound, vol, pan, loop)
channel_set(ch, volume, pan)
channel_stop(ch)
}

uint32_t load_sound(const int16_t* data, uint32_t byte_len);  // Init-only
void play_sound(uint32_t sound, float volume, float pan);  // Auto-select channel
void channel_play(uint32_t ch, uint32_t sound, float vol, float pan, uint32_t loop);
void channel_set(uint32_t ch, float volume, float pan);
void channel_stop(uint32_t ch);

load_sound(data: [*]const i16, byte_len: u32) u32  // Init-only
play_sound(sound: u32, volume: f32, pan: f32) void  // Auto-select channel
channel_play(ch: u32, sound: u32, vol: f32, pan: f32, loop: u32) void
channel_set(ch: u32, volume: f32, pan: f32) void
channel_stop(ch: u32) void

#![allow(unused)]
fn main() {
// Loading (init-only)
rom_tracker(id_ptr, id_len) -> u32     // Load XM from ROM (returns tracker handle)
load_tracker(data_ptr, len) -> u32     // Load XM from raw data

// Playback (works for both PCM and tracker)
music_play(handle, volume, looping)    // Start playing (auto-stops other type)
music_stop()                            // Stop all music
music_pause(paused)                     // 0=resume, 1=pause (tracker only)
music_set_volume(volume)                // 0.0-1.0
music_is_playing() -> u32               // 1 if playing
music_type() -> u32                     // 0=none, 1=PCM, 2=tracker

// Position (tracker-specific, no-op for PCM)
music_jump(order, row)                  // Jump to position
music_position() -> u32                 // Tracker: (order << 16) | row, PCM: sample pos
music_length(handle) -> u32             // Tracker: orders, PCM: samples
music_set_speed(speed)                  // Ticks per row (1-31)
music_set_tempo(bpm)                    // BPM (32-255)

// Query
music_info(handle) -> u32               // Tracker: (ch<<24)|(pat<<16)|(inst<<8)|len
music_name(handle, out_ptr, max) -> u32 // Tracker only (returns 0 for PCM)
}

// Loading (init-only)
uint32_t rom_tracker(uint32_t id_ptr, uint32_t id_len);  // Load XM from ROM
uint32_t load_tracker(const uint8_t* data, uint32_t len);

// Playback (works for both PCM and tracker)
void music_play(uint32_t handle, float volume, uint32_t looping);
void music_stop(void);
void music_pause(uint32_t paused);      // Tracker only
void music_set_volume(float volume);
uint32_t music_is_playing(void);
uint32_t music_type(void);              // 0=none, 1=PCM, 2=tracker

// Position (tracker-specific)
void music_jump(uint32_t order, uint32_t row);
uint32_t music_position(void);
uint32_t music_length(uint32_t handle);
void music_set_speed(uint32_t speed);
void music_set_tempo(uint32_t bpm);

// Query
uint32_t music_info(uint32_t handle);
uint32_t music_name(uint32_t handle, uint8_t* out, uint32_t max);

// Loading (init-only)
rom_tracker(id_ptr: u32, id_len: u32) u32  // Load XM from ROM
load_tracker(data: [*]const u8, len: u32) u32

// Playback (works for both PCM and tracker)
music_play(handle: u32, volume: f32, looping: u32) void
music_stop() void
music_pause(paused: u32) void           // Tracker only
music_set_volume(volume: f32) void
music_is_playing() u32
music_type() u32                        // 0=none, 1=PCM, 2=tracker

// Position (tracker-specific)
music_jump(order: u32, row: u32) void
music_position() u32
music_length(handle: u32) u32
music_set_speed(speed: u32) void
music_set_tempo(bpm: u32) void

// Query
music_info(handle: u32) u32
music_name(handle: u32, out: [*]u8, max: u32) u32

#![allow(unused)]
fn main() {
save(slot, data_ptr, data_len) -> u32  // 0=ok, 1=bad slot, 2=too big
load(slot, data_ptr, max_len) -> u32   // Returns bytes read
delete(slot) -> u32                    // 0=ok, 1=bad slot
}

uint32_t save(uint32_t slot, const uint8_t* data, uint32_t len);  // 0=ok, 1=bad slot, 2=too big
uint32_t load(uint32_t slot, uint8_t* data, uint32_t max_len);    // Returns bytes read
uint32_t delete_save(uint32_t slot);   // 0=ok, 1=bad slot

save(slot: u32, data: [*]const u8, len: u32) u32  // 0=ok, 1=bad slot, 2=too big
load(slot: u32, data: [*]u8, max_len: u32) u32    // Returns bytes read
delete_save(slot: u32) u32             // 0=ok, 1=bad slot

#![allow(unused)]
fn main() {
rom_texture(id_ptr, id_len) -> u32
rom_mesh(id_ptr, id_len) -> u32
rom_skeleton(id_ptr, id_len) -> u32
rom_font(id_ptr, id_len) -> u32
rom_sound(id_ptr, id_len) -> u32
rom_keyframes(id_ptr, id_len) -> u32
rom_tracker(id_ptr, id_len) -> u32     // Load XM tracker
rom_data_len(id_ptr, id_len) -> u32
rom_data(id_ptr, id_len, out_ptr, max_len) -> u32
}

uint32_t rom_texture(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_mesh(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_skeleton(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_font(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_sound(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_keyframes(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_tracker(uint32_t id_ptr, uint32_t id_len);  // Load XM tracker
uint32_t rom_data_len(uint32_t id_ptr, uint32_t id_len);
uint32_t rom_data(uint32_t id_ptr, uint32_t id_len, uint32_t out_ptr, uint32_t max_len);
// Helpers: NCZX_ROM_TEXTURE("id"), NCZX_ROM_MESH("id"), etc.

rom_texture(id_ptr: u32, id_len: u32) u32
rom_mesh(id_ptr: u32, id_len: u32) u32
rom_skeleton(id_ptr: u32, id_len: u32) u32
rom_font(id_ptr: u32, id_len: u32) u32
rom_sound(id_ptr: u32, id_len: u32) u32
rom_keyframes(id_ptr: u32, id_len: u32) u32
rom_tracker(id_ptr: u32, id_len: u32) u32  // Load XM tracker
rom_data_len(id_ptr: u32, id_len: u32) u32
rom_data(id_ptr: u32, id_len: u32, out_ptr: u32, max_len: u32) u32

#![allow(unused)]
fn main() {
// Registration (init-only)
debug_register_i8/i16/i32(name_ptr, name_len, ptr)
debug_register_u8/u16/u32(name_ptr, name_len, ptr)
debug_register_f32(name_ptr, name_len, ptr)
debug_register_bool(name_ptr, name_len, ptr)
debug_register_i32_range(name_ptr, name_len, ptr, min, max)
debug_register_f32_range(name_ptr, name_len, ptr, min, max)
debug_register_u8_range/u16_range/i16_range(...)
debug_register_vec2/vec3/rect/color(name_ptr, name_len, ptr)
debug_register_fixed_i16_q8/i32_q8/i32_q16/i32_q24(...)

// Watch (read-only)
debug_watch_i8/i16/i32/u8/u16/u32/f32/bool(name_ptr, name_len, ptr)
debug_watch_vec2/vec3/rect/color(name_ptr, name_len, ptr)

// Groups
debug_group_begin(name_ptr, name_len)
debug_group_end()

// Frame control
debug_is_paused() -> i32               // 1 if paused
debug_get_time_scale() -> f32          // 1.0 = normal
}

// Registration (init-only)
void debug_register_i8/i16/i32(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);
void debug_register_u8/u16/u32(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);
void debug_register_f32(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);
void debug_register_bool(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);
void debug_register_i32_range(uint32_t name_ptr, uint32_t name_len, uint32_t ptr, int32_t min, int32_t max);
void debug_register_f32_range(uint32_t name_ptr, uint32_t name_len, uint32_t ptr, float min, float max);
void debug_register_vec2/vec3/rect/color(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);

// Watch (read-only)
void debug_watch_i8/i16/i32/u8/u16/u32/f32/bool(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);
void debug_watch_vec2/vec3/rect/color(uint32_t name_ptr, uint32_t name_len, uint32_t ptr);

// Groups
void debug_group_begin(uint32_t name_ptr, uint32_t name_len);
void debug_group_end(void);

// Frame control
int32_t debug_is_paused(void);         // 1 if paused
float debug_get_time_scale(void);      // 1.0 = normal

// Registration (init-only) - similar pattern for all types
debug_register_f32(name_ptr: u32, name_len: u32, ptr: u32) void
debug_register_i32(name_ptr: u32, name_len: u32, ptr: u32) void
debug_register_bool(name_ptr: u32, name_len: u32, ptr: u32) void
debug_register_i32_range(name_ptr: u32, name_len: u32, ptr: u32, min: i32, max: i32) void
debug_register_f32_range(name_ptr: u32, name_len: u32, ptr: u32, min: f32, max: f32) void
debug_register_vec2/vec3/rect/color(name_ptr: u32, name_len: u32, ptr: u32) void

// Watch (read-only) - similar pattern
debug_watch_f32(name_ptr: u32, name_len: u32, ptr: u32) void
debug_watch_vec2/vec3/rect/color(name_ptr: u32, name_len: u32, ptr: u32) void

// Groups
debug_group_begin(name_ptr: u32, name_len: u32) void
debug_group_end() void

// Frame control
debug_is_paused() i32                  // 1 if paused
debug_get_time_scale() f32             // 1.0 = normal

#![allow(unused)]
fn main() {
fn delta_time() -> f32
}

NCZX_IMPORT float delta_time(void);

pub extern fn delta_time() f32;

#![allow(unused)]
fn main() {
fn update() {
    // Frame-rate independent movement
    position.x += velocity.x * delta_time();
    position.y += velocity.y * delta_time();
}
}

NCZX_EXPORT void update(void) {
    /* Frame-rate independent movement */
    position_x += velocity_x * delta_time();
    position_y += velocity_y * delta_time();
}

export fn update() void {
    // Frame-rate independent movement
    position_x += velocity_x * delta_time();
    position_y += velocity_y * delta_time();
}

#![allow(unused)]
fn main() {
fn elapsed_time() -> f32
}

NCZX_IMPORT float elapsed_time(void);

pub extern fn elapsed_time() f32;

#![allow(unused)]
fn main() {
fn render() {
    // Pulsing effect
    let pulse = (elapsed_time() * 2.0).sin() * 0.5 + 0.5;
    set_color(rgba(255, 255, 255, (pulse * 255.0) as u8));
}
}

NCZX_EXPORT void render(void) {
    /* Pulsing effect */
    float pulse = sinf(elapsed_time() * 2.0f) * 0.5f + 0.5f;
    set_color(nczx_rgba(255, 255, 255, (uint8_t)(pulse * 255.0f)));
}

export fn render() void {
    // Pulsing effect
    const pulse = @sin(elapsed_time() * 2.0) * 0.5 + 0.5;
    set_color(rgba(255, 255, 255, @intFromFloat(pulse * 255.0)));
}

#![allow(unused)]
fn main() {
fn tick_count() -> u64
}

NCZX_IMPORT uint64_t tick_count(void);

pub extern fn tick_count() u64;

#![allow(unused)]
fn main() {
fn update() {
    // Every second at 60fps
    if tick_count() % 60 == 0 {
        spawn_enemy();
    }

    // Every other tick
    if tick_count() % 2 == 0 {
        animate_water();
    }
}
}

NCZX_EXPORT void update(void) {
    /* Every second at 60fps */
    if (tick_count() % 60 == 0) {
        spawn_enemy();
    }

    /* Every other tick */
    if (tick_count() % 2 == 0) {
        animate_water();
    }
}

export fn update() void {
    // Every second at 60fps
    if (tick_count() % 60 == 0) {
        spawn_enemy();
    }

    // Every other tick
    if (tick_count() % 2 == 0) {
        animate_water();
    }
}

#![allow(unused)]
fn main() {
fn log(ptr: *const u8, len: u32)
}

NCZX_IMPORT void log_msg(const uint8_t* ptr, uint32_t len);
// Helper macro: NCZX_LOG("message")

pub extern fn log_msg(ptr: [*]const u8, len: u32) void;
// Helper: zx.log("message")

#![allow(unused)]
fn main() {
fn init() {
    let msg = b"Game initialized!";
    log(msg.as_ptr(), msg.len() as u32);
}

fn update() {
    if player_died {
        let msg = b"Player died";
        log(msg.as_ptr(), msg.len() as u32);
    }
}
}

NCZX_EXPORT void init(void) {
    NCZX_LOG("Game initialized!");
}

NCZX_EXPORT void update(void) {
    if (player_died) {
        NCZX_LOG("Player died");
    }
}

const zx = @import("zx.zig");

export fn init() void {
    zx.log("Game initialized!");
}

export fn update() void {
    if (player_died) {
        zx.log("Player died");
    }
}

#![allow(unused)]
fn main() {
fn quit()
}

NCZX_IMPORT void quit(void);

pub extern fn quit() void;

#![allow(unused)]
fn main() {
fn update() {
    // Quit on Start + Select held for 60 frames
    if buttons_held(0) & ((1 << BUTTON_START) | (1 << BUTTON_SELECT)) != 0 {
        quit_timer += 1;
        if quit_timer >= 60 {
            quit();
        }
    } else {
        quit_timer = 0;
    }
}
}

NCZX_EXPORT void update(void) {
    /* Quit on Start + Select held for 60 frames */
    if (buttons_held(0) & ((1 << NCZX_BUTTON_START) | (1 << NCZX_BUTTON_SELECT))) {
        quit_timer++;
        if (quit_timer >= 60) {
            quit();
        }
    } else {
        quit_timer = 0;
    }
}

export fn update() void {
    // Quit on Start + Select held for 60 frames
    if (buttons_held(0) & ((1 << Button.start) | (1 << Button.select)) != 0) {
        quit_timer += 1;
        if (quit_timer >= 60) {
            quit();
        }
    } else {
        quit_timer = 0;
    }
}

#![allow(unused)]
fn main() {
fn random() -> u32
}

NCZX_IMPORT uint32_t random_u32(void);

pub extern fn random_u32() u32;

#![allow(unused)]
fn main() {
fn update() {
    // Random integer in range [0, 320)
    let spawn_x = (random() % 320) as f32;

    // Random float 0.0 to 1.0
    let rf = (random() as f32) / (u32::MAX as f32);

    // Random bool
    let coin_flip = random() & 1 == 0;

    // Random float in range [min, max]
    let min = 10.0;
    let max = 50.0;
    let rf = (random() as f32) / (u32::MAX as f32);
    let value = min + rf * (max - min);
}
}

NCZX_EXPORT void update(void) {
    /* Random integer in range [0, 320) */
    float spawn_x = (float)(random_u32() % 320);

    /* Random float 0.0 to 1.0 */
    float rf = (float)random_u32() / (float)UINT32_MAX;

    /* Random bool */
    int coin_flip = (random_u32() & 1) == 0;

    /* Random float in range [min, max] */
    float min = 10.0f;
    float max = 50.0f;
    float value = min + rf * (max - min);
}

export fn update() void {
    // Random integer in range [0, 320)
    const spawn_x: f32 = @floatFromInt(random_u32() % 320);

    // Random float 0.0 to 1.0
    const rf: f32 = @as(f32, @floatFromInt(random_u32())) / @as(f32, @floatFromInt(@as(u32, 0xFFFFFFFF)));

    // Random bool
    const coin_flip = (random_u32() & 1) == 0;

    // Random float in range [min, max]
    const min: f32 = 10.0;
    const max: f32 = 50.0;
    const value = min + rf * (max - min);
}

#![allow(unused)]
fn main() {
fn random_range(min: i32, max: i32) -> i32
}

NCZX_IMPORT int32_t random_range(int32_t min, int32_t max);

pub extern fn random_range(min: i32, max: i32) i32;

#![allow(unused)]
fn main() {
let spawn_x = random_range(0, 960);  // 0 to 959
let damage = random_range(10, 21);   // 10 to 20
}

int spawn_x = random_range(0, 960);  /* 0 to 959 */
int damage = random_range(10, 21);   /* 10 to 20 */

const spawn_x = random_range(0, 960);  // 0 to 959
const damage = random_range(10, 21);   // 10 to 20

#![allow(unused)]
fn main() {
fn random_f32() -> f32
}

NCZX_IMPORT float random_f32(void);

pub extern fn random_f32() f32;

#![allow(unused)]
fn main() {
let t = random_f32();  // 0.0 to 0.999...
let color_variation = random_f32() * 0.2 - 0.1;  // -0.1 to +0.1
}

float t = random_f32();  /* 0.0 to 0.999... */
float color_variation = random_f32() * 0.2f - 0.1f;  /* -0.1 to +0.1 */

const t = random_f32();  // 0.0 to 0.999...
const color_variation = random_f32() * 0.2 - 0.1;  // -0.1 to +0.1

#![allow(unused)]
fn main() {
fn random_f32_range(min: f32, max: f32) -> f32
}

NCZX_IMPORT float random_f32_range(float min, float max);

pub extern fn random_f32_range(min: f32, max: f32) f32;

#![allow(unused)]
fn main() {
let speed = random_f32_range(5.0, 15.0);  // 5.0 to 14.999...
let angle = random_f32_range(0.0, 6.28);  // 0 to 2π
}

float speed = random_f32_range(5.0f, 15.0f);  /* 5.0 to 14.999... */
float angle = random_f32_range(0.0f, 6.28f);  /* 0 to 2π */

const speed = random_f32_range(5.0, 15.0);  // 5.0 to 14.999...
const angle = random_f32_range(0.0, 6.28);  // 0 to 2π

#![allow(unused)]
fn main() {
screen::WIDTH   // 960
screen::HEIGHT  // 540
}

NCZX_SCREEN_WIDTH   // 960
NCZX_SCREEN_HEIGHT  // 540

Screen.width   // 960
Screen.height  // 540

#![allow(unused)]
fn main() {
// Center something on screen
let center_x = screen::WIDTH as f32 / 2.0;
let center_y = screen::HEIGHT as f32 / 2.0;
}

/* Center something on screen */
float center_x = NCZX_SCREEN_WIDTH / 2.0f;
float center_y = NCZX_SCREEN_HEIGHT / 2.0f;

// Center something on screen
const center_x = @as(f32, @floatFromInt(Screen.width)) / 2.0;
const center_y = @as(f32, @floatFromInt(Screen.height)) / 2.0;

#![allow(unused)]
fn main() {
fn player_count() -> u32
}

NCZX_IMPORT uint32_t player_count(void);

pub extern fn player_count() u32;

#![allow(unused)]
fn main() {
fn update() {
    // Process all players
    for p in 0..player_count() {
        process_player_input(p);
        update_player_state(p);
    }
}

fn render() {
    // Draw viewport split for multiplayer
    match player_count() {
        1 => draw_fullscreen_viewport(0),
        2 => {
            draw_half_viewport(0, 0);   // Left half
            draw_half_viewport(1, 1);   // Right half
        }
        _ => draw_quad_viewports(),
    }
}
}

NCZX_EXPORT void update(void) {
    /* Process all players */
    for (uint32_t p = 0; p < player_count(); p++) {
        process_player_input(p);
        update_player_state(p);
    }
}

NCZX_EXPORT void render(void) {
    /* Draw viewport split for multiplayer */
    switch (player_count()) {
        case 1: draw_fullscreen_viewport(0); break;
        case 2:
            draw_half_viewport(0, 0);   /* Left half */
            draw_half_viewport(1, 1);   /* Right half */
            break;
        default: draw_quad_viewports(); break;
    }
}

export fn update() void {
    // Process all players
    var p: u32 = 0;
    while (p < player_count()) : (p += 1) {
        process_player_input(p);
        update_player_state(p);
    }
}

export fn render() void {
    // Draw viewport split for multiplayer
    switch (player_count()) {
        1 => draw_fullscreen_viewport(0),
        2 => {
            draw_half_viewport(0, 0);   // Left half
            draw_half_viewport(1, 1);   // Right half
        },
        else => draw_quad_viewports(),
    }
}

#![allow(unused)]
fn main() {
fn local_player_mask() -> u32
}

NCZX_IMPORT uint32_t local_player_mask(void);

pub extern fn local_player_mask() u32;

#![allow(unused)]
fn main() {
fn render() {
    let mask = local_player_mask();

    // Check if specific player is local
    let p0_local = (mask & 1) != 0;  // Player 0
    let p1_local = (mask & 2) != 0;  // Player 1
    let p2_local = (mask & 4) != 0;  // Player 2
    let p3_local = (mask & 8) != 0;  // Player 3

    // Only show local player's UI
    for p in 0..player_count() {
        if (mask & (1 << p)) != 0 {
            draw_player_ui(p);
        }
    }
}
}

NCZX_EXPORT void render(void) {
    uint32_t mask = local_player_mask();

    /* Check if specific player is local */
    int p0_local = (mask & 1) != 0;  /* Player 0 */
    int p1_local = (mask & 2) != 0;  /* Player 1 */
    int p2_local = (mask & 4) != 0;  /* Player 2 */
    int p3_local = (mask & 8) != 0;  /* Player 3 */

    /* Only show local player's UI */
    for (uint32_t p = 0; p < player_count(); p++) {
        if (mask & (1 << p)) {
            draw_player_ui(p);
        }
    }
}

export fn render() void {
    const mask = local_player_mask();

    // Check if specific player is local
    const p0_local = (mask & 1) != 0;  // Player 0
    const p1_local = (mask & 2) != 0;  // Player 1
    const p2_local = (mask & 4) != 0;  // Player 2
    const p3_local = (mask & 8) != 0;  // Player 3

    // Only show local player's UI
    var p: u32 = 0;
    while (p < player_count()) : (p += 1) {
        if (mask & (@as(u32, 1) << @intCast(p)) != 0) {
            draw_player_ui(p);
        }
    }
}

#![allow(unused)]
fn main() {
fn update() {
    // This code works for any local/remote mix
    for p in 0..player_count() {
        let input = get_player_input(p);
        update_player(p, input);
    }
}
}

NCZX_EXPORT void update(void) {
    /* This code works for any local/remote mix */
    for (uint32_t p = 0; p < player_count(); p++) {
        Input input = get_player_input(p);
        update_player(p, input);
    }
}

export fn update() void {
    // This code works for any local/remote mix
    var p: u32 = 0;
    while (p < player_count()) : (p += 1) {
        const input = get_player_input(p);
        update_player(p, input);
    }
}

#![allow(unused)]
fn main() {
// D-Pad
const BUTTON_UP: u32 = 0;
const BUTTON_DOWN: u32 = 1;
const BUTTON_LEFT: u32 = 2;
const BUTTON_RIGHT: u32 = 3;

// Face buttons
const BUTTON_A: u32 = 4;
const BUTTON_B: u32 = 5;
const BUTTON_X: u32 = 6;
const BUTTON_Y: u32 = 7;

// Shoulder bumpers
const BUTTON_LB: u32 = 8;
const BUTTON_RB: u32 = 9;

// Stick clicks
const BUTTON_L3: u32 = 10;
const BUTTON_R3: u32 = 11;

// Menu
const BUTTON_START: u32 = 12;
const BUTTON_SELECT: u32 = 13;
}

// D-Pad
#define NCZX_BUTTON_UP      0
#define NCZX_BUTTON_DOWN    1
#define NCZX_BUTTON_LEFT    2
#define NCZX_BUTTON_RIGHT   3

// Face buttons
#define NCZX_BUTTON_A       4
#define NCZX_BUTTON_B       5
#define NCZX_BUTTON_X       6
#define NCZX_BUTTON_Y       7

// Shoulder bumpers
#define NCZX_BUTTON_L1      8
#define NCZX_BUTTON_R1      9

// Stick clicks
#define NCZX_BUTTON_L3      10
#define NCZX_BUTTON_R3      11

// Menu
#define NCZX_BUTTON_START   12
#define NCZX_BUTTON_SELECT  13

const Button = struct {
    // D-Pad
    pub const up: u32 = 0;
    pub const down: u32 = 1;
    pub const left: u32 = 2;
    pub const right: u32 = 3;

    // Face buttons
    pub const a: u32 = 4;
    pub const b: u32 = 5;
    pub const x: u32 = 6;
    pub const y: u32 = 7;

    // Shoulder bumpers
    pub const l1: u32 = 8;
    pub const r1: u32 = 9;

    // Stick clicks
    pub const l3: u32 = 10;
    pub const r3: u32 = 11;

    // Menu
    pub const start: u32 = 12;
    pub const select: u32 = 13;
};

#![allow(unused)]
fn main() {
fn button_held(player: u32, button: u32) -> u32
}

NCZX_IMPORT uint32_t button_held(uint32_t player, uint32_t button);

pub extern fn button_held(player: u32, button: u32) u32;

#![allow(unused)]
fn main() {
fn update() {
    // Continuous movement while held
    if button_held(0, BUTTON_RIGHT) != 0 {
        player.x += MOVE_SPEED * delta_time();
    }
    if button_held(0, BUTTON_LEFT) != 0 {
        player.x -= MOVE_SPEED * delta_time();
    }
}
}

NCZX_EXPORT void update(void) {
    /* Continuous movement while held */
    if (button_held(0, NCZX_BUTTON_RIGHT)) {
        player_x += MOVE_SPEED * delta_time();
    }
    if (button_held(0, NCZX_BUTTON_LEFT)) {
        player_x -= MOVE_SPEED * delta_time();
    }
}

export fn update() void {
    // Continuous movement while held
    if (button_held(0, Button.right) != 0) {
        player_x += MOVE_SPEED * delta_time();
    }
    if (button_held(0, Button.left) != 0) {
        player_x -= MOVE_SPEED * delta_time();
    }
}

#![allow(unused)]
fn main() {
fn button_pressed(player: u32, button: u32) -> u32
}

NCZX_IMPORT uint32_t button_pressed(uint32_t player, uint32_t button);

pub extern fn button_pressed(player: u32, button: u32) u32;

#![allow(unused)]
fn main() {
fn update() {
    // Jump only triggers once per press
    if button_pressed(0, BUTTON_A) != 0 && player.on_ground {
        player.velocity_y = JUMP_VELOCITY;
        play_sound(jump_sfx, 1.0, 0.0);
    }

    // Cycle weapons
    if button_pressed(0, BUTTON_RB) != 0 {
        current_weapon = (current_weapon + 1) % NUM_WEAPONS;
    }
}
}

NCZX_EXPORT void update(void) {
    /* Jump only triggers once per press */
    if (button_pressed(0, NCZX_BUTTON_A) && on_ground) {
        velocity_y = JUMP_VELOCITY;
        play_sound(jump_sfx, 1.0f, 0.0f);
    }

    /* Cycle weapons */
    if (button_pressed(0, NCZX_BUTTON_R1)) {
        current_weapon = (current_weapon + 1) % NUM_WEAPONS;
    }
}

export fn update() void {
    // Jump only triggers once per press
    if (button_pressed(0, Button.a) != 0 and on_ground) {
        velocity_y = JUMP_VELOCITY;
        play_sound(jump_sfx, 1.0, 0.0);
    }

    // Cycle weapons
    if (button_pressed(0, Button.r1) != 0) {
        current_weapon = (current_weapon + 1) % NUM_WEAPONS;
    }
}

#![allow(unused)]
fn main() {
fn button_released(player: u32, button: u32) -> u32
}

NCZX_IMPORT uint32_t button_released(uint32_t player, uint32_t button);

pub extern fn button_released(player: u32, button: u32) u32;

#![allow(unused)]
fn main() {
fn update() {
    // Variable jump height (release early = smaller jump)
    if button_released(0, BUTTON_A) != 0 && player.velocity_y < 0.0 {
        player.velocity_y *= 0.5; // Cut upward velocity
    }

    // Charged attack
    if button_released(0, BUTTON_X) != 0 {
        let power = charge_time.min(MAX_CHARGE);
        fire_charged_attack(power);
        charge_time = 0.0;
    }
}
}

NCZX_EXPORT void update(void) {
    /* Variable jump height (release early = smaller jump) */
    if (button_released(0, NCZX_BUTTON_A) && velocity_y < 0.0f) {
        velocity_y *= 0.5f; /* Cut upward velocity */
    }

    /* Charged attack */
    if (button_released(0, NCZX_BUTTON_X)) {
        float power = nczx_minf(charge_time, MAX_CHARGE);
        fire_charged_attack(power);
        charge_time = 0.0f;
    }
}

export fn update() void {
    // Variable jump height (release early = smaller jump)
    if (button_released(0, Button.a) != 0 and velocity_y < 0.0) {
        velocity_y *= 0.5; // Cut upward velocity
    }

    // Charged attack
    if (button_released(0, Button.x) != 0) {
        const power = @min(charge_time, MAX_CHARGE);
        fire_charged_attack(power);
        charge_time = 0.0;
    }
}

#![allow(unused)]
fn main() {
fn buttons_held(player: u32) -> u32
}

NCZX_IMPORT uint32_t buttons_held(uint32_t player);

pub extern fn buttons_held(player: u32) u32;

#![allow(unused)]
fn main() {
fn update() {
    let held = buttons_held(0);

    // Check multiple buttons efficiently
    if held & (1 << BUTTON_A) != 0 { /* A held */ }
    if held & (1 << BUTTON_B) != 0 { /* B held */ }

    // Check for combo (A + B held together)
    let combo = (1 << BUTTON_A) | (1 << BUTTON_B);
    if held & combo == combo {
        perform_combo_attack();
    }
}
}

NCZX_EXPORT void update(void) {
    uint32_t held = buttons_held(0);

    /* Check multiple buttons efficiently */
    if (held & (1 << NCZX_BUTTON_A)) { /* A held */ }
    if (held & (1 << NCZX_BUTTON_B)) { /* B held */ }

    /* Check for combo (A + B held together) */
    uint32_t combo = (1 << NCZX_BUTTON_A) | (1 << NCZX_BUTTON_B);
    if ((held & combo) == combo) {
        perform_combo_attack();
    }
}

export fn update() void {
    const held = buttons_held(0);

    // Check multiple buttons efficiently
    if (held & (1 << Button.a) != 0) { /* A held */ }
    if (held & (1 << Button.b) != 0) { /* B held */ }

    // Check for combo (A + B held together)
    const combo = (1 << Button.a) | (1 << Button.b);
    if (held & combo == combo) {
        perform_combo_attack();
    }
}

#![allow(unused)]
fn main() {
fn buttons_pressed(player: u32) -> u32
}

NCZX_IMPORT uint32_t buttons_pressed(uint32_t player);

pub extern fn buttons_pressed(player: u32) u32;

#![allow(unused)]
fn main() {
fn update() {
    let pressed = buttons_pressed(0);

    // Check if any face button pressed
    let face_buttons = (1 << BUTTON_A) | (1 << BUTTON_B) |
                       (1 << BUTTON_X) | (1 << BUTTON_Y);
    if pressed & face_buttons != 0 {
        // Handle menu selection
    }
}
}

NCZX_EXPORT void update(void) {
    uint32_t pressed = buttons_pressed(0);

    /* Check if any face button pressed */
    uint32_t face_buttons = (1 << NCZX_BUTTON_A) | (1 << NCZX_BUTTON_B) |
                            (1 << NCZX_BUTTON_X) | (1 << NCZX_BUTTON_Y);
    if (pressed & face_buttons) {
        /* Handle menu selection */
    }
}

export fn update() void {
    const pressed = buttons_pressed(0);

    // Check if any face button pressed
    const face_buttons = (1 << Button.a) | (1 << Button.b) |
                         (1 << Button.x) | (1 << Button.y);
    if (pressed & face_buttons != 0) {
        // Handle menu selection
    }
}

#![allow(unused)]
fn main() {
fn buttons_released(player: u32) -> u32
}

NCZX_IMPORT uint32_t buttons_released(uint32_t player);

pub extern fn buttons_released(player: u32) u32;

#![allow(unused)]
fn main() {
fn left_stick_x(player: u32) -> f32
}

NCZX_IMPORT float left_stick_x(uint32_t player);

pub extern fn left_stick_x(player: u32) f32;

#![allow(unused)]
fn main() {
fn update() {
    let stick_x = left_stick_x(0);

    // Apply deadzone
    let deadzone = 0.15;
    if stick_x.abs() > deadzone {
        player.x += stick_x * MOVE_SPEED * delta_time();
    }
}
}

NCZX_EXPORT void update(void) {
    float stick_x = left_stick_x(0);

    /* Apply deadzone */
    float deadzone = 0.15f;
    if (nczx_absf(stick_x) > deadzone) {
        player_x += stick_x * MOVE_SPEED * delta_time();
    }
}

export fn update() void {
    const stick_x = left_stick_x(0);

    // Apply deadzone
    const deadzone = 0.15;
    if (@abs(stick_x) > deadzone) {
        player_x += stick_x * MOVE_SPEED * delta_time();
    }
}

#![allow(unused)]
fn main() {
fn left_stick_y(player: u32) -> f32
}

NCZX_IMPORT float left_stick_y(uint32_t player);

pub extern fn left_stick_y(player: u32) f32;

#![allow(unused)]
fn main() {
fn right_stick_x(player: u32) -> f32
}

NCZX_IMPORT float right_stick_x(uint32_t player);

pub extern fn right_stick_x(player: u32) f32;

#![allow(unused)]
fn main() {
fn update() {
    // Camera control with right stick
    camera_yaw += right_stick_x(0) * CAMERA_SPEED * delta_time();
}
}

NCZX_EXPORT void update(void) {
    /* Camera control with right stick */
    camera_yaw += right_stick_x(0) * CAMERA_SPEED * delta_time();
}

export fn update() void {
    // Camera control with right stick
    camera_yaw += right_stick_x(0) * CAMERA_SPEED * delta_time();
}

#![allow(unused)]
fn main() {
fn right_stick_y(player: u32) -> f32
}

NCZX_IMPORT float right_stick_y(uint32_t player);

pub extern fn right_stick_y(player: u32) f32;

#![allow(unused)]
fn main() {
fn left_stick(player: u32, out_x: *mut f32, out_y: *mut f32)
}

NCZX_IMPORT void left_stick(uint32_t player, float* out_x, float* out_y);

pub extern fn left_stick(player: u32, out_x: *f32, out_y: *f32) void;

#![allow(unused)]
fn main() {
fn update() {
    let mut x: f32 = 0.0;
    let mut y: f32 = 0.0;
    left_stick(0, &mut x, &mut y);

    // Calculate magnitude for circular deadzone
    let mag = (x * x + y * y).sqrt();
    if mag > 0.15 {
        let nx = x / mag;
        let ny = y / mag;
        player.x += nx * MOVE_SPEED * delta_time();
        player.y += ny * MOVE_SPEED * delta_time();
    }
}
}

NCZX_EXPORT void update(void) {
    float x = 0.0f;
    float y = 0.0f;
    left_stick(0, &x, &y);

    /* Calculate magnitude for circular deadzone */
    float mag = sqrtf(x * x + y * y);
    if (mag > 0.15f) {
        float nx = x / mag;
        float ny = y / mag;
        player_x += nx * MOVE_SPEED * delta_time();
        player_y += ny * MOVE_SPEED * delta_time();
    }
}

export fn update() void {
    var x: f32 = 0.0;
    var y: f32 = 0.0;
    left_stick(0, &x, &y);

    // Calculate magnitude for circular deadzone
    const mag = @sqrt(x * x + y * y);
    if (mag > 0.15) {
        const nx = x / mag;
        const ny = y / mag;
        player_x += nx * MOVE_SPEED * delta_time();
        player_y += ny * MOVE_SPEED * delta_time();
    }
}

#![allow(unused)]
fn main() {
fn right_stick(player: u32, out_x: *mut f32, out_y: *mut f32)
}

NCZX_IMPORT void right_stick(uint32_t player, float* out_x, float* out_y);

pub extern fn right_stick(player: u32, out_x: *f32, out_y: *f32) void;

#![allow(unused)]
fn main() {
fn trigger_left(player: u32) -> f32
}

NCZX_IMPORT float trigger_left(uint32_t player);

pub extern fn trigger_left(player: u32) f32;

#![allow(unused)]
fn main() {
fn update() {
    let lt = trigger_left(0);

    // Brake with analog pressure
    if lt > 0.1 {
        vehicle.speed *= 1.0 - (lt * BRAKE_FORCE * delta_time());
    }
}
}

NCZX_EXPORT void update(void) {
    float lt = trigger_left(0);

    /* Brake with analog pressure */
    if (lt > 0.1f) {
        vehicle_speed *= 1.0f - (lt * BRAKE_FORCE * delta_time());
    }
}

export fn update() void {
    const lt = trigger_left(0);

    // Brake with analog pressure
    if (lt > 0.1) {
        vehicle_speed *= 1.0 - (lt * BRAKE_FORCE * delta_time());
    }
}

#![allow(unused)]
fn main() {
fn trigger_right(player: u32) -> f32
}

NCZX_IMPORT float trigger_right(uint32_t player);

pub extern fn trigger_right(player: u32) f32;

#![allow(unused)]
fn main() {
fn update() {
    let rt = trigger_right(0);

    // Accelerate with analog pressure
    if rt > 0.1 {
        vehicle.speed += rt * ACCEL_FORCE * delta_time();
    }

    // Aiming zoom
    let zoom = 1.0 + rt * 2.0; // 1x to 3x zoom
    camera_fov(60.0 / zoom);
}
}

NCZX_EXPORT void update(void) {
    float rt = trigger_right(0);

    /* Accelerate with analog pressure */
    if (rt > 0.1f) {
        vehicle_speed += rt * ACCEL_FORCE * delta_time();
    }

    /* Aiming zoom */
    float zoom = 1.0f + rt * 2.0f; /* 1x to 3x zoom */
    camera_fov(60.0f / zoom);
}

export fn update() void {
    const rt = trigger_right(0);

    // Accelerate with analog pressure
    if (rt > 0.1) {
        vehicle_speed += rt * ACCEL_FORCE * delta_time();
    }

    // Aiming zoom
    const zoom = 1.0 + rt * 2.0; // 1x to 3x zoom
    camera_fov(60.0 / zoom);
}

#![allow(unused)]
fn main() {
const BUTTON_A: u32 = 4;
const BUTTON_B: u32 = 5;
const MOVE_SPEED: f32 = 100.0;
const DEADZONE: f32 = 0.15;

static mut PLAYER_X: f32 = 0.0;
static mut PLAYER_Y: f32 = 0.0;
static mut ON_GROUND: bool = true;
static mut VEL_Y: f32 = 0.0;

#[no_mangle]
pub extern "C" fn update() {
    unsafe {
        let dt = delta_time();

        // Movement with left stick
        let mut sx: f32 = 0.0;
        let mut sy: f32 = 0.0;
        left_stick(0, &mut sx, &mut sy);

        if sx.abs() > DEADZONE {
            PLAYER_X += sx * MOVE_SPEED * dt;
        }

        // Jump with A button
        if button_pressed(0, BUTTON_A) != 0 && ON_GROUND {
            VEL_Y = -300.0;
            ON_GROUND = false;
        }

        // Gravity
        VEL_Y += 800.0 * dt;
        PLAYER_Y += VEL_Y * dt;

        // Ground collision
        if PLAYER_Y >= 200.0 {
            PLAYER_Y = 200.0;
            VEL_Y = 0.0;
            ON_GROUND = true;
        }
    }
}
}

#define MOVE_SPEED 100.0f
#define DEADZONE 0.15f

static float player_x = 0.0f;
static float player_y = 0.0f;
static int on_ground = 1;
static float vel_y = 0.0f;

NCZX_EXPORT void update(void) {
    float dt = delta_time();

    /* Movement with left stick */
    float sx = 0.0f;
    float sy = 0.0f;
    left_stick(0, &sx, &sy);

    if (nczx_absf(sx) > DEADZONE) {
        player_x += sx * MOVE_SPEED * dt;
    }

    /* Jump with A button */
    if (button_pressed(0, NCZX_BUTTON_A) && on_ground) {
        vel_y = -300.0f;
        on_ground = 0;
    }

    /* Gravity */
    vel_y += 800.0f * dt;
    player_y += vel_y * dt;

    /* Ground collision */
    if (player_y >= 200.0f) {
        player_y = 200.0f;
        vel_y = 0.0f;
        on_ground = 1;
    }
}

const MOVE_SPEED: f32 = 100.0;
const DEADZONE: f32 = 0.15;

var player_x: f32 = 0.0;
var player_y: f32 = 0.0;
var on_ground: bool = true;
var vel_y: f32 = 0.0;

export fn update() void {
    const dt = delta_time();

    // Movement with left stick
    var sx: f32 = 0.0;
    var sy: f32 = 0.0;
    left_stick(0, &sx, &sy);

    if (@abs(sx) > DEADZONE) {
        player_x += sx * MOVE_SPEED * dt;
    }

    // Jump with A button
    if (button_pressed(0, Button.a) != 0 and on_ground) {
        vel_y = -300.0;
        on_ground = false;
    }

    // Gravity
    vel_y += 800.0 * dt;
    player_y += vel_y * dt;

    // Ground collision
    if (player_y >= 200.0) {
        player_y = 200.0;
        vel_y = 0.0;
        on_ground = true;
    }
}

#![allow(unused)]
fn main() {
fn set_tick_rate(fps: u32)
}

NCZX_IMPORT void set_tick_rate(uint32_t fps);

pub extern fn set_tick_rate(fps: u32) void;

#![allow(unused)]
fn main() {
fn init() {
    set_tick_rate(2); // 60 fps
}
}

NCZX_EXPORT void init(void) {
    set_tick_rate(2); // 60 fps
}

export fn init() void {
    set_tick_rate(2); // 60 fps
}

#![allow(unused)]
fn main() {
fn set_clear_color(color: u32)
}

NCZX_IMPORT void set_clear_color(uint32_t color);

pub extern fn set_clear_color(color: u32) void;

#![allow(unused)]
fn main() {
fn init() {
    set_clear_color(0x1a1a2eFF); // Dark blue
    set_clear_color(0x87CEEBFF); // Sky blue
}
}

NCZX_EXPORT void init(void) {
    set_clear_color(0x1a1a2eFF); // Dark blue
    set_clear_color(0x87CEEBFF); // Sky blue
}

export fn init() void {
    set_clear_color(0x1a1a2eFF); // Dark blue
    set_clear_color(0x87CEEBFF); // Sky blue
}

#![allow(unused)]
fn main() {
fn render_mode(mode: u32)
}

NCZX_IMPORT void render_mode(uint32_t mode);

pub extern fn render_mode(mode: u32) void;

#![allow(unused)]
fn main() {
fn init() {
    render_mode(2); // PBR-style lighting
}
}

NCZX_EXPORT void init(void) {
    render_mode(2); // PBR-style lighting
}

export fn init() void {
    render_mode(2); // PBR-style lighting
}

#![allow(unused)]
fn main() {
fn set_color(color: u32)
}

NCZX_IMPORT void set_color(uint32_t color);

pub extern fn set_color(color: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // White (no tint)
    set_color(0xFFFFFFFF);
    draw_mesh(model);

    // Red tint
    set_color(0xFF0000FF);
    draw_mesh(enemy);

    // 50% transparent
    set_color(0xFFFFFF80);
    draw_mesh(ghost);
}
}

NCZX_EXPORT void render(void) {
    // White (no tint)
    set_color(0xFFFFFFFF);
    draw_mesh(model);

    // Red tint
    set_color(0xFF0000FF);
    draw_mesh(enemy);

    // 50% transparent
    set_color(0xFFFFFF80);
    draw_mesh(ghost);
}

export fn render() void {
    // White (no tint)
    set_color(0xFFFFFFFF);
    draw_mesh(model);

    // Red tint
    set_color(0xFF0000FF);
    draw_mesh(enemy);

    // 50% transparent
    set_color(0xFFFFFF80);
    draw_mesh(ghost);
}

#![allow(unused)]
fn main() {
fn cull_mode(mode: u32)
}

NCZX_IMPORT void cull_mode(uint32_t mode);

pub extern fn cull_mode(mode: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Normal geometry
    cull_mode(1); // Back-face culling
    draw_mesh(solid_object);

    // Skybox (inside-out)
    cull_mode(2); // Front-face culling
    draw_mesh(skybox);

    // Double-sided foliage
    cull_mode(0); // No culling
    draw_mesh(leaves);
}
}

NCZX_EXPORT void render(void) {
    // Normal geometry
    cull_mode(1); // Back-face culling
    draw_mesh(solid_object);

    // Skybox (inside-out)
    cull_mode(2); // Front-face culling
    draw_mesh(skybox);

    // Double-sided foliage
    cull_mode(0); // No culling
    draw_mesh(leaves);
}

export fn render() void {
    // Normal geometry
    cull_mode(1); // Back-face culling
    draw_mesh(solid_object);

    // Skybox (inside-out)
    cull_mode(2); // Front-face culling
    draw_mesh(skybox);

    // Double-sided foliage
    cull_mode(0); // No culling
    draw_mesh(leaves);
}

#![allow(unused)]
fn main() {
fn texture_filter(filter: u32)
}

NCZX_IMPORT void texture_filter(uint32_t filter);

pub extern fn texture_filter(filter: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Pixel art sprites
    texture_filter(0);
    set_color(0xFFFFFFFF);
    draw_sprite(0.0, 0.0, 64.0, 64.0);

    // Photo textures
    texture_filter(1);
    draw_mesh(realistic_model);
}
}

NCZX_EXPORT void render(void) {
    // Pixel art sprites
    texture_filter(0);
    set_color(0xFFFFFFFF);
    draw_sprite(0.0f, 0.0f, 64.0f, 64.0f);

    // Photo textures
    texture_filter(1);
    draw_mesh(realistic_model);
}

export fn render() void {
    // Pixel art sprites
    texture_filter(0);
    set_color(0xFFFFFFFF);
    draw_sprite(0.0, 0.0, 64.0, 64.0);

    // Photo textures
    texture_filter(1);
    draw_mesh(realistic_model);
}

#![allow(unused)]
fn main() {
fn uniform_alpha(level: u32)
}

NCZX_IMPORT void uniform_alpha(uint32_t level);

pub extern fn uniform_alpha(level: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Fade in effect
    let alpha = (fade_progress * 15.0) as u32;
    uniform_alpha(alpha);
    draw_mesh(fading_object);

    // Reset to fully opaque
    uniform_alpha(15);
}
}

NCZX_EXPORT void render(void) {
    // Fade in effect
    uint32_t alpha = (uint32_t)(fade_progress * 15.0f);
    uniform_alpha(alpha);
    draw_mesh(fading_object);

    // Reset to fully opaque
    uniform_alpha(15);
}

export fn render() void {
    // Fade in effect
    const alpha: u32 = @intFromFloat(fade_progress * 15.0);
    uniform_alpha(alpha);
    draw_mesh(fading_object);

    // Reset to fully opaque
    uniform_alpha(15);
}

#![allow(unused)]
fn main() {
fn dither_offset(x: u32, y: u32)
}

NCZX_IMPORT void dither_offset(uint32_t x, uint32_t y);

pub extern fn dither_offset(x: u32, y: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Animate dither pattern for shimmer effect
    let frame = tick_count() as u32;
    dither_offset(frame % 4, (frame / 4) % 4);
}
}

NCZX_EXPORT void render(void) {
    // Animate dither pattern for shimmer effect
    uint32_t frame = (uint32_t)tick_count();
    dither_offset(frame % 4, (frame / 4) % 4);
}

export fn render() void {
    // Animate dither pattern for shimmer effect
    const frame: u32 = @intCast(tick_count());
    dither_offset(frame % 4, (frame / 4) % 4);
}

#![allow(unused)]
fn main() {
fn begin_pass(clear_depth: u32)
}

NCZX_IMPORT void begin_pass(uint32_t clear_depth);

pub extern fn begin_pass(clear_depth: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Draw world normally
    draw_mesh(world);

    // Start new pass, clear depth to draw gun on top
    begin_pass(1);
    draw_mesh(fps_gun);
}
}

NCZX_EXPORT void render(void) {
    // Draw world normally
    draw_mesh(world);

    // Start new pass, clear depth to draw gun on top
    begin_pass(1);
    draw_mesh(fps_gun);
}

export fn render() void {
    // Draw world normally
    draw_mesh(world);

    // Start new pass, clear depth to draw gun on top
    begin_pass(1);
    draw_mesh(fps_gun);
}

#![allow(unused)]
fn main() {
fn begin_pass_stencil_write(ref_value: u32, clear_depth: u32)
}

NCZX_IMPORT void begin_pass_stencil_write(uint32_t ref_value, uint32_t clear_depth);

pub extern fn begin_pass_stencil_write(ref_value: u32, clear_depth: u32) void;

#![allow(unused)]
fn main() {
fn begin_pass_stencil_test(ref_value: u32, clear_depth: u32)
}

NCZX_IMPORT void begin_pass_stencil_test(uint32_t ref_value, uint32_t clear_depth);

pub extern fn begin_pass_stencil_test(ref_value: u32, clear_depth: u32) void;

#![allow(unused)]
fn main() {
fn begin_pass_full(
    depth_compare: u32,
    depth_write: u32,
    clear_depth: u32,
    stencil_compare: u32,
    stencil_ref: u32,
    stencil_pass_op: u32,
    stencil_fail_op: u32,
    stencil_depth_fail_op: u32,
)
}

NCZX_IMPORT void begin_pass_full(
    uint32_t depth_compare,
    uint32_t depth_write,
    uint32_t clear_depth,
    uint32_t stencil_compare,
    uint32_t stencil_ref,
    uint32_t stencil_pass_op,
    uint32_t stencil_fail_op,
    uint32_t stencil_depth_fail_op
);

pub extern fn begin_pass_full(
    depth_compare: u32,
    depth_write: u32,
    clear_depth: u32,
    stencil_compare: u32,
    stencil_ref: u32,
    stencil_pass_op: u32,
    stencil_fail_op: u32,
    stencil_depth_fail_op: u32,
) void;

#![allow(unused)]
fn main() {
fn z_index(n: u32)
}

NCZX_IMPORT void z_index(uint32_t n);

pub extern fn z_index(n: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Background (lowest)
    z_index(0);
    set_color(bg_color);
    draw_sprite(bg_x, bg_y, bg_w, bg_h);

    // Game objects
    z_index(1);
    set_color(obj_color);
    draw_sprite(obj_x, obj_y, obj_w, obj_h);

    // UI on top
    z_index(2);
    set_color(ui_color);
    draw_sprite(ui_x, ui_y, ui_w, ui_h);
}
}

NCZX_EXPORT void render(void) {
    // Background (lowest)
    z_index(0);
    set_color(bg_color);
    draw_sprite(bg_x, bg_y, bg_w, bg_h);

    // Game objects
    z_index(1);
    set_color(obj_color);
    draw_sprite(obj_x, obj_y, obj_w, obj_h);

    // UI on top
    z_index(2);
    set_color(ui_color);
    draw_sprite(ui_x, ui_y, ui_w, ui_h);
}

export fn render() void {
    // Background (lowest)
    z_index(0);
    set_color(bg_color);
    draw_sprite(bg_x, bg_y, bg_w, bg_h);

    // Game objects
    z_index(1);
    set_color(obj_color);
    draw_sprite(obj_x, obj_y, obj_w, obj_h);

    // UI on top
    z_index(2);
    set_color(ui_color);
    draw_sprite(ui_x, ui_y, ui_w, ui_h);
}

#![allow(unused)]
fn main() {
fn viewport(x: u32, y: u32, width: u32, height: u32)
}

NCZX_IMPORT void viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height);

pub extern fn viewport(x: u32, y: u32, width: u32, height: u32) void;

#![allow(unused)]
fn main() {
fn render() {
    // 2-player horizontal split

    // Left half (player 1)
    viewport(0, 0, 480, 540);
    camera_position(p1.x, p1.y, p1.z);
    draw_mesh(world);
    set_color(0xFFFFFFFF);
    draw_text_str("P1", 10.0, 10.0, 16.0);

    // Right half (player 2)
    viewport(480, 0, 480, 540);
    camera_position(p2.x, p2.y, p2.z);
    draw_mesh(world);
    set_color(0xFFFFFFFF);
    draw_text_str("P2", 10.0, 10.0, 16.0);

    // Reset to fullscreen for shared UI
    viewport_clear();
    set_color(0xFFFFFFFF);
    draw_text_str("SCORE: 1000", 400.0, 10.0, 16.0);
}
}

NCZX_EXPORT void render(void) {
    // 2-player horizontal split

    // Left half (player 1)
    viewport(0, 0, 480, 540);
    camera_position(p1.x, p1.y, p1.z);
    draw_mesh(world);
    set_color(0xFFFFFFFF);
    draw_text("P1", 2, 10.0f, 10.0f, 16.0f);

    // Right half (player 2)
    viewport(480, 0, 480, 540);
    camera_position(p2.x, p2.y, p2.z);
    draw_mesh(world);
    set_color(0xFFFFFFFF);
    draw_text("P2", 2, 10.0f, 10.0f, 16.0f);

    // Reset to fullscreen for shared UI
    viewport_clear();
    set_color(0xFFFFFFFF);
    draw_text("SCORE: 1000", 11, 400.0f, 10.0f, 16.0f);
}

export fn render() void {
    // 2-player horizontal split

    // Left half (player 1)
    viewport(0, 0, 480, 540);
    camera_position(p1.x, p1.y, p1.z);
    draw_mesh(world);
    set_color(0xFFFFFFFF);
    draw_text("P1", 2, 10.0, 10.0, 16.0);

    // Right half (player 2)
    viewport(480, 0, 480, 540);
    camera_position(p2.x, p2.y, p2.z);
    draw_mesh(world);
    set_color(0xFFFFFFFF);
    draw_text("P2", 2, 10.0, 10.0, 16.0);

    // Reset to fullscreen for shared UI
    viewport_clear();
    set_color(0xFFFFFFFF);
    draw_text("SCORE: 1000", 11, 400.0, 10.0, 16.0);
}

#![allow(unused)]
fn main() {
fn viewport_clear()
}

NCZX_IMPORT void viewport_clear(void);

pub extern fn viewport_clear() void;

#![allow(unused)]
fn main() {
fn render() {
    // Draw player viewports...
    viewport(0, 0, 480, 540);
    // ... render player 1 ...

    viewport(480, 0, 480, 540);
    // ... render player 2 ...

    // Back to fullscreen for UI overlay
    viewport_clear();
    z_index(10);
    set_color(0x00000080);
    draw_rect(0.0, 500.0, 960.0, 40.0);  // Bottom bar
}
}

NCZX_EXPORT void render(void) {
    // Draw player viewports...
    viewport(0, 0, 480, 540);
    // ... render player 1 ...

    viewport(480, 0, 480, 540);
    // ... render player 2 ...

    // Back to fullscreen for UI overlay
    viewport_clear();
    z_index(10);
    set_color(0x00000080);
    draw_rect(0.0f, 500.0f, 960.0f, 40.0f);  // Bottom bar
}

export fn render() void {
    // Draw player viewports...
    viewport(0, 0, 480, 540);
    // ... render player 1 ...

    viewport(480, 0, 480, 540);
    // ... render player 2 ...

    // Back to fullscreen for UI overlay
    viewport_clear();
    z_index(10);
    set_color(0x00000080);
    draw_rect(0.0, 500.0, 960.0, 40.0);  // Bottom bar
}

#![allow(unused)]
fn main() {
fn render() {
    // 1. Draw main world
    draw_mesh(main_world);

    // 2. Write portal shape to stencil buffer (invisible)
    begin_pass_stencil_write(1, 0);
    draw_mesh(portal_quad);

    // 3. Draw portal interior (only where stencil == 1, clear depth)
    begin_pass_stencil_test(1, 1);
    draw_mesh(other_world);

    // 4. Return to normal rendering
    begin_pass(0);
    draw_mesh(portal_frame);
}
}

NCZX_EXPORT void render(void) {
    // 1. Draw main world
    draw_mesh(main_world);

    // 2. Write portal shape to stencil buffer (invisible)
    begin_pass_stencil_write(1, 0);
    draw_mesh(portal_quad);

    // 3. Draw portal interior (only where stencil == 1, clear depth)
    begin_pass_stencil_test(1, 1);
    draw_mesh(other_world);

    // 4. Return to normal rendering
    begin_pass(0);
    draw_mesh(portal_frame);
}

export fn render() void {
    // 1. Draw main world
    draw_mesh(main_world);

    // 2. Write portal shape to stencil buffer (invisible)
    begin_pass_stencil_write(1, 0);
    draw_mesh(portal_quad);

    // 3. Draw portal interior (only where stencil == 1, clear depth)
    begin_pass_stencil_test(1, 1);
    draw_mesh(other_world);

    // 4. Return to normal rendering
    begin_pass(0);
    draw_mesh(portal_frame);
}

#![allow(unused)]
fn main() {
fn init() {
    // Configure console
    set_tick_rate(2);         // 60 fps
    set_clear_color(0x1a1a2eFF);
    render_mode(2);           // PBR lighting
}

fn render() {
    // Draw 3D scene (depth testing is enabled by default)
    cull_mode(1);  // Enable back-face culling for performance
    texture_filter(1);

    set_color(0xFFFFFFFF);
    draw_mesh(level);
    draw_mesh(player);

    // Draw semi-transparent water using dithering
    uniform_alpha(8);  // 50% alpha via ordered dithering
    set_color(0x4080FFFF);
    draw_mesh(water);
    uniform_alpha(15);  // Reset to fully opaque

    // Draw UI (2D draws are always on top via z_index)
    texture_filter(0);
    z_index(1);
    set_color(0xFFFFFFFF);
    draw_sprite(10.0, 10.0, 200.0, 50.0);
}
}

NCZX_EXPORT void init(void) {
    // Configure console
    set_tick_rate(2);         // 60 fps
    set_clear_color(0x1a1a2eFF);
    render_mode(2);           // PBR lighting
}

NCZX_EXPORT void render(void) {
    // Draw 3D scene (depth testing is enabled by default)
    cull_mode(1);  // Enable back-face culling for performance
    texture_filter(1);

    set_color(0xFFFFFFFF);
    draw_mesh(level);
    draw_mesh(player);

    // Draw semi-transparent water using dithering
    uniform_alpha(8);  // 50% alpha via ordered dithering
    set_color(0x4080FFFF);
    draw_mesh(water);
    uniform_alpha(15);  // Reset to fully opaque

    // Draw UI (2D draws are always on top via z_index)
    texture_filter(0);
    z_index(1);
    set_color(0xFFFFFFFF);
    draw_sprite(10.0f, 10.0f, 200.0f, 50.0f);
}

export fn init() void {
    // Configure console
    set_tick_rate(2);         // 60 fps
    set_clear_color(0x1a1a2eFF);
    render_mode(2);           // PBR lighting
}

export fn render() void {
    // Draw 3D scene (depth testing is enabled by default)
    cull_mode(1);  // Enable back-face culling for performance
    texture_filter(1);

    set_color(0xFFFFFFFF);
    draw_mesh(level);
    draw_mesh(player);

    // Draw semi-transparent water using dithering
    uniform_alpha(8);  // 50% alpha via ordered dithering
    set_color(0x4080FFFF);
    draw_mesh(water);
    uniform_alpha(15);  // Reset to fully opaque

    // Draw UI (2D draws are always on top via z_index)
    texture_filter(0);
    z_index(1);
    set_color(0xFFFFFFFF);
    draw_sprite(10.0, 10.0, 200.0, 50.0);
}

#![allow(unused)]
fn main() {
fn camera_set(x: f32, y: f32, z: f32, target_x: f32, target_y: f32, target_z: f32)
}

NCZX_IMPORT void camera_set(float x, float y, float z, float target_x, float target_y, float target_z);

pub extern fn camera_set(x: f32, y: f32, z: f32, target_x: f32, target_y: f32, target_z: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Fixed camera looking at origin
    camera_set(0.0, 5.0, 10.0, 0.0, 0.0, 0.0);

    // Third-person follow camera
    camera_set(
        player.x,
        player.y + 3.0,
        player.z + 8.0,
        player.x,
        player.y + 1.0,
        player.z
    );
}
}

NCZX_EXPORT void render(void) {
    /* Fixed camera looking at origin */
    camera_set(0.0f, 5.0f, 10.0f, 0.0f, 0.0f, 0.0f);

    /* Third-person follow camera */
    camera_set(
        player_x,
        player_y + 3.0f,
        player_z + 8.0f,
        player_x,
        player_y + 1.0f,
        player_z
    );
}

export fn render() void {
    // Fixed camera looking at origin
    camera_set(0.0, 5.0, 10.0, 0.0, 0.0, 0.0);

    // Third-person follow camera
    camera_set(
        player_x,
        player_y + 3.0,
        player_z + 8.0,
        player_x,
        player_y + 1.0,
        player_z
    );
}

#![allow(unused)]
fn main() {
fn camera_fov(fov_degrees: f32)
}

NCZX_IMPORT void camera_fov(float fov_degrees);

pub extern fn camera_fov(fov_degrees: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Normal gameplay
    camera_fov(60.0);

    // Zoom in for aiming
    if aiming {
        camera_fov(30.0);
    }

    // Wide angle for racing
    camera_fov(90.0);
}
}

NCZX_EXPORT void render(void) {
    /* Normal gameplay */
    camera_fov(60.0f);

    /* Zoom in for aiming */
    if (aiming) {
        camera_fov(30.0f);
    }

    /* Wide angle for racing */
    camera_fov(90.0f);
}

export fn render() void {
    // Normal gameplay
    camera_fov(60.0);

    // Zoom in for aiming
    if (aiming) {
        camera_fov(30.0);
    }

    // Wide angle for racing
    camera_fov(90.0);
}

#![allow(unused)]
fn main() {
fn push_view_matrix(
    m0: f32, m1: f32, m2: f32, m3: f32,
    m4: f32, m5: f32, m6: f32, m7: f32,
    m8: f32, m9: f32, m10: f32, m11: f32,
    m12: f32, m13: f32, m14: f32, m15: f32
)
}

NCZX_IMPORT void push_view_matrix(
    float m0, float m1, float m2, float m3,
    float m4, float m5, float m6, float m7,
    float m8, float m9, float m10, float m11,
    float m12, float m13, float m14, float m15
);

// 16 individual f32 parameters for the 4x4 matrix

#![allow(unused)]
fn main() {
fn render() {
    // Using glam for matrix math
    let eye = Vec3::new(0.0, 5.0, 10.0);
    let target = Vec3::new(0.0, 0.0, 0.0);
    let up = Vec3::Y;
    let view = Mat4::look_at_rh(eye, target, up);

    let cols = view.to_cols_array();
    push_view_matrix(
        cols[0], cols[1], cols[2], cols[3],
        cols[4], cols[5], cols[6], cols[7],
        cols[8], cols[9], cols[10], cols[11],
        cols[12], cols[13], cols[14], cols[15]
    );
}
}

NCZX_EXPORT void render(void) {
    /* Using a math library for matrix calculation */
    float view[16];
    mat4_look_at(view, eye, target, up);

    push_view_matrix(
        view[0], view[1], view[2], view[3],
        view[4], view[5], view[6], view[7],
        view[8], view[9], view[10], view[11],
        view[12], view[13], view[14], view[15]
    );
}

export fn render() void {
    // Using a math library for matrix calculation
    const view = look_at(eye, target, up);

    // Pass 16 individual floats to push_view_matrix
}

#![allow(unused)]
fn main() {
fn push_projection_matrix(
    m0: f32, m1: f32, m2: f32, m3: f32,
    m4: f32, m5: f32, m6: f32, m7: f32,
    m8: f32, m9: f32, m10: f32, m11: f32,
    m12: f32, m13: f32, m14: f32, m15: f32
)
}

NCZX_IMPORT void push_projection_matrix(
    float m0, float m1, float m2, float m3,
    float m4, float m5, float m6, float m7,
    float m8, float m9, float m10, float m11,
    float m12, float m13, float m14, float m15
);

// 16 individual f32 parameters for the 4x4 matrix

#![allow(unused)]
fn main() {
fn render() {
    // Custom perspective projection
    let aspect = 16.0 / 9.0;
    let fov = 60.0_f32.to_radians();
    let near = 0.1;
    let far = 1000.0;
    let proj = Mat4::perspective_rh(fov, aspect, near, far);

    let cols = proj.to_cols_array();
    push_projection_matrix(
        cols[0], cols[1], cols[2], cols[3],
        cols[4], cols[5], cols[6], cols[7],
        cols[8], cols[9], cols[10], cols[11],
        cols[12], cols[13], cols[14], cols[15]
    );

    // Orthographic projection for 2D
    let ortho = Mat4::orthographic_rh(0.0, 960.0, 540.0, 0.0, -1.0, 1.0);
    // ... push_projection_matrix with ortho values
}
}

NCZX_EXPORT void render(void) {
    /* Custom perspective projection */
    float aspect = 16.0f / 9.0f;
    float fov = 60.0f * 3.14159f / 180.0f;
    float near = 0.1f;
    float far = 1000.0f;
    float proj[16];
    mat4_perspective(proj, fov, aspect, near, far);

    push_projection_matrix(
        proj[0], proj[1], proj[2], proj[3],
        proj[4], proj[5], proj[6], proj[7],
        proj[8], proj[9], proj[10], proj[11],
        proj[12], proj[13], proj[14], proj[15]
    );
}

export fn render() void {
    // Custom perspective projection
    const aspect = 16.0 / 9.0;
    const fov = 60.0 * std.math.pi / 180.0;
    const near = 0.1;
    const far = 1000.0;
    const proj = perspective(fov, aspect, near, far);

    // Pass 16 individual floats to push_projection_matrix
}

#![allow(unused)]
fn main() {
static mut ORBIT_ANGLE: f32 = 0.0;
static mut ORBIT_DISTANCE: f32 = 10.0;
static mut ORBIT_HEIGHT: f32 = 5.0;

fn update() {
    unsafe {
        // Rotate with right stick
        ORBIT_ANGLE += right_stick_x(0) * 2.0 * delta_time();

        // Zoom with triggers
        ORBIT_DISTANCE -= trigger_right(0) * 5.0 * delta_time();
        ORBIT_DISTANCE += trigger_left(0) * 5.0 * delta_time();
        ORBIT_DISTANCE = ORBIT_DISTANCE.clamp(5.0, 20.0);
    }
}

fn render() {
    unsafe {
        let cam_x = ORBIT_ANGLE.cos() * ORBIT_DISTANCE;
        let cam_z = ORBIT_ANGLE.sin() * ORBIT_DISTANCE;
        camera_set(cam_x, ORBIT_HEIGHT, cam_z, 0.0, 0.0, 0.0);
    }
}
}

static float orbit_angle = 0.0f;
static float orbit_distance = 10.0f;
static float orbit_height = 5.0f;

NCZX_EXPORT void update(void) {
    /* Rotate with right stick */
    orbit_angle += right_stick_x(0) * 2.0f * delta_time();

    /* Zoom with triggers */
    orbit_distance -= trigger_right(0) * 5.0f * delta_time();
    orbit_distance += trigger_left(0) * 5.0f * delta_time();
    orbit_distance = nczx_clampf(orbit_distance, 5.0f, 20.0f);
}

NCZX_EXPORT void render(void) {
    float cam_x = cosf(orbit_angle) * orbit_distance;
    float cam_z = sinf(orbit_angle) * orbit_distance;
    camera_set(cam_x, orbit_height, cam_z, 0.0f, 0.0f, 0.0f);
}

var orbit_angle: f32 = 0.0;
var orbit_distance: f32 = 10.0;
var orbit_height: f32 = 5.0;

export fn update() void {
    // Rotate with right stick
    orbit_angle += right_stick_x(0) * 2.0 * delta_time();

    // Zoom with triggers
    orbit_distance -= trigger_right(0) * 5.0 * delta_time();
    orbit_distance += trigger_left(0) * 5.0 * delta_time();
    orbit_distance = zx.clampf(orbit_distance, 5.0, 20.0);
}

export fn render() void {
    const cam_x = @cos(orbit_angle) * orbit_distance;
    const cam_z = @sin(orbit_angle) * orbit_distance;
    camera_set(cam_x, orbit_height, cam_z, 0.0, 0.0, 0.0);
}

#![allow(unused)]
fn main() {
static mut CAM_X: f32 = 0.0;
static mut CAM_Y: f32 = 1.7; // Eye height
static mut CAM_Z: f32 = 0.0;
static mut CAM_YAW: f32 = 0.0;
static mut CAM_PITCH: f32 = 0.0;

fn update() {
    unsafe {
        // Look with right stick
        CAM_YAW += right_stick_x(0) * 3.0 * delta_time();
        CAM_PITCH -= right_stick_y(0) * 2.0 * delta_time();
        CAM_PITCH = CAM_PITCH.clamp(-1.4, 1.4); // Limit look up/down

        // Move with left stick
        let forward_x = CAM_YAW.sin();
        let forward_z = CAM_YAW.cos();
        let right_x = forward_z;
        let right_z = -forward_x;

        let speed = 5.0 * delta_time();
        CAM_X += left_stick_y(0) * forward_x * speed;
        CAM_Z += left_stick_y(0) * forward_z * speed;
        CAM_X += left_stick_x(0) * right_x * speed;
        CAM_Z += left_stick_x(0) * right_z * speed;
    }
}

fn render() {
    unsafe {
        let look_x = CAM_X + CAM_YAW.sin() * CAM_PITCH.cos();
        let look_y = CAM_Y + CAM_PITCH.sin();
        let look_z = CAM_Z + CAM_YAW.cos() * CAM_PITCH.cos();
        camera_set(CAM_X, CAM_Y, CAM_Z, look_x, look_y, look_z);
    }
}
}

static float cam_x = 0.0f;
static float cam_y = 1.7f; /* Eye height */
static float cam_z = 0.0f;
static float cam_yaw = 0.0f;
static float cam_pitch = 0.0f;

NCZX_EXPORT void update(void) {
    /* Look with right stick */
    cam_yaw += right_stick_x(0) * 3.0f * delta_time();
    cam_pitch -= right_stick_y(0) * 2.0f * delta_time();
    cam_pitch = nczx_clampf(cam_pitch, -1.4f, 1.4f);

    /* Move with left stick */
    float forward_x = sinf(cam_yaw);
    float forward_z = cosf(cam_yaw);
    float right_x = forward_z;
    float right_z = -forward_x;

    float speed = 5.0f * delta_time();
    cam_x += left_stick_y(0) * forward_x * speed;
    cam_z += left_stick_y(0) * forward_z * speed;
    cam_x += left_stick_x(0) * right_x * speed;
    cam_z += left_stick_x(0) * right_z * speed;
}

NCZX_EXPORT void render(void) {
    float look_x = cam_x + sinf(cam_yaw) * cosf(cam_pitch);
    float look_y = cam_y + sinf(cam_pitch);
    float look_z = cam_z + cosf(cam_yaw) * cosf(cam_pitch);
    camera_set(cam_x, cam_y, cam_z, look_x, look_y, look_z);
}

var cam_x: f32 = 0.0;
var cam_y: f32 = 1.7; // Eye height
var cam_z: f32 = 0.0;
var cam_yaw: f32 = 0.0;
var cam_pitch: f32 = 0.0;

export fn update() void {
    // Look with right stick
    cam_yaw += right_stick_x(0) * 3.0 * delta_time();
    cam_pitch -= right_stick_y(0) * 2.0 * delta_time();
    cam_pitch = zx.clampf(cam_pitch, -1.4, 1.4);

    // Move with left stick
    const forward_x = @sin(cam_yaw);
    const forward_z = @cos(cam_yaw);
    const right_x = forward_z;
    const right_z = -forward_x;

    const speed = 5.0 * delta_time();
    cam_x += left_stick_y(0) * forward_x * speed;
    cam_z += left_stick_y(0) * forward_z * speed;
    cam_x += left_stick_x(0) * right_x * speed;
    cam_z += left_stick_x(0) * right_z * speed;
}

export fn render() void {
    const look_x = cam_x + @sin(cam_yaw) * @cos(cam_pitch);
    const look_y = cam_y + @sin(cam_pitch);
    const look_z = cam_z + @cos(cam_yaw) * @cos(cam_pitch);
    camera_set(cam_x, cam_y, cam_z, look_x, look_y, look_z);
}

#![allow(unused)]
fn main() {
fn render() {
    let count = player_count();

    for p in 0..count {
        // Set viewport (would need custom projection)
        setup_viewport_for_player(p, count);

        // Each player's camera follows them
        camera_set(
            players[p].x,
            players[p].y + 5.0,
            players[p].z + 10.0,
            players[p].x,
            players[p].y,
            players[p].z
        );

        draw_scene();
    }
}
}

NCZX_EXPORT void render(void) {
    uint32_t count = player_count();

    for (uint32_t p = 0; p < count; p++) {
        /* Set viewport (would need custom projection) */
        setup_viewport_for_player(p, count);

        /* Each player's camera follows them */
        camera_set(
            players[p].x,
            players[p].y + 5.0f,
            players[p].z + 10.0f,
            players[p].x,
            players[p].y,
            players[p].z
        );

        draw_scene();
    }
}

export fn render() void {
    const count = player_count();

    var p: u32 = 0;
    while (p < count) : (p += 1) {
        // Set viewport (would need custom projection)
        setup_viewport_for_player(p, count);

        // Each player's camera follows them
        camera_set(
            players[p].x,
            players[p].y + 5.0,
            players[p].z + 10.0,
            players[p].x,
            players[p].y,
            players[p].z
        );

        draw_scene();
    }
}

#![allow(unused)]
fn main() {
fn push_identity()
}

NCZX_IMPORT void push_identity(void);

pub extern fn push_identity() void;

#![allow(unused)]
fn main() {
fn render() {
    // Reset before drawing each object
    push_identity();
    draw_mesh(object_a);

    push_identity();
    push_translate(10.0, 0.0, 0.0);
    draw_mesh(object_b);
}
}

NCZX_EXPORT void render(void) {
    /* Reset before drawing each object */
    push_identity();
    draw_mesh(object_a);

    push_identity();
    push_translate(10.0f, 0.0f, 0.0f);
    draw_mesh(object_b);
}

export fn render() void {
    // Reset before drawing each object
    push_identity();
    draw_mesh(object_a);

    push_identity();
    push_translate(10.0, 0.0, 0.0);
    draw_mesh(object_b);
}

#![allow(unused)]
fn main() {
fn transform_set(matrix_ptr: *const f32)
}

NCZX_IMPORT void transform_set(const float* matrix_ptr);

pub extern fn transform_set(matrix_ptr: [*]const f32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Using glam
    let transform = Mat4::from_scale_rotation_translation(
        Vec3::ONE,
        Quat::from_rotation_y(angle),
        Vec3::new(x, y, z)
    );

    let cols = transform.to_cols_array();
    transform_set(cols.as_ptr());
    draw_mesh(model);
}
}

NCZX_EXPORT void render(void) {
    /* Using a math library */
    float transform[16];
    mat4_from_translation_rotation_scale(transform, pos, rot, scale);

    transform_set(transform);
    draw_mesh(model);
}

export fn render() void {
    // Using a math library
    const transform = from_scale_rotation_translation(scale, rotation, translation);

    transform_set(&transform);
    draw_mesh(model);
}

#![allow(unused)]
fn main() {
fn push_translate(x: f32, y: f32, z: f32)
}

NCZX_IMPORT void push_translate(float x, float y, float z);

pub extern fn push_translate(x: f32, y: f32, z: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    // Position object at (10, 5, 0)
    push_identity();
    push_translate(10.0, 5.0, 0.0);
    draw_mesh(object);

    // Stack translations (additive)
    push_identity();
    push_translate(5.0, 0.0, 0.0);  // Move right 5
    push_translate(0.0, 3.0, 0.0);  // Then move up 3
    draw_mesh(object);  // At (5, 3, 0)
}
}

NCZX_EXPORT void render(void) {
    /* Position object at (10, 5, 0) */
    push_identity();
    push_translate(10.0f, 5.0f, 0.0f);
    draw_mesh(object);

    /* Stack translations (additive) */
    push_identity();
    push_translate(5.0f, 0.0f, 0.0f);  /* Move right 5 */
    push_translate(0.0f, 3.0f, 0.0f);  /* Then move up 3 */
    draw_mesh(object);  /* At (5, 3, 0) */
}

export fn render() void {
    // Position object at (10, 5, 0)
    push_identity();
    push_translate(10.0, 5.0, 0.0);
    draw_mesh(object);

    // Stack translations (additive)
    push_identity();
    push_translate(5.0, 0.0, 0.0);  // Move right 5
    push_translate(0.0, 3.0, 0.0);  // Then move up 3
    draw_mesh(object);  // At (5, 3, 0)
}

#![allow(unused)]
fn main() {
fn push_rotate_x(angle_deg: f32)
}

NCZX_IMPORT void push_rotate_x(float angle_deg);

pub extern fn push_rotate_x(angle_deg: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_rotate_x(45.0); // Tilt forward 45 degrees
    draw_mesh(object);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_rotate_x(45.0f); /* Tilt forward 45 degrees */
    draw_mesh(object);
}

export fn render() void {
    push_identity();
    push_rotate_x(45.0); // Tilt forward 45 degrees
    draw_mesh(object);
}

#![allow(unused)]
fn main() {
fn push_rotate_y(angle_deg: f32)
}

NCZX_IMPORT void push_rotate_y(float angle_deg);

pub extern fn push_rotate_y(angle_deg: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_rotate_y(elapsed_time() * 90.0); // Spin 90 deg/sec
    draw_mesh(spinning_object);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_rotate_y(elapsed_time() * 90.0f); /* Spin 90 deg/sec */
    draw_mesh(spinning_object);
}

export fn render() void {
    push_identity();
    push_rotate_y(elapsed_time() * 90.0); // Spin 90 deg/sec
    draw_mesh(spinning_object);
}

#![allow(unused)]
fn main() {
fn push_rotate_z(angle_deg: f32)
}

NCZX_IMPORT void push_rotate_z(float angle_deg);

pub extern fn push_rotate_z(angle_deg: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_rotate_z(45.0); // Roll 45 degrees
    draw_mesh(object);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_rotate_z(45.0f); /* Roll 45 degrees */
    draw_mesh(object);
}

export fn render() void {
    push_identity();
    push_rotate_z(45.0); // Roll 45 degrees
    draw_mesh(object);
}

#![allow(unused)]
fn main() {
fn push_rotate(angle_deg: f32, axis_x: f32, axis_y: f32, axis_z: f32)
}

NCZX_IMPORT void push_rotate(float angle_deg, float axis_x, float axis_y, float axis_z);

pub extern fn push_rotate(angle_deg: f32, axis_x: f32, axis_y: f32, axis_z: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    // Rotate around diagonal axis
    push_rotate(45.0, 1.0, 1.0, 0.0);
    draw_mesh(object);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    /* Rotate around diagonal axis */
    push_rotate(45.0f, 1.0f, 1.0f, 0.0f);
    draw_mesh(object);
}

export fn render() void {
    push_identity();
    // Rotate around diagonal axis
    push_rotate(45.0, 1.0, 1.0, 0.0);
    draw_mesh(object);
}

#![allow(unused)]
fn main() {
fn push_scale(x: f32, y: f32, z: f32)
}

NCZX_IMPORT void push_scale(float x, float y, float z);

pub extern fn push_scale(x: f32, y: f32, z: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_scale(2.0, 1.0, 1.0); // Stretch horizontally
    draw_mesh(object);

    push_identity();
    push_scale(1.0, 0.5, 1.0); // Squash vertically
    draw_mesh(squashed);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_scale(2.0f, 1.0f, 1.0f); /* Stretch horizontally */
    draw_mesh(object);

    push_identity();
    push_scale(1.0f, 0.5f, 1.0f); /* Squash vertically */
    draw_mesh(squashed);
}

export fn render() void {
    push_identity();
    push_scale(2.0, 1.0, 1.0); // Stretch horizontally
    draw_mesh(object);

    push_identity();
    push_scale(1.0, 0.5, 1.0); // Squash vertically
    draw_mesh(squashed);
}

#![allow(unused)]
fn main() {
fn push_scale_uniform(s: f32)
}

NCZX_IMPORT void push_scale_uniform(float s);

pub extern fn push_scale_uniform(s: f32) void;

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_scale_uniform(2.0); // Double size
    draw_mesh(big_object);

    push_identity();
    push_scale_uniform(0.5); // Half size
    draw_mesh(small_object);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_scale_uniform(2.0f); /* Double size */
    draw_mesh(big_object);

    push_identity();
    push_scale_uniform(0.5f); /* Half size */
    draw_mesh(small_object);
}

export fn render() void {
    push_identity();
    push_scale_uniform(2.0); // Double size
    draw_mesh(big_object);

    push_identity();
    push_scale_uniform(0.5); // Half size
    draw_mesh(small_object);
}

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_translate(5.0, 0.0, 0.0);  // Applied LAST
    push_rotate_y(45.0);             // Applied SECOND
    push_scale_uniform(2.0);         // Applied FIRST
    draw_mesh(object);

    // Equivalent to: Translate * Rotate * Scale * vertex
    // Object is: 1) scaled, 2) rotated, 3) translated
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_translate(5.0f, 0.0f, 0.0f);  /* Applied LAST */
    push_rotate_y(45.0f);               /* Applied SECOND */
    push_scale_uniform(2.0f);           /* Applied FIRST */
    draw_mesh(object);

    /* Equivalent to: Translate * Rotate * Scale * vertex */
    /* Object is: 1) scaled, 2) rotated, 3) translated */
}

export fn render() void {
    push_identity();
    push_translate(5.0, 0.0, 0.0);  // Applied LAST
    push_rotate_y(45.0);             // Applied SECOND
    push_scale_uniform(2.0);         // Applied FIRST
    draw_mesh(object);

    // Equivalent to: Translate * Rotate * Scale * vertex
    // Object is: 1) scaled, 2) rotated, 3) translated
}

#![allow(unused)]
fn main() {
push_identity();
push_translate(obj.x, obj.y, obj.z);  // Position
push_rotate_y(obj.rotation);           // Then rotate
draw_mesh(obj.mesh);
}

push_identity();
push_translate(obj_x, obj_y, obj_z);  /* Position */
push_rotate_y(obj_rotation);           /* Then rotate */
draw_mesh(obj_mesh);

push_identity();
push_translate(obj.x, obj.y, obj.z);  // Position
push_rotate_y(obj.rotation);           // Then rotate
draw_mesh(obj.mesh);

#![allow(unused)]
fn main() {
fn render() {
    // Tank body
    push_identity();
    push_translate(tank.x, tank.y, tank.z);
    push_rotate_y(tank.body_angle);
    draw_mesh(tank_body);

    // Turret (inherits body transform, then adds its own)
    push_translate(0.0, 1.0, 0.0);     // Offset from body
    push_rotate_y(tank.turret_angle);  // Independent rotation
    draw_mesh(tank_turret);

    // Barrel (inherits turret transform)
    push_translate(0.0, 0.5, 2.0);
    push_rotate_x(tank.barrel_pitch);
    draw_mesh(tank_barrel);
}
}

NCZX_EXPORT void render(void) {
    /* Tank body */
    push_identity();
    push_translate(tank_x, tank_y, tank_z);
    push_rotate_y(tank_body_angle);
    draw_mesh(tank_body);

    /* Turret (inherits body transform, then adds its own) */
    push_translate(0.0f, 1.0f, 0.0f);     /* Offset from body */
    push_rotate_y(tank_turret_angle);     /* Independent rotation */
    draw_mesh(tank_turret);

    /* Barrel (inherits turret transform) */
    push_translate(0.0f, 0.5f, 2.0f);
    push_rotate_x(tank_barrel_pitch);
    draw_mesh(tank_barrel);
}

export fn render() void {
    // Tank body
    push_identity();
    push_translate(tank.x, tank.y, tank.z);
    push_rotate_y(tank.body_angle);
    draw_mesh(tank_body);

    // Turret (inherits body transform, then adds its own)
    push_translate(0.0, 1.0, 0.0);     // Offset from body
    push_rotate_y(tank.turret_angle);  // Independent rotation
    draw_mesh(tank_turret);

    // Barrel (inherits turret transform)
    push_translate(0.0, 0.5, 2.0);
    push_rotate_x(tank.barrel_pitch);
    draw_mesh(tank_barrel);
}

#![allow(unused)]
fn main() {
fn render() {
    push_identity();
    push_translate(pivot_x, pivot_y, pivot_z);  // Move to pivot
    push_rotate_y(angle);                        // Rotate
    push_translate(-pivot_x, -pivot_y, -pivot_z); // Move back
    draw_mesh(object);
}
}

NCZX_EXPORT void render(void) {
    push_identity();
    push_translate(pivot_x, pivot_y, pivot_z);  /* Move to pivot */
    push_rotate_y(angle);                        /* Rotate */
    push_translate(-pivot_x, -pivot_y, -pivot_z); /* Move back */
    draw_mesh(object);
}

export fn render() void {
    push_identity();
    push_translate(pivot_x, pivot_y, pivot_z);  // Move to pivot
    push_rotate_y(angle);                        // Rotate
    push_translate(-pivot_x, -pivot_y, -pivot_z); // Move back
    draw_mesh(object);
}

#![allow(unused)]
fn main() {
static mut ANGLE: f32 = 0.0;

fn update() {
    unsafe {
        ANGLE += 90.0 * delta_time(); // 90 degrees per second
    }
}

fn render() {
    unsafe {
        camera_set(0.0, 5.0, 10.0, 0.0, 0.0, 0.0);

        // Spinning cube at origin
        push_identity();
        push_rotate_y(ANGLE);
        draw_mesh(cube);

        // Orbiting cube
        push_identity();
        push_rotate_y(ANGLE * 0.5);    // Orbital rotation
        push_translate(5.0, 0.0, 0.0);  // Distance from center
        push_rotate_y(ANGLE * 2.0);     // Spin on own axis
        push_scale_uniform(0.5);
        draw_mesh(cube);

        // Static cube for reference
        push_identity();
        push_translate(-5.0, 0.0, 0.0);
        draw_mesh(cube);
    }
}
}

static float angle = 0.0f;

NCZX_EXPORT void update(void) {
    angle += 90.0f * delta_time(); /* 90 degrees per second */
}

NCZX_EXPORT void render(void) {
    camera_set(0.0f, 5.0f, 10.0f, 0.0f, 0.0f, 0.0f);

    /* Spinning cube at origin */
    push_identity();
    push_rotate_y(angle);
    draw_mesh(cube);

    /* Orbiting cube */
    push_identity();
    push_rotate_y(angle * 0.5f);    /* Orbital rotation */
    push_translate(5.0f, 0.0f, 0.0f);  /* Distance from center */
    push_rotate_y(angle * 2.0f);     /* Spin on own axis */
    push_scale_uniform(0.5f);
    draw_mesh(cube);

    /* Static cube for reference */
    push_identity();
    push_translate(-5.0f, 0.0f, 0.0f);
    draw_mesh(cube);
}

var angle: f32 = 0.0;

export fn update() void {
    angle += 90.0 * delta_time(); // 90 degrees per second
}

export fn render() void {
    camera_set(0.0, 5.0, 10.0, 0.0, 0.0, 0.0);

    // Spinning cube at origin
    push_identity();
    push_rotate_y(angle);
    draw_mesh(cube);

    // Orbiting cube
    push_identity();
    push_rotate_y(angle * 0.5);    // Orbital rotation
    push_translate(5.0, 0.0, 0.0);  // Distance from center
    push_rotate_y(angle * 2.0);     // Spin on own axis
    push_scale_uniform(0.5);
    draw_mesh(cube);

    // Static cube for reference
    push_identity();
    push_translate(-5.0, 0.0, 0.0);
    draw_mesh(cube);
}

#![allow(unused)]
fn main() {
fn load_texture(width: u32, height: u32, pixels: *const u8) -> u32
}

NCZX_IMPORT uint32_t load_texture(uint32_t width, uint32_t height, const uint8_t* pixels);