Only allow "Random" color selection for online public seeks

This change is due to lichess PR# 15969 deprecating the ability
to choose your color on public seeks.

Author: trevorbayless

src/cli_chess/core/game/game_model_base.py

@@ -10,10 +10,10 @@
 
 
 class GameModelBase:
-    def __init__(self, orientation: Color = WHITE, variant="standard", fen=""):
+    def __init__(self, orientation: Color = WHITE, variant="standard", fen="", side_confirmed=True):
         self.game_metadata = GameMetadata()
 
-        self.board_model = BoardModel(orientation, variant, fen)
+        self.board_model = BoardModel(orientation, variant, fen, side_confirmed)
         self.move_list_model = MoveListModel(self.board_model)
         self.material_diff_model = MaterialDifferenceModel(self.board_model)
 
@@ -53,11 +53,11 @@ def _notify_game_model_updated(self, *args, **kwargs) -> None:
 
 
 class PlayableGameModelBase(GameModelBase, ABC):
-    def __init__(self, play_as_color: str, variant="standard", fen=""):
+    def __init__(self, play_as_color: str, variant="standard", fen="", side_confirmed=True):
         self.my_color = self._get_side_to_play_as(play_as_color)
         self.game_in_progress = False
 
-        super().__init__(orientation=self.my_color, variant=variant, fen=fen)
+        super().__init__(orientation=self.my_color, variant=variant, fen=fen, side_confirmed=side_confirmed)
         self.premove_model = PremoveModel(self.board_model)
         self._assoc_models = self._assoc_models + [self.premove_model]
 

src/cli_chess/core/game/game_options.py

@@ -105,31 +105,39 @@ def __init__(self):
     time_control_options_dict.update(additional_time_controls)
 
 
-class OnlineGameOptions(BaseGameOptions):
-    """Game Options class with defined options permitted for board API use"""
+class OnlinePublicGameOptions(BaseGameOptions):
+    """Game Options class with defined options permitted for public seek board API use"""
     def __init__(self):
         super().__init__()
         self.dict_map = {
             GameOption.VARIANT: BaseGameOptions.variant_options_dict,
-            GameOption.TIME_CONTROL: self.time_control_options_dict,
-            GameOption.COMPUTER_SKILL_LEVEL: BaseGameOptions.skill_level_options_dict,
+            GameOption.TIME_CONTROL: BaseGameOptions.time_control_options_dict,
             GameOption.RATED: self.rated_options_dict,
-            GameOption.RATING_RANGE: None,
-            GameOption.COLOR: BaseGameOptions.color_options,
+            GameOption.COLOR: self.color_options
         }
 
+    color_options = {
+        "Random": "random"  # Online public seeks must be random (lila PR# 15969)
+    }
+
     rated_options_dict = {
         "No": False,
         "Yes": True
     }
 
 
-class OnlineDirectChallengesGameOptions(OnlineGameOptions):
+class OnlineDirectChallengesGameOptions(BaseGameOptions):
     """Game Options class with defined options for direct challenges.
-       Brings in the additional permitted time controls.
+       Brings in the additional side to play as and permitted time controls options.
     """
     def __init__(self):
         super().__init__()
