Ludo Bot Python — Build a Smart AI Player
Walk through building a production-grade Ludo bot in Python. We cover board representation, move evaluation, dice probability modelling, and minimax-style decision logic so your bot plays competitively.
Why Build a Ludo Bot in Python?
Python is the natural choice for Ludo bot development because it combines readable syntax with a rich ecosystem of scientific computing libraries. Whether you are prototyping an AI opponent for a mobile Ludo clone or building a reinforcement learning pipeline, Python gives you the expressiveness to model game complexity without sacrificing iteration speed.
The Ludo board has 52 movement squares, four colour-coded home bases, a shared centre winning zone, and a deterministic dice that yields values 1–6. A well-structured Python bot isolates three concerns: board state representation, legal move generation, and move ranking via heuristics or search.
Modelling the Board State
Before evaluating any move you need an unambiguous representation of the game position. The board is modelled as a dictionary mapping token IDs to their current positions, alongside global state flags for each player's tokens.
from enum import IntEnum
from dataclasses import dataclass, field
from typing import List, Optional, Tuple
import random
class Player(IntEnum):
RED = 0
GREEN = 1
BLUE = 2
YELLOW = 3
# Board has 52 main track squares + 5 home-stretch squares per player
HOME_STRETCH_START = {Player.RED: 0, Player.GREEN: 13,
Player.BLUE: 26, Player.YELLOW: 39}
SAFE_SQUARES = [0, 8, 13, 21, 26, 34, 39, 47]
@dataclass
class TokenState:
player: Player
square: int # -1 = in hand, 0-51 = main track, 100+ = home stretch
finished: bool = False
@dataclass
class LudoBoard:
tokens: List[TokenState] = field(default_factory=list)
dice_value: int = 0
def get_legal_moves(self, player: Player) -> List[Tuple[int, str]]:
"""Return list of (token_index, move_description) tuples."""
moves = []
for i, token in enumerate(self.tokens):
if token.player != player or token.finished:
continue
# Move from hand onto board on a roll of 6
if token.square == -1 and self.dice_value == 6:
start = HOME_STRETCH_START[player]
moves.append((i, f"enter_board_onto_{start}"))
# Advance on board
elif token.square >= 0:
new_pos = token.square + self.dice_value
# Clamp to home stretch
if new_pos <= 56:
moves.append((i, f"advance_to_{new_pos}"))
# Home stretch movement
elif 100 <= token.square < 104:
new_pos = token.square + self.dice_value
if new_pos == 105:
moves.append((i, "finish"))
elif new_pos < 105:
moves.append((i, f"home_advance_to_{new_pos}"))
return moves
def apply_move(self, token_idx: int, move: str) -> None:
token = self.tokens[token_idx]
if "enter" in move:
token.square = HOME_STRETCH_START[token.player]
elif move == "finish":
token.finished = True; token.square = 105
elif "home" in move:
token.square = 100 + (token.square - 51 + self.dice_value)
else:
token.square += self.dice_valueEvaluating Moves with Weighted Heuristics
A full minimax search over the Ludo game tree is computationally intractable due to branching factors of up to 4 tokens × 6 dice faces per move. Instead, we use a weighted heuristic scorer that assigns numerical values to each board state property, then picks the move with the highest total score.
The key heuristics are:
- Safety score: Tokens on safe squares (star squares) cannot be captured. We assign +30 points for safe positions.
- Progress score: Tokens further along the home stretch are closer to victory. We use a linear scale from 0–50 based on square index.
- Capture threat score: If a move lands on an opponent's token, we add +80 points because sent tokens return to base.
- Exit penalty: Moving a token from base onto the board should be prioritised when multiple 6s are rolled. We add +20 for exit moves.
- Finish bonus: Reaching the home centre awards the full +100 points.
class LudoBot:
SAFETY_BONUS = 30
CAPTURE_BONUS = 80
EXIT_BONUS = 20
FINISH_BONUS = 100
def __init__(self, player: Player):
self.player = player
def score_state(self, board: LudoBoard) -> float:
score = 0.0
for token in board.tokens:
if token.player != self.player or token.finished:
continue
if token.square == -1: # Still in base — low priority
score -= 5
continue
# Progress along home stretch: 0→50 linear scale
if token.square >= 100:
score += (5 * (token.square - 100)) + 40
else:
score += (token.square / 51) * 50
# Safe square bonus
if token.square % 13 in SAFE_SQUARES:
score += self.SAFETY_BONUS
# Check for capturable opponents
opp_tokens = [t for t in board.tokens
if t.player != self.player and t.square == token.square
and t.square % 13 not in SAFE_SQUARES]
score += len(opp_tokens) * self.CAPTURE_BONUS
return score
def choose_move(self, board: LudoBoard) -> Optional[Tuple[int, str]]:
legal = board.get_legal_moves(self.player)
if not legal:
return None
best_move, best_score = None, float("-inf")
for token_idx, move_desc in legal:
board.apply_move(token_idx, move_desc)
s = self.score_state(board)
# Tie-break: prefer captures and finishes
if move_desc == "finish": s += 5
if s > best_score:
best_score, best_move = s, (token_idx, move_desc)
board.tokens[token_idx].square -= board.dice_value # undo
return best_move
def play_turn(board: LudoBoard, bot: LudoBot) -> None:
board.dice_value = random.randint(1, 6)
move = bot.choose_move(board)
if move:
token_idx, desc = move
board.apply_move(token_idx, desc)
print(f"Player {bot.player.name} rolled {board.dice_value} → {desc}")Dice Simulation and Turn Flow
Python's random.randint handles fair dice rolling. A key Ludo rule is that rolling a 6 grants an
extra turn, and the entire turn repeats until a non-6 is rolled. The bot's play_turn function
should be wrapped in a loop that checks this condition:
In a real integration, you would use the Ludo API to read actual game state from a live server and submit moves programmatically. The board representation above can be serialised from the JSON payload returned by the REST API endpoint.
Extending to Minimax with Alpha-Beta Pruning
If you want to go beyond simple heuristics, implement a minimax search with alpha-beta pruning. Depth 3 is a practical ceiling given the branching factor. At each node, simulate all possible dice outcomes and all legal moves for the current player. Prune branches where the alpha-beta bounds are violated.
The LudoGamePython project in our game dev guide provides a full server-client scaffold where this bot can be connected as an AI opponent.
Connecting to a Real Game Server
The bot class above works against a local simulation. To play against real opponents, replace the local
LudoBoard with live data from the Ludo API
documentation. Authenticate with your API key, subscribe to game state events via the realtime WebSocket feed, and feed the JSON payload into the
board parser before calling choose_move.
Frequently Asked Questions
LudoBoard instance before calling
choose_move.SAFE_SQUARES list and home-stretch length to match Ludo King's board layout if you are
integrating with its unofficial API.choose_move → apply the move → if a 6 was rolled, repeat. For fully automated multi-game
runs, consider the scheduling patterns covered in the Ludo game automation guide.Ready to Build Your Ludo Bot?
Connect your Python bot to live Ludo games with the LudoKingAPI realtime feed and move submission endpoint.