Snake and ladder

interface Dice { roll(): number; }

class RandomDice implements Dice {
  constructor(private faces = 6) {}
  roll(): number { return 1 + Math.floor(Math.random() * this.faces); }
}

/** Rolls a fixed sequence: the game becomes testable without touching its code. */
class ScriptedDice implements Dice {
  constructor(private rolls: number[]) {}
  roll(): number {
    const r = this.rolls.shift();
    if (r === undefined) throw new Error("out of rolls");
    return r;
  }
}

class Board {
  constructor(readonly size: number, private jumps: Map<number, number>) {
    for (const [s, e] of jumps) if (!(s > 0 && s < size && e > 0 && e <= size) || s === e) throw new Error(`bad jump ${s}->${e}`);
  }
  destination(square: number): number { return this.jumps.get(square) ?? square; }
}

class Game {
  private queue: string[];
  private position = new Map<string, number>();
  winner: string | null = null;

  constructor(private board: Board, players: string[], private dice: Dice) {
    this.queue = [...players];
    for (const p of players) this.position.set(p, 0);
  }

  takeTurn(): string {
    const player = this.queue[0];
    const roll = this.dice.roll();
    const start = this.position.get(player)!;
    const target = start + roll;
    let note: string;
    if (target > this.board.size) { // must land exactly on the last square
      note = `${player} rolls ${roll}: needs ${this.board.size - start}, stays on ${start}`;
    } else {
      const end = this.board.destination(target);
      const kind = end === target ? "" : end > target ? " ladder up to" : " snake down to";
      note = `${player} rolls ${roll}: ${start} -> ${target}` + (kind ? `,${kind} ${end}` : "");
      this.position.set(player, end);
      if (end === this.board.size) {
        this.winner = player;
        return `${note}. ${player} wins`;
      }
    }
    this.queue.push(this.queue.shift()!);
    return note;
  }

  play(maxTurns = 1000): void {
    for (let i = 0; i < maxTurns && !this.winner; i++) console.log(this.takeTurn());
  }
}

const board = new Board(30, new Map([[3, 22], [5, 8], [11, 26], [20, 29], [17, 4], [19, 7], [21, 9], [27, 1]]));
new Game(board, ["Ana", "Ben"], new ScriptedDice([2, 3, 6, 2, 6, 4, 3, 1, 5, 2, 2, 1])).play();
void RandomDice; // the real game would pass new RandomDice()

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

interface Dice {
    int roll();
}

class RandomDice implements Dice {
    private final Random rng = new Random();
    private final int faces;

    RandomDice(int faces) {
        this.faces = faces;
    }

    public int roll() {
        return 1 + rng.nextInt(faces);
    }
}

/** Rolls a fixed sequence: the game becomes testable without touching its code. */
class ScriptedDice implements Dice {
    private final Deque<Integer> rolls;

    ScriptedDice(List<Integer> rolls) {
        this.rolls = new ArrayDeque<>(rolls);
    }

    public int roll() {
        return rolls.removeFirst();
    }
}

class Board {
    final int size;
    private final Map<Integer, Integer> jumps;

    Board(int size, Map<Integer, Integer> jumps) {
        jumps.forEach((s, e) -> {
            if (!(s > 0 && s < size && e > 0 && e <= size) || s.equals(e))
                throw new IllegalArgumentException("bad jump " + s + "->" + e);
        });
        this.size = size;
        this.jumps = jumps;
    }

    int destination(int square) {
        return jumps.getOrDefault(square, square);
    }
}

class Game {
    private final Board board;
    private final Dice dice;
    private final Deque<String> queue;
    private final Map<String, Integer> position = new HashMap<>();
    String winner;

    Game(Board board, List<String> players, Dice dice) {
        this.board = board;
        this.dice = dice;
        this.queue = new ArrayDeque<>(players);
        players.forEach(p -> position.put(p, 0));
    }

    String takeTurn() {
        String player = queue.peekFirst();
        int roll = dice.roll();
        int start = position.get(player), target = start + roll;
        String note;
        if (target > board.size) { // must land exactly on the last square
            note = player + " rolls " + roll + ": needs " + (board.size - start) + ", stays on " + start;
        } else {
            int end = board.destination(target);
            String kind = end == target ? "" : end > target ? " ladder up to" : " snake down to";
            note = player + " rolls " + roll + ": " + start + " -> " + target + (kind.isEmpty() ? "" : "," + kind + " " + end);
            position.put(player, end);
            if (end == board.size) {
                winner = player;
                return note + ". " + player + " wins";
            }
        }
        queue.addLast(queue.removeFirst());
        return note;
    }

    void play(int maxTurns) {
        for (int i = 0; i < maxTurns && winner == null; i++) System.out.println(takeTurn());
    }
}

public class Main {
    public static void main(String[] args) {
        Map<Integer, Integer> jumps = new HashMap<>(Map.of(3, 22, 5, 8, 11, 26, 20, 29, 17, 4, 19, 7, 21, 9, 27, 1));
        Board board = new Board(30, jumps);
        new Game(board, List.of("Ana", "Ben"), new ScriptedDice(List.of(2, 3, 6, 2, 6, 4, 3, 1, 5, 2, 2, 1))).play(1000);
        Dice real = new RandomDice(6); // the real game would pass this instead
        if (real.roll() < 1) throw new AssertionError();
    }
}