"The fight is already over before it begins. Your job was five minutes ago."

---

Prerequisites

Module	What You Used From It
Module 6 - Tower Defense	Wave-based pacing, spatial placement on a grid, entities interacting without direct player control during execution phases
Module 10 - Deckbuilder	Shop-and-draft loop, random offers, synergy construction, tension between building toward a plan and adapting to what is available

---

Week 1: History & Design Theory

The Origin

The auto-battler genre emerged almost fully formed in January 2019 when a team of modders released Dota Auto Chess as a custom game mode inside Dota 2. Players drafted heroes from a shared pool, placed them on an 8x8 chessboard grid, and watched them fight automatically against other players' boards. Within weeks it had millions of daily players. The game fused the character-collecting satisfaction of gacha games with the positional strategy of chess and the economic pressure of poker. What made it revolutionary was the realization that combat itself did not need to be interactive — all the meaningful decisions happened before the fight, in the draft and the positioning.

How the Genre Evolved

Dota Auto Chess (2019): The original mod that defined the genre. Eight players share a unit pool, spend gold in a shop to buy and upgrade heroes, place them on a grid, and watch rounds of automated combat. It established the core loop of draft-position-fight and introduced the economic system of saving gold for interest.

Teamfight Tactics (Riot Games, 2019): Riot's response brought the genre to a massive audience through the League of Legends client. TFT refined the item system, introduced the carousel round, and polished the synergy system with clear trait thresholds. It proved the genre could sustain a live-service model with rotating sets.

Super Auto Pets (2021): A radical simplification that stripped the genre to its essence. Units are animals arranged in a single line instead of a grid. What remains is pure draft economics and synergy construction. Its success demonstrated that the core auto-battler loop — buy, arrange, watch, adapt — is compelling even without complexity.

What Makes It "Great"

A great auto-battler creates a constant tension between commitment and flexibility. Every round, the shop offers you a small random selection of units, and you must decide: do you buy that unit to chase a powerful synergy, or save your gold to earn interest for a stronger economy later? The automated combat is not a gimmick — it is the design insight that lets the game focus entirely on the decisions that matter: resource allocation, risk assessment, and spatial reasoning.

The Essential Mechanic

Drafting and positioning units that fight automatically — strategy is in preparation, not execution.

---

Week 2: Build the MVP

What You're Building

A single-player auto-battler where you face a series of increasingly difficult AI opponents. Each round, you spend gold to buy units from a randomized shop, place them on a small grid, and watch them fight the enemy team automatically. Units of the same type grant synergy bonuses when you field enough of them. You can reroll the shop for new options, save gold to earn interest, and upgrade units by collecting duplicates.

Core Concepts (Must Implement)

1. Draft / Shop System

The shop presents a random selection of units each round. The player spends gold to buy units and can pay to reroll for a new selection. This is where the majority of strategic decisions happen.

SHOP_SIZE = 5
REROLL_COST = 2

function generate_shop(tier_odds, unit_pool):
    shop = []
    for i in 0..SHOP_SIZE:
        tier = weighted_random(tier_odds)
        available = unit_pool.filter(u => u.tier == tier AND u.copies_remaining > 0)
        unit = random_choice(available)
        shop.append(unit)
    return shop

function buy_unit(player, shop_index):
    unit = shop[shop_index]
    if player.gold >= unit.cost:
        player.gold -= unit.cost
        add_to_bench(player, unit)
        shop[shop_index] = EMPTY
        check_for_upgrade(player, unit.type)

function reroll_shop(player):
    if player.gold >= REROLL_COST:
        player.gold -= REROLL_COST
        return_units_to_pool(current_shop)
        player.shop = generate_shop(tier_odds_for_level(player.level), unit_pool)

Why it matters: The shop is the primary interface between randomness and player agency. Every auto-battler lives or dies by how its shop feels. Too random and players feel helpless; too predictable and there is no adaptation. The reroll mechanic gives players a pressure valve — they can spend resources to fight bad luck, but at a cost.

2. Synergy / Tribal Bonuses

Units belong to one or more types (tribes, traits). When you field enough units of the same type, the entire team receives a bonus. Thresholds create breakpoints that drive drafting decisions.

synergy_definitions = {
    "warrior": {2: {armor: +5}, 4: {armor: +15}},
    "mage":    {2: {spell_power: +20}, 4: {spell_power: +50}},
    "beast":   {2: {attack_speed: +15%}, 4: {attack_speed: +30%}}
}

