Soccer

Each seat drives one humanoid robot on a RoboCup-style pitch. You steer it with the same high-level commands a real humanoid takes: a body-frame walk velocity, a kick, a get-up, a head turn. You write one bot; it is cloned across your whole side, and each copy plays from its own view, so roles have to emerge, not be dictated. Outscore the other team over two 60-second halves. Draws are real.

Rules

• Variants are kid-4v4 (default, 8 seats), 1v1, and adult-3v3. Every seat runs as its own robot, but a match ranks the two programs, yours vs theirs.
• One turn is 100 ms of simulated time. A half is 600 turns (60 s); two halves make 1200 turns. Positions are millimeters, velocities mm/s, angles milliradians (CCW from the +x axis).
• Team 0 attacks the goal at x = width, team 1 attacks x = 0. Most goals at the final whistle wins. Equal goals is a draw.
• Each turn you send a robot up to four things, all optional: a cmd_vel walk command, a shoot, a get_up, and a head turn. cmd_vel persists until you replace it, the way a real robot keeps walking until told otherwise. The rest fire once.

Your robot is a state machine. It is walking (obeying cmd_vel), kicking (planted for three ticks around a shot), fallen (an obstacle until you get it up), or getting_up (a 2 s routine). Read mode and mode_ticks off each robot to know what it can do this turn.

Walking is direction-dependent, like a real biped: forward tops out at 1000 mm/s, backpedal at 500, strafe at 600, and yaw at 2500 mrad/s. You cannot stop or turn on a dime either. Velocity changes by at most 250 mm/s per tick, so plan your approach.

The kick

shoot takes yaw (mrad off your heading), power, and loft (both 0..1000). The strike lands two ticks after you call it: a windup, then contact, then follow-through. At contact the ball must be within 450 mm of your center, inside a 900 mrad cone around your heading, and below 500 mm off the turf. If the ball rolled out of reach in those two ticks, you whiff.

Ball ground speed is power x 5 mm/s (up to 5000). loft sets the vertical kick, loft x 5 mm/s (up to 5000); a full-loft chip clears a 700 mm robot. The turf is slow and the air drags: a max-power ground shot rolls out in about 5 m, a max chip carries about 6 m total, and every bounce scrubs pace. No single kick crosses the field; you work the ball up it.

The ball's height matters the whole way, and so does what it hits. A ball whose underside is above 700 mm sails over standing robots (300 mm over a fallen one). Below that, the body part at the ball's height decides the rebound: boots kick it back lively, the chest kills it dead so it drops short (a trap), the head glances it, and a ball dropping onto the head bounces up off it. The legs are two columns with a real gap, so a rising ball can slip clean between them. The rebound also carries the robot's own motion, so a charging robot punches the ball harder. Aim at the goal mouth's open corner, chip over a defender and chase the second bounce, or thread one through the keeper's legs.

Falls and getting up

Run into another robot fast and someone goes down. If the closing speed tops 800 mm/s, the slower robot falls (both, when their speeds are within 100 mm/s of each other). A fallen robot is a dead obstacle: it blocks low balls but nothing else. Send get_up: true and it spends 2 s rising, then walks with 1 s of shove immunity so it does not get pinned right back down.

The referee

• The ball fully over a touchline is placed dead on the line. Over an end line without a goal, it is a corner if a defender touched it last, or a goal kick if an attacker did.
• After a goal the conceding team kicks off. Formations teleport to a mirrored setup and the world holds still for a 1 s ready window. The kicking team's striker starts on the ball; everyone else holds position. Team 1 kicks off the second half.
• A goal counts only when the ball crosses the end line inside the mouth (goal_lo..goal_hi) and below goal_height.

Writing a bot

Each robot sees the whole pitch: every robot's pose, velocity, and mode; the ball's position and velocity in 3D; the score; the clock; and which robot it is (you, your team, your team_index). It also gets caps, the gait and kick limits, so you can plan against them instead of hardcoding numbers. The same code runs for every robot on your side, so use team_index and your position to split into a striker, support, and a keeper.

The floor is "whoever is nearest the ball walks at it and shoots at the goal; everyone else holds a spot goal-side" (the Greedy bot). Past that: intercept the ball's path instead of chasing its current cell, chip over a packed defense, keep a robot back on your own line, and get fallen teammates up fast.

Input and output

Each turn your bot is handed the observation as JSON and returns one action as JSON.

Observation:

{
  "you": 0, "team": 0, "team_index": 0, "team_size": 4,
  "attacking_goal_x": 9000, "own_goal_x": 0,
  "width": 9000, "height": 6000, "goal_lo": 1700, "goal_hi": 4300,
  "goal_height": 1200, "ball_r": 65,
  "caps": { "tick_ms": 100, "robot_r": 200, "robot_h": 700,
    "max_fwd": 1000, "max_back": 500, "max_strafe": 600, "max_yaw": 2500,
    "accel": 250, "kick_range": 450, "kick_arc": 900, "kick_v": 5,
    "kick_loft": 5, "kickable_z": 500, "getup_ticks": 20 },
  "robots": [
    { "seat": 0, "x": 600, "y": 3000, "heading": 0, "vx": 0, "vy": 0,
      "mode": "walking", "mode_ticks": 0, "team": 0, "number": 1 }
  ],
  "ball": { "x": 4500, "y": 3000, "z": 65, "vx": 0, "vy": 0, "vz": 0 },
  "score": [0, 0], "half": 1,
  "phase": { "kind": "kickoff", "team": 0, "ticks": 7 },
  "last_toucher": -1, "turn": 3, "max_turns": 1200, "nonce": 123456789
}

robots lists every seat in seat order; robots[you] is yours. mode is walking, kicking, fallen, or getting_up. phase is {"kind":"play"} in open play, or {"kind":"kickoff","team":T,"ticks":N} during a ready window (team T has the first touch). last_toucher is the seat that touched the ball last, or -1.

Action (every field optional):

{ "cmd_vel": { "vx": 800, "vy": 0, "wz": -500 },
  "shoot": { "yaw": 200, "power": 900, "loft": 300 },
  "get_up": true,
  "head": { "pitch": 0, "yaw": -785 } }

cmd_vel is body-frame: vx forward, vy left, wz counter-clockwise. It persists until you send a new one. shoot, get_up, and head are one-shot. head is cosmetic in v1 (your observation is already full-state); it aims the replayer's head.

The robot API mirrors real humanoids

The commands are the same primitives the high-level humanoid SDKs expose, so a strategy here ports to real hardware.

Botliga	Booster T1	Unitree G1	ROS 2
cmd_vel {vx, vy, wz}	B1LocoClient::Move(vx, vy, vyaw)	LocoClient::SetVelocity(vx, vy, omega)	geometry_msgs/Twist on cmd_vel (linear.x/y, angular.z)
shoot {yaw, power, loft}	Shoot()
get_up: true	GetUp()	Lie2StandUp()
head {pitch, yaw}	RotateHead(pitch, yaw)

The editor preloads a random starter in each language; replace the logic in bl_act.