1class GameStatus(Enum):
2    NOT_STARTED = "NOT_STARTED"
3    RUNNING = "RUNNING"
4    FINISHED = "FINISHED"

1class Dice:
2    def __init__(self, min_value: int, max_value: int):
3        self.min_value = min_value
4        self.max_value = max_value
5
6    def roll(self) -> int:
7        return int(random.random() * (self.max_value - self.min_value + 1) + self.min_value)

1class Player:
2    def __init__(self, name: str):
3        self.name = name
4        self.position = 0
5
6    def get_name(self) -> str:
7        return self.name
8
9    def get_position(self) -> int:
10        return self.position
11
12    def set_position(self, position: int):
13        self.position = position

1class BoardEntity(ABC):
2    def __init__(self, start: int, end: int):
3        self.start = start
4        self.end = end
5    
6    def get_start(self) -> int:
7        return self.start
8    
9    def get_end(self) -> int:
10        return self.end

1class Snake(BoardEntity):
2    def __init__(self, start: int, end: int):
3        super().__init__(start, end)
4        if start <= end:
5            raise ValueError("Snake head must be at a higher position than its tail.")

1class Ladder(BoardEntity):
2    def __init__(self, start: int, end: int):
3        super().__init__(start, end)
4        if start >= end:
5            raise ValueError("Ladder bottom must be at a lower position than its top.")

1class Board:
2    def __init__(self, size: int, entities: List[BoardEntity]):
3        self.size = size
4        self.snakes_and_ladders = {}
5        
6        for entity in entities:
7            self.snakes_and_ladders[entity.get_start()] = entity.get_end()
8    
9    def get_size(self) -> int:
10        return self.size
11    
12    def get_final_position(self, position: int) -> int:
13        return self.snakes_and_ladders.get(position, position)

1class Game:
2    class Builder:
3        def __init__(self):
4            self.board = None
5            self.players = None
6            self.dice = None
7        
8        def set_board(self, board_size: int, board_entities: List[BoardEntity]):
9            self.board = Board(board_size, board_entities)
10            return self
11        
12        def set_players(self, player_names: List[str]):
13            self.players = deque()
14            for player_name in player_names:
15                self.players.append(Player(player_name))
16            return self
17        
18        def set_dice(self, dice: Dice):
19            self.dice = dice
20            return self
21        
22        def build(self):
23            if self.board is None or self.players is None or self.dice is None:
24                raise ValueError("Board, Players, and Dice must be set.")
25            return Game(self)
26    
27    def __init__(self, builder: 'Game.Builder'):
28        self.board = builder.board
29        self.players = deque(builder.players)
30        self.dice = builder.dice
31        self.status = GameStatus.NOT_STARTED
32        self.winner = None
33    
34    def play(self):
35        if len(self.players) < 2:
36            print("Cannot start game. At least 2 players are required.")
37            return
38        
39        self.status = GameStatus.RUNNING
40        print("Game started!")
41        
42        while self.status == GameStatus.RUNNING:
43            current_player = self.players.popleft()
44            self.take_turn(current_player)
45            
46            # If the game is not finished and the player didn't roll a 6, add them back to the queue
47            if self.status == GameStatus.RUNNING:
48                self.players.append(current_player)
49        
50        print("Game Finished!")
51        if self.winner is not None:
52            print(f"The winner is {self.winner.get_name()}!")
53    
54    def take_turn(self, player: Player):
55        roll = self.dice.roll()
56        print(f"\n{player.get_name()}'s turn. Rolled a {roll}.")
57        
58        current_position = player.get_position()
59        next_position = current_position + roll
60        
61        if next_position > self.board.get_size():
62            print(f"Oops, {player.get_name()} needs to land exactly on {self.board.get_size()}. Turn skipped.")
63            return
64        
65        if next_position == self.board.get_size():
66            player.set_position(next_position)
67            self.winner = player
68            self.status = GameStatus.FINISHED
69            print(f"Hooray! {player.get_name()} reached the final square {self.board.get_size()} and won!")
70            return
71        
72        final_position = self.board.get_final_position(next_position)
73        
74        if final_position > next_position:  # Ladder
75            print(f"Wow! {player.get_name()} found a ladder 🪜 at {next_position} and climbed to {final_position}.")
76        elif final_position < next_position:  # Snake
77            print(f"Oh no! {player.get_name()} was bitten by a snake 🐍 at {next_position} and slid down to {final_position}.")
78        else:
79            print(f"{player.get_name()} moved from {current_position} to {final_position}.")
80        
81        player.set_position(final_position)
82        
83        if roll == 6:
84            print(f"{player.get_name()} rolled a 6 and gets another turn!")
85            self.take_turn(player)

1class SnakeAndLadderDemo:
2    @staticmethod
3    def main():
4        board_entities = [
5            Snake(17, 7), Snake(54, 34),
6            Snake(62, 19), Snake(98, 79),
7            Ladder(3, 38), Ladder(24, 33),
8            Ladder(42, 93), Ladder(72, 84)
9        ]
10        
11        players = ["Alice", "Bob", "Charlie"]
12        
13        game = Game.Builder() \
14            .set_board(100, board_entities) \
15            .set_players(players) \
16            .set_dice(Dice(1, 6)) \
17            .build()
18        
19        game.play()
20
21
22if __name__ == "__main__":
23    SnakeAndLadderDemo.main()