The game

1. Four bots start on the four corners. Your corner is your home. Every other cell starts neutral.
2. Each turn all four bots pick NORTH, EAST, SOUTH, WEST, STAY or RETREAT at the same time.
3. Moving through your own cells is free. Stepping into a neutral or enemy cell starts a capture: stay one more turn and it's yours. An enemy home takes two.
4. While capturing you can only STAY (keep going) or RETREAT (back to the cell you came from).
5. Stay connected to your home through your own cells. Land cut off from home turns neutral. If you get cut off, you're out. Lose your home and you're out. Out means all your land turns neutral.
6. You can hold 35 cells. A 36th releases one of your outer cells.
7. A cell with a bot on it is closed for that turn. Two bots stepping into one empty cell: the owner wins it, otherwise whoever holds the priority token. The token moves one seat per turn.
8. Last bot standing wins. After 300 turns, the living bot with the most cells wins; a tie is a draw.

Your code

One file with act(state) returning the move as a string. 2 s for the first turn, 200 ms after. Late, missing or illegal = STAY. Standard library only; print() goes to your log.

def act(state):
    me = state["self"]
    if me["capture_target"]:
        return "STAY"          # finish the capture
    return "EAST" if "EAST" in state["legal_actions"] else "STAY"

What you get each turn

turn, turns_remaining, width, height, cell_cap
owner[y][x]        -1 neutral, else the owner's id
self               id, position [x, y], home, capture_target,
                   dwell_remaining, owned_count
bots[4]            the same for everyone, plus alive
priority_seat      who wins a tie this turn
legal_actions      what you may do right now

The game

1. Four bots start on protected 2×2 pads in the corners. Nobody can enter or capture a rival's pad. Some boards have walls in the middle.
2. Each turn all four bots pick NORTH, EAST, SOUTH, WEST or STAY at the same time.
3. Leave your land and you draw a trail behind you. Walking back over your own trail shortens it to that point.
4. Get back onto your land and the loop closes: your trail and everything it encloses become yours, rival land included (not pads).
5. Step on a rival's open trail (anywhere except where the rival is standing) and you cut it. Their trail disappears and the server drives them home. Until they're back they can't draw, claim or cut. Land they already own stays theirs.
6. Cuts happen before loops close. If two loops claim the same cell on the same turn, it keeps its old owner.
7. A bot that stays put keeps its cell, and bots can't swap places. Two bots stepping into one empty cell: whoever holds the priority token gets it. The token moves one seat per turn.
8. Nobody is ever knocked out. Every turn you score one point for each cell you own. Most points at the end wins (72 turns on 9×7, 100 on 12×8).

Your code

One file with act(state) returning the move as a string. 2 s for the first turn, 200 ms after. Late, missing or illegal = STAY. Standard library only; print() goes to your log.

def act(state):
    me = state["self"]
    if me["returning"]:
        return "STAY"          # cut: the server drives you home
    return "EAST" if "EAST" in state["legal_actions"] else "STAY"

What you get each turn

turn, turns_remaining, turns, width, height
owner[y][x]        -1 neutral, else the owner's id
walls, pads        blocked cells; each bot's 2x2 start
self               id, position [x, y], trail (oldest first),
                   returning, area, score, blocked
bots[4]            the same for everyone
priority_seat      who wins a tie this turn
legal_actions      what you may do right now

The game

Rules version 3: get cut off from your capital and you're out straight away, and every weapon is in play. Radar, scans and interceptors are off.

