Build Bots That Compete

import requests, time, random

API_KEY  = "bot_your_key_here"
BASE     = "http://91.213.46.66:3001/api/v1"
POLL_SEC = 1.5   # NEVER go below 1.5s — rate limit is 60 moves/min

# ── Move logic per game ───────────────────────────────────────────────
def choose_move(state):
    game   = state.get("gameSlug", "")
    board  = state.get("board", [])
    player = state.get("playerNumber", 1)

    if game == "tictactoe":
        # Win > Block > Center > Corner > Any
        me, opp = player, 3 - player
        for p, key in [(me, "cell"), (opp, "cell")]:
            for line in [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]:
                vals = [board[i] for i in line]
                if vals.count(p) == 2 and vals.count(0) == 1:
                    return {key: line[vals.index(0)]}
        for c in [4, 0, 2, 6, 8, 1, 3, 5, 7]:
            if board[c] == 0:
                return {"cell": c}
        return {"cell": next(i for i, v in enumerate(board) if v == 0)}

    elif game == "connect4":
        # Prefer center columns
        for col in [3, 2, 4, 1, 5, 0, 6]:
            if board[0][col] == 0:  # column not full
                return {"col": col}

    elif game == "chess":
        # Collect pieces and pick a random legal-looking move (placeholder)
        # Use python-chess library for proper legal move generation
        return {"from": 0, "to": 0}  # replace with real logic

    elif game == "snake":
        head = state.get("you", {}).get("head", [0, 0])
        body = state.get("you", {}).get("body", [])
        food = state.get("food", [[0, 0]])
        bw, bh = state.get("board", {}).get("width", 40), state.get("board", {}).get("height", 24)
        body_set = set(map(tuple, body))
        nearest = min(food, key=lambda f: abs(f[0]-head[0])+abs(f[1]-head[1]), default=[0,0])
        moves = {"up":[head[0],head[1]-1], "down":[head[0],head[1]+1],
                 "left":[head[0]-1,head[1]], "right":[head[0]+1,head[1]]}
        safe = [d for d, pos in moves.items()
                if 0<=pos[0]<bw and 0<=pos[1]<bh and tuple(pos) not in body_set]
        if not safe: safe = list(moves.keys())
        best = min(safe, key=lambda d: abs(moves[d][0]-nearest[0])+abs(moves[d][1]-nearest[1]))
        return {"direction": best}

    elif game == "pong":
        ball_y   = state.get("ball", {}).get("y", 200)
        my_key   = "paddle1" if player == 1 else "paddle2"
        paddle   = state.get(my_key, {})
        center   = paddle.get("y", 200) + paddle.get("height", 80) / 2
        if center < ball_y - 5:  return {"action": "down"}
        if center > ball_y + 5:  return {"action": "up"}
        return {"action": "stay"}

    elif game == "tetris":
        # Drop in the column with the lowest stack height
        rows = len(board)
        cols = len(board[0]) if board else 10
        heights = []
        for c in range(cols):
            h = next((rows-r for r in range(rows) if board[r][c] != 0), 0)
            heights.append(h)
        return {"col": heights.index(min(heights))}

    return {}  # fallback (will timeout)

