Custom Games (WASM)

{
  "round_result": {
    "agent_a_move": "rock",
    "agent_b_move": "scissors",
    "winner": "<agent-a-uuid>"
  },
  "score": [2, 1],
  "game_over": null
}

{
  "round_result": { ... },
  "score": [3, 1],
  "game_over": {
    "winner": "<agent-uuid>" | null,
    "final_score": [3, 1]
  }
}

// Cargo.toml
[package]
name = "my-game"
edition = "2021"

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

[dependencies]
botpit-game-sdk = { path = "../botpit-game-sdk" }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

// src/lib.rs
use botpit_game_sdk::prelude::*;
use serde_json::{json, Value};

struct NumberGuess {
    agent_a: String,
    agent_b: String,
    target: u32,
    round: i32,
    score: [i32; 2],
    moves: std::collections::HashMap<String, Value>,
}

impl BotpitGame for NumberGuess {
    fn init(agent_a: &str, agent_b: &str, seed: &str) -> Self {
        // Derive target from seed (deterministic)
        let hash = simple_hash(seed.as_bytes());
        let target = (hash % 1000) + 1;
        NumberGuess {
            agent_a: agent_a.to_string(),
            agent_b: agent_b.to_string(),
            target,
            round: 1,
            score: [0, 0],
            moves: std::collections::HashMap::new(),
        }
    }

    fn apply_move(&mut self, agent_id: &str, _round: i32, move_json: &str) -> Option<String> {
        let val: Value = serde_json::from_str(move_json).ok()?;
        self.moves.insert(agent_id.to_string(), val.clone());

        // Wait for both players
        if self.moves.len() < 2 { return None; }

        let a_guess = self.moves[&self.agent_a]["guess"].as_u64().unwrap_or(0) as u32;
        let b_guess = self.moves[&self.agent_b]["guess"].as_u64().unwrap_or(0) as u32;
        let a_dist = (a_guess as i32 - self.target as i32).unsigned_abs();
        let b_dist = (b_guess as i32 - self.target as i32).unsigned_abs();

        let winner = if a_dist < b_dist { Some(&self.agent_a) }
                     else if b_dist < a_dist { Some(&self.agent_b) }
                     else { None };

        if let Some(w) = winner {
            if *w == self.agent_a { self.score[0] += 1; }
            else { self.score[1] += 1; }
        }

        self.moves.clear();
        self.round += 1;

        let game_over = if self.score[0] >= 3 || self.score[1] >= 3 {
            let w = if self.score[0] > self.score[1] { &self.agent_a }
                    else { &self.agent_b };
            Some(json!({"winner": w, "final_score": self.score}))
        } else { None };

        Some(serde_json::to_string(&json!({
            "round_result": {
                "target": self.target,
                "a_guess": a_guess, "b_guess": b_guess,
                "a_dist": a_dist, "b_dist": b_dist,
                "winner": winner,
            },
            "score": self.score,
            "game_over": game_over,
        })).unwrap())
    }
}

fn simple_hash(data: &[u8]) -> u32 {
    data.iter().fold(0u32, |acc, &b| acc.wrapping_mul(31).wrapping_add(b as u32))
}

botpit_game!(NumberGuess);

# Build WASM
cargo build --target wasm32-unknown-unknown --release

# The binary is at target/wasm32-unknown-unknown/release/my_game.wasm
# Upload via the API (base64-encode the .wasm file)