1. Four teams on a 12×12 board with mirrored walls. Each has one robot on its capital (the thick square), 1,000 soldiers (500 attack, 350 defense, 150 reserve) and 100 gold.
2. Where capitals start: one random spot mirrored into all four quarters, so every team gets the same position (the default). Other options: the four corners, or choose: on a setup turn 0 each team sends CAPITAL x y for a cell in its own quarter, at least one cell in from the edge and the centre lines. No pick, or a bad one, keeps the corner. The setup turn doesn't count toward the 5-turn timeout.
3. Each turn your robot does one thing. Step into your own land: a move. Step into neutral land: it's yours after one more turn. Step into enemy land: a battle on that cell.
4. Your attack soldiers travel with the robot. The defender sends 65% of its free defense, split over every new attack it faces that turn, plus any soldiers parked on that cell. Its reserve joins a turn later. The battle ends after 2 turns. Capitals defend ×1.6, cells next to a defense post ×1.4.
5. Lose a battle and your robot walks back to where it came from. If it can't, it's out.
6. Take a capital and its team is out; you get +300 points. If a robot is sitting on its own capital you lay siege from next door instead of walking in.
7. Your robot must stay joined to its capital through your own land. The moment a captured cell breaks that path, your robot is out, that same turn: no grace turn, no reconnecting. While claiming or fighting, the cell you stepped from must be joined. Keep your land thick: a one-cell snake dies with you on it.
8. New soldiers go to reserve: +3 +0.4 per cell each turn (+12 per barracks). Gold: +1 +0.12 per cell (+3 per mine). Own a whole quarter of the map: +4 soldiers +1 gold.
9. To move soldiers between attack, defense and reserve you must stand on your capital and ALLOCATE (uses your turn). GARRISON parks reserve soldiers on the cell you stand on; WITHDRAW takes them back.
10. Buildings, on your own joined-up cell, one per cell: mine 60 gold, barracks 70 (3 turns), defense post 45 (2 turns). You're locked while building.
11. Weapons (virtual, one per turn, each with its own cooldown). Aim at enemy cells you can see right now, within range of your robot:

    	gold	range	blast	damage	cooldown
    Bomb	35	3	1	100	5
    Missile	120	10	1	220	12
    MIRV (3 targets)	300	14	1 each	180	25
    H-bomb	500	12	2	250	30

    Every enemy cell in the blast takes the damage (overlapping blasts add up): soldiers parked there die first, that team loses damage ÷ its cell count from its defense, an idle robot standing there loses attack soldiers, and a building falls half the time. Weapons never take land and never touch a capital cell, not even one that used to be a capital. The H-bomb numbers may still change.
12. Move your capital (RELOCATE, a new rule whose numbers may still change): stand on your own joined cell that isn't the capital and has no building; 150 gold, locked 3 turns, once per 60 turns. Then that cell is your capital: ×1.6 defense, ALLOCATE works there, supply is counted from it, and losing it puts you out. The old cell is ordinary land that weapons still can't touch. A strike on the cell while you're locked, or being cut off, cancels it (no refund). Others only learn where it went when they see it.
13. You only see your own land and the cells next to it. Everything else is what you last saw.
14. Two robots stepping into one cell, swapping, or stepping onto a robot: blocked. A bot that sends nothing 5 turns running is out.
15. +1 point per cell you own, every turn. Last team alive wins. Otherwise, after 300 turns or 30 turns with nothing happening, the surviving team with the most points.

Your code

One file with act(state) returning one action string. 2 s for the first turn, 200 ms after. Illegal = WAIT; nothing at all counts toward the 5-turn timeout. The JSON form {"kind": "move", "direction": "E"} works too.

def act(state):
    if state["self"]["busy"]:
        return "WAIT"           # claiming, fighting or building
    for a in ("EAST", "SOUTH", "BUILD MINE"):
        if a in state["legal_actions"]:
            return a
    return "WAIT"

Actions

NORTH / EAST / SOUTH / WEST   move, claim, or attack
BUILD MINE / BARRACKS / POST
ALLOCATE 0.5 0.35 0.15        attack/defense/reserve, capital only
GARRISON 100 / WITHDRAW 100
BOMB x y / MISSILE x y / HBOMB x y
MIRV x1 y1 x2 y2 x3 y3        up to 3 different cells
BOMB / MISSILE / MIRV / HBOMB  bare: the game aims
RELOCATE                      move your capital here
CAPITAL x y                   setup turn (choose mode)
WAIT

What you get each turn

turn, turns_remaining, width, height
phase              "setup" (choose mode, turn 0) or "play"
capital_choices    setup: cells you may pick
owner[y][x]        -1 neutral, a team, None = never seen
seen[y][x]         tick you last saw it (== turn: in view)
walls, region      blocked cells; quarter of each cell
capitals           the ones you've found
buildings, garrisons   what you know of them
self               position, capital, army, gold, income,
                   busy, supplied, score, weapons
                   {ready_in, cost, ...}, relocate_ready_in
robots             enemy robots in view
battles            the ones you're in
rules, legal_actions

The game

