chessai.ui.text

  1import sys
  2import typing
  3
  4import chessai.core.gamestate
  5import chessai.core.piece
  6import chessai.core.ui
  7
  8DEFAULT_PADDING_SIZE: int = 1
  9""" The default number of padding spaces between each piece and the square border. """
 10
 11class TextUI(chessai.core.ui.UI):
 12    """
 13    A simple UI that renders the game to a text stream.
 14    This UI will be simple and generally meant for debugging.
 15    """
 16
 17    SYMBOL_SIZE: int = 2
 18    """
 19    The space reserved to display the symbols.
 20    Pieces represent themselves as unicode symbols, which often take two spaces.
 21    """
 22
 23    def __init__(self,
 24            output_stream: typing.TextIO,
 25            padding_size: int = DEFAULT_PADDING_SIZE,
 26            **kwargs: typing.Any) -> None:
 27        super().__init__(**kwargs)
 28
 29        self._output_stream: typing.TextIO = output_stream
 30        """ The stream output will be sent to. """
 31
 32        self._padding_size: int = padding_size
 33        """ The number of padding spaces between each piece and the square border. """
 34
 35        self._cell_width: int = self.SYMBOL_SIZE
 36        """ The width of an individual cell, including the padding and symbol sizes. """
 37
 38        self._file_labels: str | None = None
 39        """ The file labels to be displayed at the bottom of the board. """
 40
 41        self._horizontal_border: str | None = None
 42        """ The horizontal border to be displayed between each rank. """
 43
 44    def draw(self,
 45            state: chessai.core.gamestate.GameState,
 46            termination_reason: chessai.core.types.TerminationReason | None = None,
 47            **kwargs: typing.Any,
 48            ) -> None:
 49        if (state.get_previous_action() == chessai.core.action.NoneAction()):
 50            return
 51
 52        # Draw the top border.
 53        self._output_stream.write(self._get_horizontal_border(state))
 54
 55        prefix_padding_size = self._get_prefix_padding_size(state)
 56
 57        for rank in range((state.board.num_ranks - 1), -1, -1):
 58            rank_str = str(rank + 1)
 59            rank_padding_size = prefix_padding_size - len(rank_str)
 60            rank_padding = ' ' * rank_padding_size
 61
 62            line = f"{rank_str}{rank_padding}{self._get_padding()}|"
 63
 64            for file in range(state.board.num_files):
 65                piece_symbol = self._translate_piece(state.board.get(file, rank))
 66                line += f"{piece_symbol}|"
 67
 68            self._output_stream.write(line + "\n")
 69            self._output_stream.write(self._get_horizontal_border(state))
 70
 71        self._output_stream.write(self._get_file_labels(state))
 72
 73        # Display the most recent action.
 74        action = state.get_previous_action()
 75        if (action is not None):
 76            self._output_stream.write(f"Previous action: '{action}'.\n")
 77
 78        if (termination_reason is not None):
 79            self._output_stream.write('Game Over!\n')
 80            self._output_stream.write(f"Termination Reason: '{termination_reason}'.\n")
 81
 82        self._output_stream.write('\n')
 83        self._output_stream.flush()
 84
 85    def _get_padding(self) -> str:
 86        """ Get the padding for this UI. """
 87
 88        return " " * self._padding_size
 89
 90    def _get_prefix_padding(self, state: chessai.core.gamestate.GameState) -> str:
 91        """
 92        Get the initial padding for rows without a column numbering,
 93        such as the horizontal border and the file labels.
 94        """
 95
 96        prefix_padding_size = self._get_prefix_padding_size(state)
 97
 98        prefix_padding = ' ' * prefix_padding_size
 99
100        return f"{prefix_padding}{self._get_padding()}"
101
102
103    def _get_prefix_padding_size(self, state: chessai.core.gamestate.GameState) -> int:
104        """ Get the size of the prefix padding to account for the rank labels. """
105
106        prefix_padding_size = 1
107        num_ranks = state.board.num_ranks
108
109        while (num_ranks >= 10):
110            prefix_padding_size += 1
111            num_ranks = num_ranks // 10
112
113        return prefix_padding_size
114
115    def _get_horizontal_border(self, state: chessai.core.gamestate.GameState) -> str:
116        """ Get the horizontal border for the UI. """
117
118        if (self._horizontal_border is not None):
119            return self._horizontal_border
120
121        dash_segment = '-' * self._cell_width + '+'
122
123        horizontal_border = f"{self._get_prefix_padding(state)}+" + (dash_segment * state.board.num_files) + '\n'
124
125        # Cache the horizontal border for subsequent calls.
126        self._horizontal_border = horizontal_border
127
128        return self._horizontal_border
129
130    def _get_file_labels(self, state: chessai.core.gamestate.GameState) -> str:
131        """ Get the labels of the files for the bottom of the board. """
132
133        if (self._file_labels is not None):
134            return self._file_labels
135
136        file_labels = self._get_prefix_padding(state)
137        for file in range(state.board.num_files):
138            # Use a coordinate to get the file name.
139            coordinate = chessai.core.coordinate.Coordinate(file, 0)
140
141            file_str = coordinate.uci(only_file = True)
142            file_labels += f"{self._get_padding()}{file_str}{self._get_padding()}"
143
144        file_labels += '\n'
145
146        # Cache the file labels for subsequent calls to the UI.
147        self._file_labels = file_labels
148
149        return file_labels
150
151    def _translate_piece(self, piece: chessai.core.piece.Piece | None) -> str:
152        """
153        Convert a piece to a string.
154        This can be trivial (since a piece knows how to represent itself as a string),
155        but this allows children to implement special conversions.
156        """
157
158        if (piece is None):
159            return ' ' * self.SYMBOL_SIZE
160
161        return piece.unicode_symbol().center(self.SYMBOL_SIZE)
162
163class StdioUI(TextUI):
164    """
165    A convenience class for a TextUI using stdout.
166    """
167
168    def __init__(self, **kwargs: typing.Any) -> None:
169        super().__init__(sys.stdout, **kwargs)