Raised renders to Play class

Author: OrderAndCh4oS

rummy/game/players.py

@@ -15,15 +15,15 @@ def __init__(self):
     def choose_players(self):
         self.number_of_players = int(UserInput.create_input(MenuActionDialog.human_players()))
         for _ in range(int(self.number_of_players)):
-            self.players.append(Human(len(self.players)))
+            self.players.append(Human(len(self.players) + 1))
 
     def choose_opponents(self):
         if self.number_of_players in [-1, 0, 1]:
             self.number_of_opponents = int(
                 UserInput.create_input(MenuActionDialog.ai_players(self.number_of_players)))
             ai_only = self.is_ai_only()
             for _ in range(int(self.number_of_opponents)):
-                self.players.append(AI(len(self.players), ai_only))
+                self.players.append(AI(len(self.players) + 1, ai_only))
 
     def is_ai_only(self):
         return True if self.number_of_players is 0 else False

rummy/game/score.py

@@ -28,12 +28,12 @@ def is_end_of_game(self):
                 return True
         return False
 
-    def end_game(self):
+    def show_winners(self):
         winners = self.find_lowest_scores()
         if len(winners) == 1:
-            View.render(Colour.green("%s is the Winner!!" % winners[0]))
+            return Colour.green("%s is the Winner!!" % winners[0])
         else:
-            View.render(Colour.green(", ".join([str(w) for w in winners]) + " are joint winners!"))
+            return Colour.green(", ".join([str(w) for w in winners]) + " are joint winners!")
 
     def find_lowest_scores(self):
         lowest = []

rummy/play.py

@@ -42,31 +42,36 @@ def play_game(self):
             self.round.prepare_turn()
             player = self.players[self.round.current_player]
             player.turn(self.round)
+            View.render(player.show_turn_start())
+            View.render(player.has_someone_knocked())
+            View.render(player.draw_from_deck_or_discard_pile())
+            View.render(player.show_turn_end())
+            player.discard_or_knock()
+            View.render(player.show_discard())
             self.round.end_turn()
-        self.end_round()
+        View.render(self.end_round())
         sleep(1.2)
-        self.start_new_round_or_end_game()
-
-    def start_new_round_or_end_game(self):
         if self.score.is_end_of_game():
-            self.score.end_game()
+            View.render(self.score.show_winners())
         else:
-            self.round.rotate_first_player()
-            if not self.ai_only:
-                self.confirm_start_new_round()
-            self.round.prepare_new_round()
-            self.round.deal_cards(self.players)
-            self.play_game()
+            self.start_new_round()
+
+    def start_new_round(self):
+        self.round.rotate_first_player()
+        if not self.ai_only:
+            self.confirm_start_new_round()
+        self.round.prepare_new_round()
+        self.round.deal_cards(self.players)
+        self.play_game()
 
     @staticmethod
     def confirm_start_new_round():
         UserInput.create_input(MenuActionDialog.next_round())
 
     def end_round(self):
         self.score.update_player_scores()
-        View.render(
-            View.template_this_round_score(self.score.get_end_of_round_scores(), self.score.get_current_game_scores())
-        )
+        return View.template_this_round_score(self.score.get_end_of_round_scores(),
+                                              self.score.get_current_game_scores())
 
 
 # start game

rummy/player/player.py

@@ -23,14 +23,6 @@ def __str__(self):
 
     def turn(self, game_round):
         self.round = game_round
-        self.has_someone_knocked()
-        # Todo: the methods used below should only return the data,
-        # Todo: the data should be passed to the render method with the view to use.
-        View.render(self.show_turn_start())
-        View.render(self.draw_from_deck_or_discard_pile())
-        View.render(self.show_turn_end())
-        self.discard_or_knock()
-        View.render(self.show_discard())
 
     def take_from_deck(self):
         self.hand.draw_card(self.round.deck.take_card())
@@ -62,7 +54,7 @@ def display_round_score(self):
 
     def has_someone_knocked(self):
         if self.round.knocked:
-            View.render(View.prepare_template('/knocked.txt'))
+            return View.prepare_template('/knocked.txt')
 
     @abstractmethod
     def show_turn_start(self):

tests/game/test_score.py

@@ -1,8 +1,8 @@
 # coding=utf-8
 
 from rummy.game.score import Score
-from rummy.player.player import Player
 from rummy.player.human import Human
+from rummy.player.player import Player
 
 
 class TestScore:
@@ -29,14 +29,13 @@ def test_is_end_of_game(self, mocker):
         mocker.patch.object(Player, 'get_game_score', side_effect=[80, 85, 90, 99])
         assert not score.is_end_of_game()
 
+    # ToDo: End game is now handled in Play, not sure how to fix this test
     def test_end_game(self, mocker):
         mocker.patch('builtins.print')
         mocker.patch.object(Score, 'find_lowest_scores', side_effect=[[Human(1)], [Human(1), Human(2)]])
         score = Score([Human(1), Human(2)])
-        score.end_game()
-        print.assert_called_with('\x1b[0;32mPlayer 1 is the Winner!!\x1b[0m')
-        score.end_game()
-        print.assert_called_with('\x1b[0;32mPlayer 1, Player 2 are joint winners!\x1b[0m')
+        assert '\x1b[0;32mPlayer 1 is the Winner!!\x1b[0m' == score.show_winners()
+        assert '\x1b[0;32mPlayer 1, Player 2 are joint winners!\x1b[0m' == score.show_winners()
 
     def test_find_lowest_scores(self, mocker):
         human1 = mocker.MagicMock()

tests/player/test_player.py

@@ -42,8 +42,8 @@ def test_turn(self, mocker):
         assert not player.ai_only
         assert isinstance(player.hand, Hand)
         assert isinstance(player.melds, Melds)
-        assert DummyPlayer.has_someone_knocked.call_count == 1
-        assert DummyPlayer.discard_or_knock.call_count == 1
+        # assert DummyPlayer.has_someone_knocked.call_count == 1
+        # assert DummyPlayer.discard_or_knock.call_count == 1
 
     def test_get_name(self):
         player = DummyPlayer(1)