function calculate_active_synergies(board_units):
    type_counts = {}
    for unit in board_units:
        for type in unit.types:
            type_counts[type] = type_counts.get(type, 0) + 1
    active_buffs = []
    for type, count in type_counts:
        thresholds = synergy_definitions[type].keys().sort(descending)
        for threshold in thresholds:
            if count >= threshold:
                active_buffs.append(synergy_definitions[type][threshold])
                break
    return active_buffs

Why it matters: Synergies transform the draft from "pick the strongest individual unit" into "build a team that is greater than the sum of its parts." The threshold system creates natural decision points: do you splash two warriors for a small bonus or commit to four for a massive one?

3. Board Placement Strategy

Before combat begins, the player arranges their units on a grid. Where a unit stands determines who it fights first, who it protects, and whether it survives long enough to use its abilities.

BOARD_ROWS = 4
BOARD_COLS = 7

function place_unit(player, unit, row, col):
    if row < 0 OR row >= BOARD_ROWS OR col >= BOARD_COLS:
        return false
    if board[row][col] is not EMPTY:
        return false
    board[row][col] = unit
    unit.position = {row, col}
    return true

Why it matters: Placement is the spatial puzzle within the auto-battler. Two players with identical units and synergies will get different results based on positioning. This is where the "chess" in auto chess comes from.

4. Automated Combat Resolution

Once the player finalizes their board, combat plays out without any input. Units select targets based on simple rules (nearest enemy), attack on cooldowns, and use abilities when their mana is full.

function resolve_combat(team_a, team_b):
    all_units = team_a + team_b
    for unit in all_units:
        unit.current_hp = unit.max_hp
        unit.mana = 0

    while team_a.has_living_units() AND team_b.has_living_units():
        for unit in all_units.sort_by(attack_speed):
            if unit.is_dead(): continue
            target = find_target(unit, get_enemies(unit))
            if target == null: continue
            if not in_range(unit, target):
                move_toward(unit, target)
            else:
                damage = calculate_damage(unit.attack, target.armor)
                target.current_hp -= damage
                if target.current_hp <= 0:
                    mark_dead(target)
    return {winner: surviving_team(), damage: count_surviving_units(winner)}

function find_target(unit, enemies):
    living = enemies.filter(e => e.is_alive())
    return living.sort_by(distance_to(unit)).first()

Why it matters: Automated combat is the defining feature of the genre. By removing execution from the player's hands, the game shifts all skill expression to preparation. The combat system must be readable — the player needs to watch a fight, understand why they lost, and know what to change.

5. Economy Management

Gold is earned each round from a base income, interest on savings, and win/loss streak bonuses. The interest system creates a fundamental tension: spend now for power or save for compound returns.

BASE_INCOME = 5
INTEREST_RATE = 0.1
MAX_INTEREST = 5
STREAK_BONUS = {0: 0, 1: 0, 2: 1, 3: 1, 4: 2, 5+: 3}

function calculate_round_income(player):
    base = BASE_INCOME
    interest = min(floor(player.gold * INTEREST_RATE), MAX_INTEREST)
    streak = STREAK_BONUS[player.current_streak_length]
    bonus = 1 if player.won_last_round else 0
    return base + interest + streak + bonus

Why it matters: The economy system is what gives auto-battlers their strategic depth beyond the draft. Interest on saved gold means that every purchase has a hidden cost: the future interest you will not earn. This creates distinct strategic archetypes (greedy vs aggressive).

6. Shared Pool Drafting

All players draw from the same finite pool of units. When one player buys a unit, there are fewer copies available for everyone else. This creates indirect competition during the draft phase.

function initialize_unit_pool():
    pool = {}
    for unit_type in all_unit_types:
        copies = {1: 29, 2: 22, 3: 16, 4: 12, 5: 10}
        pool[unit_type] = copies[unit_type.tier]
    return pool

function buy_from_pool(pool, unit_type):
    if pool[unit_type] > 0:
        pool[unit_type] -= 1
        return unit_type
    return null

Why it matters: The shared pool transforms what could be a solo optimization puzzle into a competitive resource game. Smart players scout opponents and pivot to uncontested strategies.

7. Round Structure

The game progresses through a sequence of rounds: PvE rounds against neutral creeps, then PvP rounds. Each round has a preparation phase and a combat phase.

