Agenda

1. How we organised the work
2. Quoridor · algorithm · heuristic · class concepts · live demo
3. Ghosts · algorithm · heuristic · class concepts · live demo
4. UNO · algorithm · heuristic · class concepts · live demo
5. Recap & what we'd do next

Total time ≤ 10 min talk + 5 min Q&A (per rubric)

How we organised the work

Game 1 - Quoridor

Quoridor - Algorithm

Depth-limited alpha-beta minimax

• Frontier: all pawn moves (≤4 after jump rule) + a capped set of wall placements (top-K sorted by proximity to opponent)
• Depth: 2 plies; deep enough to spot 1-move tactics, shallow enough to stay responsive
• Pruning: alpha-beta on negamax form
• Move legality: uses shortest_path_length() as a path-completeness check before placing a wall (matches the rule "walls cannot fully block any player")

def negamax(state, depth, alpha, beta):
    if depth == 0 or state.is_terminal():
        return eval(state)
    for m in order_moves(state):       # walls near opponent first
        v = -negamax(apply(state, m), depth-1, -beta, -alpha)
        alpha = max(alpha, v)
        if alpha >= beta: break
    return alpha

Quoridor - Heuristic

Path-length differential

The notebook tip is exactly this:

eval(state) = 10 * (opponent_path - my_path)
            + (my_walls_left - opp_walls_left)

• opponent_path - my_path is computed via BFS (already provided as shortest_path_length)
• Walls-in-hand kept as a small tie-breaker - preserves flexibility
• Why it works: winning = being closer to your goal than the opponent is to theirs; the BFS distance is an admissible-style proxy for "moves to win"

Quoridor - Class concepts

Game 2 - Ghosts

Ghosts - Algorithm

Expectiminimax-flavoured 2-ply search

• From the current state, enumerate own moves (≤32)
• For each, apply move, then take the worst opponent response from the top-K (we limit to 16 to keep latency low)
• Opponent piece types are unknown - they enter the eval as expected threat (see next slide)
• For setup, we don't search - we use a fixed strategy: good ghosts on the outer columns so they're 1 step from a corner exit

# Per candidate move
child = apply(state, move)
if child.winner: score = eval(child)
else:
    score = min(eval(apply(child, om)) for om in opp_moves[:16])
return argmax(moves by score)

Ghosts - Heuristic

Multi-term evaluation

• +60 × (own goods - opp goods) - good-ghost differential
• +25 × own evils remaining - keeps evils alive (we lose if all are captured)
• -5 × opp evils remaining - mild incentive to capture opp evils (with a small weight on purpose)
• -4 × distance(own goods → opponent exit row), +10 if on outer column
• -threat for opponent pieces moving toward our exit rows; revealed-evil pieces count for ~20% the threat of unknown/revealed-good

Belief reasoning is encoded in that last bullet - hidden pieces are penalised at full weight, revealed-evil pieces at reduced weight. This is the imperfect-information "trick" the notebook hints at.

Ghosts - Class concepts

Game 3 - UNO

UNO - Algorithm

Greedy / rule-based policy

• Enumerate get_valid_moves() (legal plays + draw)
• Score each candidate play with a hand-tuned heuristic (next slide)
• Pick the highest-scoring play; if no play, draw
• For a Wild, pick the color most common in our remaining hand

We deliberately did not use deep search here. Hidden hands plus a 100+-card stochastic deck make minimax a poor fit; a thoughtful greedy policy with the right features beats it in wall-clock practice for this assignment.

plays = [m for m in valid_moves if m['type'] == 'play']
if not plays: return {'type': 'draw', 'count': 1}
plays.sort(key=score, reverse=True)
return plays[0]

UNO - Heuristic

Card scoring (features)

Information used: get_hand_sizes() tells us when to switch to aggression; get_discard_pile() is available for full card counting (future work).

UNO - Class concepts

One-slide summary

What we'd do next

• Quoridor: iterative deepening so depth scales with available time; transposition table on (pawns, wall-set) keys
• Ghosts: particle-filter belief over hidden-type assignments and proper expectiminimax over the belief
• UNO: Monte-Carlo determinization - sample opponent hands consistent with the discard pile and average rollouts; this is the standard hidden-info game-AI move