Merge pull request #5 from CodeClash-ai/john/new-arenas

Insight: New Training Arenas

Author: john-b-yang

data/team.json

@@ -12,6 +12,18 @@
             "link": "https://www.lieret.net/",
             "affiliation": "Princeton University"
         },
+        {
+            "name": "Muhtasham Oblokulov",
+            "role": "Contributor",
+            "link": "https://muhtasham.github.io/blog/",
+            "affiliation": "Technical University of Munich"
+        },
+        {
+            "name": "Aryan Siddiqui",
+            "role": "Contributor",
+            "link": "https://www.linkedin.com/in/aryan-siddiqui/",
+            "affiliation": "Stanford University"
+        },
         {
             "name": "Joyce Yang",
             "role": "Contributor",

pages/arenas/battlecode23.md

@@ -0,0 +1,38 @@
+title: BattleCode 2023
+logo: /static/images/arenas/battlecode23.png
+preview: /static/images/arenas/battlecode23.gif
+preview_width: 70
+description: Conquer sky islands by placing reality anchors with your robot army
+date-added: 2026-01-06T16:58:27.268231Z
+players: 2
+language: Java
+split: train
+
+**What is BattleCode 2023?**
+BattleCode 2023: Tempest is a turn-based strategy game where you control robots competing to conquer sky islands by placing reality anchors. Win by controlling 75% of all islands through six robot types: Headquarters (build units and craft anchors), Carriers (transport resources and anchors), Launchers (combat), and specialized Amplifiers, Boosters, and Destabilizers.
+
+**How does it work?**
+Carriers gather resources (adamantium, mana, elixir) from wells and deliver them to headquarters. Headquarters use these resources to build robots and craft anchors. Carriers transport anchors to islands and place them to claim territory. The map features time-bending currents that push robots and clouds that obscure vision while slowing movement.
+
+**What's the goal?**
+Conquer 75% of sky islands for instant victory. Islands are captured by placing standard anchors (80 Ad + 80 Mn) or accelerating anchors (300 Ex) that buff nearby allies. Anchors have health that changes based on island occupation. Tiebreakers after 2000 rounds favor teams controlling more islands or holding more total resources.
+
+**What makes it challenging?**
+Success requires managing complex resource chains (upgrading wells, transforming to elixir), coordinating independent robots under bytecode limits, and utilizing terrain effects strategically. Communication is limited to a 64-integer shared array requiring proximity to headquarters, amplifiers, or controlled islands. You must balance resource gathering, anchor production, and military units while navigating time-bending currents and clouds.
+
+---
+
+### References
+
+* [MIT BattleCode 2023 Starter Project](https://github.com/battlecode/battlecode23-scaffold)
+* [MIT BattleCode 2023 Source Code](https://github.com/battlecode/battlecode23)
+* [MIT BattleCode Website](https://battlecode.org/)
+
+<pre>
+@misc{mit2023battlecode,
+    title={MIT Battlecode 2023: Tempest},
+    author={MIT BattleCode},
+    url={https://github.com/battlecode/battlecode23},
+    year={2023}
+}
+</pre>

pages/arenas/battlecode24.md

@@ -0,0 +1,38 @@
+title: BattleCode 2024
+logo: /static/images/arenas/battlecode24.png
+preview: /static/images/arenas/battlecode24.gif
+preview_width: 70
+description: Capture enemy flags with specialized robots in turn-based combat
+date-added: 2026-01-03T16:58:27.268231Z
+players: 2
+language: Java
+split: train
+
+**What is BattleCode 2024?**
+BattleCode 2024: Breadwars is a turn-based strategy game where you program robots to capture the opponent's flags. Each team controls 50 robots that can attack, heal, build traps, and modify terrain. The game features a 200-round setup phase where teams are separated by a dam before engaging in open combat.
+
+**How does it work?**
+You spawn robots in designated zones and collect crumbs to build defenses. Robots gain experience in attack, healing, or building skills, leveling up through specializations to become more effective. During setup, position your three flags strategically and construct traps (explosive, water, stun) to defend them before the dam collapses.
+
+**What's the goal?**
+Capture all three enemy flags by bringing them to your spawn zones before 2000 rounds. Flags return to default positions if dropped for 4 rounds, and carrying them slows movement. Tiebreakers favor teams with more flags captured, higher skill levels, or more resources.
+
+**What makes it challenging?**
+Success demands coordinating 50 independent robots under bytecode constraints, balancing offensive flag captures with defensive trap placement, and managing specialization paths (robots mastering one skill at level 4 cap others at level 3). You must optimize terrain modification, navigate jail penalties, and utilize global upgrades strategically.
+
+---
+
+### References
+
+* [MIT BattleCode 2024 Starter Project](https://github.com/battlecode/battlecode24-scaffold)
+* [MIT BattleCode 2024 Source Code](https://github.com/battlecode/battlecode24)
+* [MIT BattleCode Website](https://battlecode.org/)
+
+<pre>
+@misc{mit2024battlecode,
+    title={MIT Battlecode 2024: Breadwars},
+    author={MIT BattleCode},
+    url={https://github.com/battlecode/battlecode24},
+    year={2024}
+}
+</pre>

pages/arenas/battlecode25.md

@@ -0,0 +1,38 @@
+title: BattleCode 2025
+logo: /static/images/arenas/battlecode25.png
+preview: /static/images/arenas/battlecode25.gif
+preview_width: 70
+description: Paint the map with robots and towers to control territory
+date-added: 2025-12-20T16:58:27.268231Z
+players: 2
+language: Python
+split: train
+
+**What is BattleCode?**
+BattleCode is a real-time strategy game where you program bots to control specialized robots (Soldiers, Moppers, Splashers) and towers on a grid map. Teams compete to paint the map with their colors, building towers that spawn units or generate resources while managing paint supply and unit coordination.
+
+**How does it work?**
+You start with towers that build robots using stored paint. Soldiers paint territory and attack enemies, Moppers steal paint from opponents and clean enemy colors, and Splashers provide area coverage. Robots must find ruins and complete specific paint patterns to construct new towers, expanding your production capabilities.
+
+**What's the goal?**
+Win by painting 70% of the map, destroying all enemy units and towers, or having more painted squares at game end. Tiebreakers favor teams with more towers, money, stored paint, or robots. Victory requires balancing territorial expansion with tower construction and paint economy.
+
+**What makes it challenging?**
+Success demands efficient bytecode management under strict computational limits, coordinating multiple robot types with different capabilities, optimizing paint distribution across units, and strategically placing towers using pattern-matching mechanics. You must balance aggressive painting with defensive tower protection while managing limited resources.
+
+---
+
+### References
+
+* [MIT BattleCode 2025 Starter Project](https://github.com/battlecode/battlecode25-scaffold)
+* [MIT BattleCode 2025 Source Code](https://github.com/battlecode/battlecode25)
+* [MIT BattleCode Website](https://battlecode.org/)
+
+<pre>
+@misc{mit2025battlecode,
+    title={MIT Battlecode 2025: Chromatic Conflict},
+    author={MIT BattleCode},
+    url={https://github.com/battlecode/battlecode25},
+    year={2025}
+}
+</pre>

pages/arenas/battlesnake.md

@@ -5,6 +5,7 @@ description: Snake AIs compete to survive and grow in a grid
 date-added: 2025-11-04T16:58:27.268231Z
 players: 2+
 language: Python
+split: test
 
 **What is BattleSnake?**
 BattleSnake is a multiplayer programming game where you control a snake navigating a grid-based board. Your snake competes against other snakes to collect food, grow longer, and outlast your opponents. The last snake alive wins.

pages/arenas/bridge.md

@@ -0,0 +1,39 @@
+title: Bridge
+logo: /static/images/arenas/bridge.png
+preview: /static/images/arenas/bridge.gif
+preview_width: 70
+description: Classic trick-taking card game with team-based bidding and play
+date-added: 2025-12-17T12:00:00.000000Z
+players: 4
+language: Python
+split: train
+
+**What is Bridge?**
+Bridge is a competitive trick-taking card game arena where you program AI bots to play Contract Bridge. Four players form two teams (North/South vs East/West) and compete through strategic bidding and precise card play to win tricks and fulfill contracts.
+
+**How does it work?**
+Your Python bot implements two functions: `get_bid(game_state)` for the auction phase and `play_card(game_state)` for trick-taking. During bidding, you evaluate your hand and communicate with your partner through legal bids to establish a contract. During play, you select cards strategically based on the current trick, your remaining cards, and the established contract.
+
+**What's the goal?**
+Win by scoring more Victory Points than the opposing team. As declarer, fulfill your bid contract by winning the required number of tricks. As defenders, prevent the declarer from making their contract. Games are scored using standard Bridge scoring rules, then normalized to Victory Points on a 0-1 scale.
+
+**What makes it challenging?**
+Success requires mastering both cooperative bidding conventions to communicate hand strength with your partner and adversarial card play to outmaneuver opponents. You must track played cards, infer opponent holdings, and make optimal plays under uncertainty while coordinating with a teammate who can only communicate through legal bids.
+
+---
+
+### References
+
+* [Bridge Arena Repository](https://github.com/CodeClash-ai/Bridge)
+* [CATArena Bridge Implementation](https://github.com/AGI-Eval-Official/CATArena/tree/main/bridgegame/bridge) (original implementation)
+
+If you evaluate on Bridge using CodeClash, in addition to our work, we recommend the following citation for attribution to the original creators:
+
+<pre>
+@misc{catarena2025bridge,
+    title={CATArena: Bridge Game},
+    author={AGI-Eval-Official},
+    url={https://github.com/AGI-Eval-Official/CATArena},
+    year={2025}
+}
+</pre>

pages/arenas/chess.md

@@ -0,0 +1,33 @@
+title: Chess
+logo: /static/images/arenas/chess.png
+preview: /static/images/arenas/chess.gif
+preview_width: 70
+description: No explanation needed, it's chess!
+date-added: 2026-01-04T00:00:00.000000Z
+players: 2
+language: Python
+split: train
+
+**What is Chess?**
+Chess is the classic two-player strategy board game where you compete by improving a UCI-compatible chess engine. Rather than playing individual moves, you enhance the engine's search algorithms, evaluation functions, and move ordering heuristics to create a stronger player.
+
+**How does it work?**
+In CodeClash's Chess arena, you modify a C++ chess engine that uses the Universal Chess Interface (UCI) protocol. Your code lives in the `src/` directory and must compile to an executable named `kojiro` using `make native`. The engine communicates via UCI, receiving board positions and returning moves based on your implemented search and evaluation logic.
+
+Matches are orchestrated by Fastchess, a high-performance tournament manager that runs concurrent games between engines with configurable time controls (default: 1 second + 0.01 second increment per move). Fastchess handles UCI communication, time management, adjudication, and result tracking across multiple games.
+
+**What's the goal?**
+Create the strongest chess engine by improving its core components. This includes enhancing the search algorithm with techniques like alpha-beta pruning, null move pruning, and late move reductions; implementing effective move ordering using heuristics like killer moves and history tables; and refining position evaluation through piece-square tables, pawn structure analysis, and mobility calculations. Your engine competes in head-to-head matches, with performance measured by win rate across multiple games.
+
+**What makes it challenging?**
+Success requires balancing multiple competing objectives: search depth versus time management, evaluation accuracy versus computational cost, and aggressive pruning versus search completeness. You must optimize C++ code for performance while implementing sophisticated chess algorithms. The engine must make strong decisions under strict time constraints, requiring efficient data structures like bitboards, transposition tables, and Zobrist hashing. Small improvements in evaluation or search can translate to significant rating gains, making incremental optimization both rewarding and demanding.
+
+---
+
+### References
+
+* [Kojiro Chess Engine](https://github.com/Babak-SSH/Kojiro)
+* [Fastchess Tournament Manager](https://github.com/Disservin/fastchess)
+* [UCI Protocol Documentation](http://wbec-ridderkerk.nl/html/UCIProtocol.html)
+* [Chess Programming Wiki](https://www.chessprogramming.org/)
+* [CodeClash GitHub Repository](https://github.com/CodeClash-ai/Chess)

pages/arenas/corewar.md

@@ -6,6 +6,7 @@ description: Redcode warriors battle to control a virtual computer
 date-added: 2025-11-04
 players: 2+
 language: RedCode
+split: test
 
 **What is Core War?**
 Core War is a programming battle where you write "warriors" in Redcode, an assembly-like language, to compete within a virtual machine called MARS (Memory Array Redcode Simulator). Your warriors battle for control of the core memory.

pages/arenas/figgie.md

@@ -0,0 +1,29 @@
+title: Figgie
+logo: /static/images/arenas/figgie.png
+preview: /static/images/arenas/figgie.gif
+preview_width: 70
+description: Card game by Jane Street simulating open-outcry commodities trading
+date-added: 2025-12-31T00:00:00.000000Z
+players: 4-5
+language: Python
+split: train
+
+**What is Figgie?**
+Figgie is a card trading game invented at Jane Street that simulates open-outcry commodities markets. Players trade cards from four suits through bids and offers, competing to accumulate the secret goal suit while managing limited capital and incomplete information.
+
+**How does it work?**
+Each game uses a 40-card deck with asymmetric suit sizes (12-10-10-8 cards). Players start with $350 and contribute an ante to a $200 pot. You post bids to buy cards or offers to sell them, execute trades at market prices, and gather information from other players' trading patterns to deduce which suit is the goal.
+
+**What's the goal?**
+Maximize profits by collecting cards in the goal suit, which is revealed only at game end. Each goal suit card pays $10 from the pot, and the remainder ($100-120) goes to whoever holds the most. The goal suit is always the same color as the 12-card suit but contains 8 or 10 cards.
+
+**What makes it challenging?**
+Success requires probabilistic reasoning under uncertainty, reading opponent signals from trading behavior, and balancing market-making profits against goal suit accumulation. You must manage capital efficiently, avoid overpaying for cards, and deduce the goal suit from limited information about deck composition.
+
+---
+
+### References
+
+* [Jane Street Figgie Website](https://www.figgie.com/index.html)
+* [Discussion of Figgie vs. Poker for teaching quantitative marketing skills by ex-Jane Street employee](https://blog.rossry.net/figgie/)
+* [Reference Implementation](https://github.com/0xDub/figgie-auto)

pages/arenas/gomoku.md

@@ -0,0 +1,28 @@
+title: Gomoku
+logo: /static/images/arenas/gomoku.png
+preview: /static/images/arenas/gomoku.gif
+preview_width: 70
+description: Board game where players race to connect five stones in a row
+date-added: 2025-12-19T00:00:00.000000Z
+players: 2
+language: Python
+split: train
+
+**What is Gomoku?**
+Gomoku is a classic two-player strategy board game played on a grid. Players take turns placing their stones (black or white) on the board, with the goal of being the first to form an unbroken line of exactly five stones horizontally, vertically, or diagonally.
+
+**How does it work?**
+Each player writes a Python program (`main.py`) that controls their stone placements. Your code receives the current board state and your color, then returns the coordinates where you want to place your next stone. The game runs on a 15x15 grid.
+
+**What's the goal?**
+Be the first to connect exactly five of your stones in a row. Block your opponent's attempts while building your own winning lines.
+
+**What makes it challenging?**
+Success requires balancing offense and defense: building multiple threats while recognizing and blocking your opponent's patterns. The best players think several moves ahead and create situations where they threaten to win in multiple ways simultaneously.
+
+---
+
+### References
+
+* [Gomoku on Wikipedia](https://en.wikipedia.org/wiki/Gomoku)
+* [CodeClash GitHub Repository](https://github.com/CodeClash-ai/Gomoku)