Snake & Ladder

import java.util.*;

// ---------- the design decision: randomness is a collaborator, not a call ----------
interface Dice {
    int roll();
}

class RandomDice implements Dice {
    private final Random random;
    private final int faces;
    RandomDice()                     { this(6, new Random()); }
    RandomDice(int faces, Random r)  { this.faces = faces; this.random = r; }
    public int roll() { return 1 + random.nextInt(faces); }
}

/** Fixed sequence — for tests, replays and reproducible demos. */
class LoadedDice implements Dice {
    private final int[] values;
    private int i = 0;
    LoadedDice(int... values) { this.values = values; }
    public int roll() { return values[i++ % values.length]; }
}

class Player {
    private final String name;
    private int position = 0;                 // 0 == not yet on the board
    Player(String name) { this.name = name; }
    String name()      { return name; }
    int position()     { return position; }
    void moveTo(int p) { this.position = p; }
}

/** A snake and a ladder are the same thing: land on "from", go to "to". */
class Board {
    private final int lastSquare;
    private final Map<Integer, Integer> jumps;

    Board(int lastSquare, Map<Integer, Integer> jumps) {
        this.lastSquare = lastSquare;
        this.jumps = Map.copyOf(jumps);
        jumps.forEach((from, to) -> {
            if (from < 1 || from > lastSquare || to < 1 || to > lastSquare)
                throw new IllegalArgumentException("jump off the board: " + from + "->" + to);
            if (from.equals(to)) throw new IllegalArgumentException("jump to itself: " + from);
        });
    }

    int lastSquare() { return lastSquare; }

    /** One lookup. to &lt; from is a snake, to &gt; from is a ladder — the difference is arithmetic. */
    int destinationFrom(int square) { return jumps.getOrDefault(square, square); }

    static Board classic() {
        Map<Integer, Integer> j = new HashMap<>();
        j.put(1, 38);  j.put(4, 14);  j.put(9, 31);  j.put(21, 42);
        j.put(28, 84); j.put(51, 67); j.put(71, 91); j.put(80, 100);   // ladders
        j.put(17, 7);  j.put(36, 6);  j.put(49, 11); j.put(54, 34);
        j.put(62, 18); j.put(87, 24); j.put(95, 56); j.put(98, 78);    // snakes
        return new Board(100, j);
    }
}

/** House rules are data, not subclasses. */
record GameRules(boolean exactLanding, boolean extraTurnOnSix) {
    static GameRules classic() { return new GameRules(true, true); }
}

record TurnResult(Player player, int roll, int from, int to, boolean jumped, boolean won, boolean forfeited) {}

class Game {
    private final Board board;
    private final Deque<Player> turns = new ArrayDeque<>();
    private final Dice dice;
    private final GameRules rules;
    private Player winner;

    Game(Board board, List<Player> players, Dice dice, GameRules rules) {
        if (players.size() < 2) throw new IllegalArgumentException("need at least two players");
        this.board = board;
        this.dice = dice;
        this.rules = rules;
        this.turns.addAll(players);
    }

    boolean isOver()  { return winner != null; }
    Player winner()   { return winner; }
    Player current()  { return turns.peekFirst(); }

    /** ONE turn. No loop, no printing — so this works in a test, a UI or a simulation. */
    TurnResult playTurn() {
        if (isOver()) throw new IllegalStateException("game is over");

        Player player = turns.removeFirst();
        int roll = dice.roll();
        int from = player.position();
        int target = from + roll;

        // overshoot: forfeit, or clamp, depending on the house rule
        if (target > board.lastSquare()) {
            if (rules.exactLanding()) {
                turns.addLast(player);
                return new TurnResult(player, roll, from, from, false, false, true);
            }
            target = board.lastSquare();
        }

        int after = board.destinationFrom(target);      // one jump per turn, never a chain
        player.moveTo(after);

        if (after == board.lastSquare()) {
            winner = player;
            return new TurnResult(player, roll, from, after, after != target, true, false);
        }

        // rolling a six keeps you at the front of the queue
        if (rules.extraTurnOnSix() && roll == 6) turns.addFirst(player);
        else                                     turns.addLast(player);

        return new TurnResult(player, roll, from, after, after != target, false, false);
    }
}

public class Main {
    public static void main(String[] args) {
        List<Player> players = List.of(new Player("Asha"), new Player("Ravi"), new Player("Meera"));

        // ---- deterministic: the same game every run ----
        Game game = new Game(Board.classic(), players, new LoadedDice(4, 6, 2, 5, 3, 1), GameRules.classic());
        while (!game.isOver()) {
            TurnResult t = game.playTurn();
            System.out.printf("%-6s rolls %d : %d -> %d%s%s%n",
                    t.player().name(), t.roll(), t.from(), t.to(),
                    t.jumped() ? "  (jump)" : "", t.forfeited() ? "  (forfeit)" : "");
        }
        System.out.println("winner: " + game.winner().name());

        // ---- the test the injected dice makes possible ----
        Player solo = new Player("Test");
        Game t = new Game(Board.classic(), List.of(solo, new Player("Other")),
                          new LoadedDice(4), GameRules.classic());
        t.playTurn();
        System.out.println("rolled 4 from 0, ladder at 4 -> position " + solo.position() + " (expected 14)");
    }
}