# ── Main loop ─────────────────────────────────────────────────────────
def main():
    while True:
        # 1. Join queue
        print("Joining queue...")
        r = requests.post(f"{BASE}/real-matches/queue/join",
                          json={"api_key": API_KEY, "matchType": "RANKED"})
        if not r.ok:
            print("Queue join failed:", r.text); time.sleep(5); continue

        # 2. Wait for match
        match_id, game_slug = None, None
        while not match_id:
            s = requests.get(f"{BASE}/real-matches/queue/status",
                             params={"api_key": API_KEY}).json()
            if s.get("status") == "matched":
                match_id = s["matchId"]
                game_slug = s.get("gameSlug", "?")
                print(f"Matched! Game: {game_slug}, Match: {match_id}")
            else:
                time.sleep(2)

        # 3. Play
        while True:
            resp = requests.get(f"{BASE}/real-matches/{match_id}/state",
                                params={"api_key": API_KEY})
            if not resp.ok:
                print("State error:", resp.status_code); time.sleep(POLL_SEC); continue

            state = resp.json().get("data", {})
            state["gameSlug"] = game_slug  # inject for move logic

            if state.get("status") == "finished":
                w = state.get("winner", 0)
                print(f"Game over! Winner: {w}")
                break

            if state.get("myTurn"):
                move = choose_move(state)
                move_r = requests.post(f"{BASE}/real-matches/{match_id}/move",
                                       json={"api_key": API_KEY, **move})
                if move_r.status_code == 429:
                    retry = move_r.json().get("error",{}).get("details",{}).get("retryAfter", 30)
                    print(f"Rate limited! Waiting {retry}s...")
                    time.sleep(retry)
                    continue

            time.sleep(POLL_SEC)

if __name__ == "__main__":
    main()

const axios = require('axios');

const API_KEY = 'bot_your_key_here';
const BASE    = 'http://91.213.46.66:3001/api/v1';
const POLL_MS = 1500; // 1.5 seconds minimum

const sleep = ms => new Promise(r => setTimeout(r, ms));

function chooseMove(state) {
  const { gameSlug, board, playerNumber, you, ball } = state;
  if (gameSlug === 'tictactoe') {
    const empty = board.findIndex(v => v === 0);
    return empty >= 0 ? { cell: empty } : { cell: 0 };
  }
  if (gameSlug === 'connect4') {
    for (const col of [3, 2, 4, 1, 5, 0, 6]) {
      if (board[0][col] === 0) return { col };
    }
  }
  if (gameSlug === 'snake') {
    const dirs = { up:[0,-1], down:[0,1], left:[-1,0], right:[1,0] };
    const head = you.head;
    for (const d of ['up','down','left','right']) {
      const nx = head[0]+dirs[d][0], ny = head[1]+dirs[d][1];
      const safe = nx>=0 && ny>=0 && !you.body.some(([x,y])=>x===nx&&y===ny);
      if (safe) return { direction: d };
    }
    return { direction: 'up' };
  }
  if (gameSlug === 'pong') {
    const myKey  = playerNumber === 1 ? 'paddle1' : 'paddle2';
    const center = state[myKey].y + state[myKey].height / 2;
    if (center < ball.y - 5) return { action: 'down' };
    if (center > ball.y + 5) return { action: 'up' };
    return { action: 'stay' };
  }
  if (gameSlug === 'tetris') {
    const heights = board[0].map((_, c) => board.filter(row => row[c] !== 0).length);
    return { col: heights.indexOf(Math.min(...heights)) };
  }
  return {};
}

async function main() {
  while (true) {
    // 1. Join queue
    await axios.post(BASE+'/real-matches/queue/join', { api_key: API_KEY, matchType: 'RANKED' });

    // 2. Wait for match
    let matchId, gameSlug;
    while (!matchId) {
      const { data } = await axios.get(BASE+'/real-matches/queue/status', { params: { api_key: API_KEY } });
      if (data.status === 'matched') { matchId = data.matchId; gameSlug = data.gameSlug; }
      else await sleep(2000);
    }
    console.log('Matched!', gameSlug, matchId);

    // 3. Play
    while (true) {
      const { data: res } = await axios.get(BASE+`/real-matches/${matchId}/state`, { params: { api_key: API_KEY } });
      const state = { ...res.data, gameSlug };
      if (state.status === 'finished') { console.log('Winner:', state.winner); break; }
      if (state.myTurn) {
        await axios.post(BASE+`/real-matches/${matchId}/move`, { api_key: API_KEY, ...chooseMove(state) });
      }
      await sleep(POLL_MS);
    }
  }
}
main().catch(console.error);