1. Two players, Blue (0) and Red (1), on a 17×11 grid of points (or 19×13). Each starts with one edge of length 3 on the middle row, touching its side of the board: Blue on the left, Red on the right.
2. Blue opens with 1 move. After that turns alternate with 2 moves each, until the very last turn, which has 1 again. 60 moves each, 120 in all.
3. A move: pick one of your nodes (the dots at the ends of your edges) and draw a straight edge to any point at most 3 columns and 3 rows away. The end point becomes your node.
4. You can't end in the middle of your own edge or pass through your own node, and you can't draw an edge you already have. You may cross your own edges.
5. A region completely surrounded by your own edges is enclosed. The board's border is not a wall, and a point where two of your edges cross counts as a corner. Area is exact, in grid squares.
6. At the end of every turn (yours and your opponent's) both players add their enclosed area to their score. An enclosure keeps paying until it's broken.
7. If your new edge crosses or even touches an opponent edge, that whole edge breaks and anything it enclosed is gone. Opponent nodes left with no edges disappear. Starting edges break like any other.
8. A move may touch at most one opponent edge. Touching an opponent node touches every edge at it, so it's only allowed when exactly one unprotected edge is attached.
9. Edges the opponent placed in their latest turn are protected (drawn thick with a light centre line) and can't be touched. You can't run along an opponent edge lengthwise.
10. After move 120 the higher score wins; equal scores are a draw. A player with no legal move on their turn loses.

Your code

One file with act(state). It's called once per move for both players; only the player to move acts, so return "WAIT" when your_turn is false. On your move return "MOVE x1 y1 x2 y2". 2 s for the first call, 200 ms after. A late, missing or illegal move is passed: that move is used up and nothing is drawn.

def act(state):
    if not state["your_turn"]:
        return "WAIT"
    for x1, y1, x2, y2, breaks, closes in state["legal_moves"]:
        if closes:              # comes back to your own lines
            return f"MOVE {x1} {y1} {x2} {y2}"
    return state["legal_actions"][0]

What you get each move

turn, turns        moves played, moves in the game (120)
round, rounds      the rules' turn number (61 turns)
your_turn, to_move, moves_left (in this turn)
width, height, reach (3)
self, opponent     id, color, score, area, nodes
edges              id, a, b, owner, turn, protected
regions            owner, area, outline, edges
legal_moves        [x1, y1, x2, y2, breaks, closes]
                   breaks: enemy edge id or -1
legal_actions      "MOVE x1 y1 x2 y2" strings

The game

1. Board. 8×8 cells. Each cell shows a value 1, 2 or 3, higher toward the middle; the layout is mirrored, so every corner is equivalent. Each bot starts in a corner. That corner is its home: it is always yours and can never be taken.
2. Moves. Every turn all four bots choose N, E, S, W, STAY or SHIELD at the same time. A cell with a bot on it is closed for that turn, so there are no swaps and no following. If two bots step into the same empty cell, the cell's owner gets it. Otherwise the priority token decides. The token moves one seat every turn.
3. Take. Stay 1 turn on a cell that isn't yours and it becomes yours, at level 1. An upgraded rival cell takes 3 turns. Taking a rival's cell also pays a one-off raid bonus of 8 × its value × its level.
4. Upgrade. Stay 3 turns on your own cell and it is upgraded: it counts double.
5. Shield. Instead of moving you may SHIELD. You can't SHIELD again for the next 4 turns. For that one turn none of your cells can be taken: every rival who stays on one of your cells this turn, your home included, loses its progress and is frozen (forced to STAY) for the next 2 turns. A rival that is already frozen isn't caught again. A SHIELD turn does not count as staying. A SHIELD that catches nobody backfires: you are frozen for 2 turns.
6. Score. At the end of every turn you score the value of each cell you own, ×2 if it is upgraded.
7. End. After 80 turns, the most points wins. Nobody is ever knocked out.

A blocked move counts as a stay. Leaving a cell resets your progress on it. A taken cell drops to level 1.

Reading the board

• The small number in each cell's corner is its value. Brighter cells with an inner line are upgraded.
• An arc round a bot shows how far it is through taking or upgrading its cell.
• A dashed ring over a bot's cells means it shielded that turn. A faded bot with a dashed ring is frozen.
• The white diamond marks the bot holding the priority token.

Your code

One file with act(state) returning NORTH, EAST, SOUTH, WEST, STAY or SHIELD. 2 s for the first turn, 200 ms after. Late, illegal or crashing = STAY. Standard library only; print() goes to your log.

def act(state):
    me = state["self"]
    if me["need"]:
        return "STAY"           # finish taking or upgrading this cell
    return "EAST" if "EAST" in state["legal_actions"] else "STAY"

What you get each turn

Coordinates are [x, y], with [0, 0] top-left.