+        self.dict_map = {
+            GameOption.VARIANT: BaseGameOptions.variant_options_dict,
+            GameOption.TIME_CONTROL: self.time_control_options_dict,
+            GameOption.COMPUTER_SKILL_LEVEL: BaseGameOptions.skill_level_options_dict,
+            GameOption.COLOR: BaseGameOptions.color_options,
+        }
 
     time_control_options_dict = dict(BaseGameOptions.time_control_options_dict)
     additional_time_controls = {

src/cli_chess/core/game/offline_game/offline_game_model.py

@@ -81,7 +81,6 @@ def _update_game_metadata(self, *args, data: Optional[Dict] = None, **kwargs) ->
             return
         try:
             if EventTopics.GAME_PARAMS in args:
-                self.game_metadata.my_color = self.my_color
                 self.game_metadata.variant = data[GameOption.VARIANT]
                 self.game_metadata.players[self.my_color].name = player_info_config.get_value(player_info_config.Keys.OFFLINE_PLAYER_NAME)  # noqa: E501
 

src/cli_chess/core/game/online_game/online_game_model.py

@@ -19,7 +19,7 @@ class OnlineGameModel(PlayableGameModelBase):
        Games not owned by this account must directly use the base model instead.
     """
     def __init__(self, game_parameters: dict, is_vs_ai: bool):
-        super().__init__(play_as_color=game_parameters[GameOption.COLOR], variant=game_parameters[GameOption.VARIANT], fen=None)
+        super().__init__(play_as_color=game_parameters[GameOption.COLOR], variant=game_parameters[GameOption.VARIANT], fen=None, side_confirmed=is_vs_ai)  # noqa: E501
         self.vs_ai = is_vs_ai
         self.playing_game_id = None
         self.searching = False
@@ -48,15 +48,15 @@ def create_game(self) -> None:
                 self.api_client.challenges.create_ai(level=self.game_metadata.players[not self.my_color].ai_level,
                                                      clock_limit=self.game_metadata.clocks[WHITE].time * 60,  # challenges need time in seconds
                                                      clock_increment=self.game_metadata.clocks[WHITE].increment,
-                                                     color=COLOR_NAMES[self.game_metadata.my_color],
+                                                     color=COLOR_NAMES[self.my_color],
                                                      variant=self.game_metadata.variant)
             else:  # Find a random opponent
                 payload = {
                     "rated": str(self.game_metadata.rated).lower(),
                     "time": self.game_metadata.clocks[WHITE].time,
                     "increment": self.game_metadata.clocks[WHITE].increment,
                     "variant": self.game_metadata.variant,
-                    "color": COLOR_NAMES[self.game_metadata.my_color],
+                    "color": "random",  # lila PR# 15969
                     "ratingRange": "",
                 }
                 for _ in self.api_client.board._r.post("/api/board/seek", data=payload, fmt=TEXT, stream=True):
@@ -246,7 +246,6 @@ def _update_game_metadata(self, *args, sender: Optional[EventSender] = None, dat
         try:
             if sender is EventSender.LOCAL:
                 if EventTopics.GAME_PARAMS in args:  # This is the data that came from the menu selections
-                    self.game_metadata.my_color = self.my_color
                     self.game_metadata.variant = data.get(GameOption.VARIANT)
                     self.game_metadata.rated = data.get(GameOption.RATED, False)
                     self.game_metadata.players[not self.my_color].ai_level = data.get(GameOption.COMPUTER_SKILL_LEVEL) if self.vs_ai else None
@@ -259,8 +258,9 @@ def _update_game_metadata(self, *args, sender: Optional[EventSender] = None, dat
                 if EventTopics.GAME_START in args:
                     self.game_metadata.reset()
                     self.game_metadata.game_id = data.get('gameId')
-                    self.game_metadata.my_color = self.my_color
                     self.game_metadata.rated = data.get('rated')
+                    # Since lila PR# 15969, color seeks can only be random. This resets `my_color` to the color received
+                    self.my_color = Color(COLOR_NAMES.index(data.get('color')))
                     self.game_metadata.variant = data.get('variant', {}).get('name')
                     self.game_metadata.speed = data['speed']
 

src/cli_chess/menus/tv_channel_menu/tv_channel_menu_model.py

@@ -1,5 +1,5 @@
 from cli_chess.menus import MenuModel, MenuOption, MenuCategory
-from cli_chess.core.game.game_options import OnlineGameOptions
+from cli_chess.core.game.game_options import OnlinePublicGameOptions
 from types import MappingProxyType
 from enum import Enum
 
@@ -44,7 +44,7 @@ class TVChannelMenuOptions(Enum):
     @property
     def variant(self) -> str:
         """Return the chess variant related to the enum"""
-        variant = OnlineGameOptions.variant_options_dict.get(self.value)
+        variant = OnlinePublicGameOptions.variant_options_dict.get(self.value)
         if not variant:
             variant = "standard"
         return variant

src/cli_chess/menus/versus_menus/versus_menu_models.py

@@ -1,5 +1,5 @@
 from cli_chess.menus import MultiValueMenuModel, MultiValueMenuOption, MenuCategory
-from cli_chess.core.game.game_options import GameOption, OfflineGameOptions, OnlineGameOptions, OnlineDirectChallengesGameOptions
+from cli_chess.core.game.game_options import GameOption, OfflineGameOptions, OnlinePublicGameOptions, OnlineDirectChallengesGameOptions
 
 
 class VersusMenuModel(MultiValueMenuModel):
@@ -63,9 +63,9 @@ def __init__(self):
     def _create_menu() -> MenuCategory:
         """Create the online menu options"""
         menu_options = [
-            MultiValueMenuOption(GameOption.VARIANT, "Choose the variant to play", [option for option in OnlineGameOptions.variant_options_dict]),  # noqa: E501
-            MultiValueMenuOption(GameOption.TIME_CONTROL, "Choose the time control", [option for option in OnlineGameOptions.time_control_options_dict]),  # noqa: E501
-            MultiValueMenuOption(GameOption.RATED, "Choose if you'd like to play a casual or rated game", [option for option in OnlineGameOptions.rated_options_dict]),  # noqa: E501
-            MultiValueMenuOption(GameOption.COLOR, "Choose the side you would like to play as", [option for option in OnlineGameOptions.color_options]),  # noqa: E501
+            MultiValueMenuOption(GameOption.VARIANT, "Choose the variant to play", [option for option in OnlinePublicGameOptions.variant_options_dict]),  # noqa: E501
+            MultiValueMenuOption(GameOption.TIME_CONTROL, "Choose the time control", [option for option in OnlinePublicGameOptions.time_control_options_dict]),  # noqa: E501
+            MultiValueMenuOption(GameOption.RATED, "Choose if you'd like to play a casual or rated game", [option for option in OnlinePublicGameOptions.rated_options_dict]),  # noqa: E501
+            MultiValueMenuOption(GameOption.COLOR, "The side you play for an online public game is determined by Lichess", [option for option in OnlinePublicGameOptions.color_options]),  # noqa: E501
         ]
         return MenuCategory("Play Online vs Random Opponent", menu_options)

src/cli_chess/menus/versus_menus/versus_menu_presenters.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from cli_chess.menus.versus_menus import VersusMenuView
 from cli_chess.menus import MultiValueMenuPresenter
-from cli_chess.core.game.game_options import GameOption, BaseGameOptions, OfflineGameOptions, OnlineGameOptions, OnlineDirectChallengesGameOptions
+from cli_chess.core.game.game_options import GameOption, BaseGameOptions, OfflineGameOptions, OnlinePublicGameOptions, OnlineDirectChallengesGameOptions  # noqa: E501
 from cli_chess.core.game import start_online_game, start_offline_game
 from cli_chess.utils import log
 from abc import ABC, abstractmethod
@@ -78,7 +78,7 @@ def value_cycled_handler(self, selected_option: int):
     def handle_start_game(self) -> None:
         """Starts the game using the currently selected menu values"""
         try:
-            game_parameters = super()._create_dict_of_selected_values(OnlineGameOptions if not self.is_vs_ai else OnlineDirectChallengesGameOptions)
+            game_parameters = super()._create_dict_of_selected_values(OnlinePublicGameOptions if not self.is_vs_ai else OnlineDirectChallengesGameOptions)  # noqa: E501
             start_online_game(game_parameters, is_vs_ai=self.is_vs_ai)
         except Exception as e:
             log.error(e)

src/cli_chess/modules/board/board_model.py

@@ -7,10 +7,11 @@
 
 
 class BoardModel:
-    def __init__(self, orientation: chess.Color = chess.WHITE, variant="standard", fen="") -> None:
+    def __init__(self, orientation: chess.Color = chess.WHITE, variant="standard", fen="", side_confirmed=True) -> None:
         self.board = self._initialize_board(variant, fen)
         self.initial_fen = self.board.fen()
         self.orientation = chess.WHITE if variant.lower() == "racingkings" else orientation
+        self.side_confirmed = side_confirmed  # flag to indicate if the users color is fully confirmed (e.g. online)
         self.highlight_move = chess.Move.null()
         self.premove_highlight = chess.Move.null()
         self._game_over_result: Optional[chess.Outcome] = None
@@ -41,16 +42,18 @@ def _initialize_board(variant: str, fen: str):
             else:
                 return chess.variant.find_variant(variant)()
 
-    def reinitialize_board(self, variant: str, orientation: chess.Color, fen: str = "", uci_last_move=""):
+    def reinitialize_board(self, variant: str, orientation: chess.Color, fen: str = "", uci_last_move="", is_side_confirmed=True):
         """Reinitializes the existing board object to the new variant/fen.
            An optional uci_last_move can be passed in to highlight the last known move
+           Sets the "side_confirmed" to the passed in "is_side_confirmed" value. Defaults to true.
         """
         try:
             self.board = self._initialize_board(variant, fen)
             self.initial_fen = self.board.fen()
             self.set_board_orientation(chess.WHITE if variant.lower() == "racingkings" else orientation, notify=False)
             self.highlight_move = chess.Move.from_uci(uci_last_move) if uci_last_move else chess.Move.null()
             self._game_over_result = None
+            self.side_confirmed = is_side_confirmed
 
             self._log_init_info()
             self._notify_board_model_updated(EventTopics.GAME_START)
@@ -280,6 +283,14 @@ def is_white_orientation(self) -> bool:
         """Returns True if the board orientation is set as white"""
         return self.orientation is chess.WHITE
 
+    def is_side_confirmed(self) -> bool:
+        """Returns true if the users playing color is confirmed. This should always
+           be true once a game starts and an opponent is found. In Lichess online games
+           versus a random opponent, we need to wait until Lichess responds with our
+           starting color in order to know what color we start with
+        """
+        return self.side_confirmed
+
     def set_board_position(self, fen: str, uci_last_move=""):
         """Sets up the board using the passed in FEN. In addition, optionally the
            board orientation and last move can also be passed in. The last move must be

src/cli_chess/modules/board/board_presenter.py

@@ -70,7 +70,7 @@ def get_file_labels(self) -> str:
            is disabled in the configuration.
         """
         file_labels = ""
-        show_board_coordinates = self.game_config_values[game_config.Keys.SHOW_BOARD_COORDINATES]
+        show_board_coordinates = self.game_config_values[game_config.Keys.SHOW_BOARD_COORDINATES] and self.model.is_side_confirmed()
 
         if show_board_coordinates:
             file_labels = self.model.get_file_labels()
@@ -83,7 +83,7 @@ def get_rank_label(self, square: chess.Square) -> str:
         """
         rank_label = ""
         rank_index = self.model.get_square_rank_index(square)
-        show_board_coordinates = self.game_config_values[game_config.Keys.SHOW_BOARD_COORDINATES]
+        show_board_coordinates = self.game_config_values[game_config.Keys.SHOW_BOARD_COORDINATES] and self.model.is_side_confirmed()
 
         if self.is_square_start_of_rank(square) and show_board_coordinates:
             rank_label = self.model.get_rank_label(rank_index)