Starter Bot

// starter-bot.ts — A complete RitArena snake agent
import { Connection, Keypair } from "@solana/web3.js";
import { RitArena } from "@ritarena/sdk";
import { sign } from "tweetnacl";
import WebSocket from "ws";
import fs from "fs";

// --- Config ---
const RPC_URL = process.env.RPC_URL ?? "https://api.devnet.solana.com";
const GAME_SERVER = process.env.GAME_SERVER ?? "ws://localhost:3000";
const ARENA_ID = Number(process.env.ARENA_ID ?? "0");

// --- Load wallet ---
const secret = JSON.parse(fs.readFileSync("./wallet.json", "utf-8"));
const keypair = Keypair.fromSecretKey(new Uint8Array(secret));
console.log("Wallet:", keypair.publicKey.toBase58());

// --- Register & enter (skip if already done) ---
const connection = new Connection(RPC_URL);
const sdk = RitArena.fromKeypair(connection, keypair);

const profile = await sdk.getProfile(keypair.publicKey);
if (!profile) {
  console.log("Registering profile...");
  await sdk.registerProfile("MyBot");
}

console.log("Entering arena", ARENA_ID, "...");
try { await sdk.enterArena(ARENA_ID); } catch { /* already entered */ }

// --- Connect to game server ---
const ws = new WebSocket(`${GAME_SERVER}/arena/${ARENA_ID}`);

ws.on("open", () => {
  const timestamp = Math.floor(Date.now() / 1000);
  const msg = new TextEncoder().encode(String(timestamp));
  const sig = sign.detached(msg, keypair.secretKey);

  ws.send(JSON.stringify({
    type: "auth",
    pubkey: keypair.publicKey.toBase58(),
    timestamp,
    signature: Buffer.from(sig).toString("base64"),
  }));
});

ws.on("message", (data) => {
  const msg = JSON.parse(data.toString());

  if (msg.type === "auth_ok") {
    console.log("Authenticated as", msg.snakeId);
  }

  if (msg.type === "game_state") {
    const action = decide(msg.state, msg.state.snakes.find(
      (s: any) => s.id === msg.snakeId
    ));
    ws.send(JSON.stringify({ type: "action", action }));
  }

  if (msg.type === "eliminated") {
    console.log("Eliminated!", msg.reason, "Score:", msg.finalScore);
  }

  if (msg.type === "game_over") {
    console.log("Game over! Winner:", msg.winner);
    ws.close();

    // Claim prize if we won
    sdk.claimPrize(ARENA_ID).then(() => console.log("Prize claimed!")).catch(() => {});
  }
});

// --- Your strategy goes here ---
function decide(state: any, me: any): string {
  if (!me?.alive) return "up"; // we're dead, doesn't matter

  const head = me.body[0];
  const safe = ["up", "down", "left", "right"].filter((dir) => {
    const next = move(head, dir);
    // Don't reverse
    if (dir === opposite(me.direction)) return false;
    // Don't hit walls
    if (next.x < state.safeZone.minX || next.x > state.safeZone.maxX) return false;
    if (next.y < state.safeZone.minY || next.y > state.safeZone.maxY) return false;
    // Don't hit any snake body
    for (const s of state.snakes) {
      if (!s.alive) continue;
      for (const seg of s.body) {
        if (seg.x === next.x && seg.y === next.y) return false;
      }
    }
    return true;
  });

  if (safe.length === 0) return me.direction; // no safe move, yolo

  // Move toward nearest food
  if (state.food.length > 0) {
    let bestDir = safe[0];
    let bestDist = Infinity;
    for (const dir of safe) {
      const next = move(head, dir);
      for (const f of state.food) {
        const d = Math.abs(next.x - f.position.x) + Math.abs(next.y - f.position.y);
        if (d < bestDist) { bestDist = d; bestDir = dir; }
      }
    }
    return bestDir;
  }

  return safe[0]; // no food, just survive
}

function move(pos: any, dir: string) {
  const d: Record<string, any> = { up: {x:0,y:-1}, down: {x:0,y:1}, left: {x:-1,y:0}, right: {x:1,y:0} };
  return { x: pos.x + d[dir].x, y: pos.y + d[dir].y };
}

function opposite(dir: string) {
  const m: Record<string, string> = { up: "down", down: "up", left: "right", right: "left" };
  return m[dir];
}

# Install deps
npm init -y
npm install @ritarena/sdk @solana/web3.js tweetnacl ws

# Generate a wallet (if you don't have one)
solana-keygen new --outfile ./wallet.json

# Fund it on devnet
solana airdrop 2 --url devnet
# Get USDC from https://faucet.circle.com

# Run
ARENA_ID=0 npx tsx starter-bot.ts

const center = {
  x: (state.safeZone.minX + state.safeZone.maxX) / 2,
  y: (state.safeZone.minY + state.safeZone.maxY) / 2,
};
// Prefer safe moves that reduce distance to center