function run_round(round, player):
    // PREPARATION PHASE
    player.shop = generate_shop(...)
    start_timer(PREP_TIME)
    wait_for_timer_or_ready()

    // COMBAT PHASE
    if round.type == "pve":
        enemy_board = round.enemies
    else:
        enemy_board = select_opponent(player).board.clone()

    result = resolve_combat(player.board, enemy_board)
    if result.winner != player:
        player.hp -= result.damage

    update_streak(player, result.winner == player)
    end_of_round(player)

Why it matters: The round structure provides rhythm and pacing. The preparation-then-combat loop creates a heartbeat: tension as you scramble to improve your board, then release as you watch the fight play out.

---

Stretch Goals

• Unit upgrades: Buying three copies of the same unit automatically combines them into a stronger two-star version.
• Item system: Defeated PvE rounds drop items that can be equipped on units.
• Multiple opponents: Expand from one AI opponent to a full lobby of simulated opponents.
• Carousel round: A special round where units with items circle on a conveyor belt and each player picks one.

MVP Spec

Element	Scope
Grid	4x7 board for the player, mirrored for the opponent
Units	8-10 unit types across 3 tiers and 3-4 synergy types
Shop	5 slots, reroll for 2 gold, refreshes each round
Economy	Base income + interest (10%, capped at 5) + streak bonus
Synergies	3-4 types with 2/4 thresholds
Combat	Automated: nearest-target, attack on cooldown
Rounds	3 PvE rounds then PvP rounds until one side reaches 0 HP
Health	Player starts at 100 HP, loses HP equal to surviving enemy units on a loss
Win condition	Survive all rounds or reduce AI opponent's HP to 0

Deliverable

A playable single-player auto-battler with a shop phase where you buy units from a randomized selection, place them on a grid, and watch automated combat resolve against an AI opponent. The game must include at least three synergy types with visible bonuses, an economy system with interest on saved gold, and a clear win/loss state.

---

Analogies by Background

For Backend Developers

Concept	Analogy
Draft / Shop System	Like a service registry where available instances are drawn from a pool — each request depletes availability, rerolling is re-querying with a cost.
Synergy / Tribal Bonuses	Like middleware chains that activate only when enough compatible services are registered — reaching a threshold enables a new capability.
Automated Combat	Like a CI/CD pipeline executing after you commit — you set up the conditions and watch the system run.
Shared Pool Drafting	Like a connection pool shared across microservices — one service hogging connections starves the others.
Economy Management	Like capacity planning with compound returns — investing in infrastructure now reduces future costs.

For Frontend Developers

Concept	Analogy
Draft / Shop System	Like a component marketplace where you browse available widgets, purchase the ones you need, and refresh the listing.
Board Placement	Like CSS Grid layout — you are positioning elements into specific grid cells and the arrangement determines interaction.
Automated Combat	Like the browser render pipeline after you commit DOM changes — you set up state and the engine resolves it.
Economy Management	Like a performance budget — you can spend rendering time now for richness or save it for smoother interactions later.
Round Structure	Like the React lifecycle — mount (preparation), render (combat), and cleanup (round end) phases repeat.

For Data / ML Engineers

Concept	Analogy
Draft / Shop System	Like hyperparameter search with a budget — each evaluation costs compute, rerolling is re-sampling the search space.
Synergy / Tribal Bonuses	Like feature interactions in a model — individual features are useful, but specific combinations produce non-linear boosts.
Automated Combat	Like launching a training run — you configure the hyperparameters, hit start, and observe the loss curve.
Shared Pool Drafting	Like a shared GPU cluster — other teams' jobs compete for the same resources.
Round Structure	Like an epoch-based training loop — each epoch consists of forward pass, loss calculation, and backprop.

---

Discussion Questions

1. The Preparation Paradox: Auto-battlers remove all player input during combat, yet players report feeling more responsible for outcomes. Why does limiting agency during execution increase the feeling of ownership over results?
2. Economic Depth vs. Accessibility: The interest-on-gold system creates rich strategic depth but is the hardest concept for new players to grasp. How would you design the UI so players discover the interest mechanic naturally?
3. The Shared Pool Problem: In a single-player MVP, there is only one opponent drawing from the pool. How do you simulate the competitive pressure of a full lobby?
4. Randomness as Content: Auto-battlers generate replayability almost entirely through randomness in the shop. How much randomness is enough to create variety, and at what point does it feel like the game is playing you?