Created separate classes for views, removing them from templates

Author: OrderAndCh4oS

rummy/controller/ai_controller.py

@@ -1,40 +1,42 @@
 from random import choice
 
+from rummy.controller.player_controller import PlayerController
 from rummy.player.player import Player
 from rummy.ui.view import View
+from rummy.view.ai_view import AiView
 
 
-class AiController:
+class AiController(PlayerController):
 
     @staticmethod
     def show_start_turn(player: Player):
         output = ''
         if player.ai_only:
-            output += View.template_turn_start(player)
+            output += AiView.turn_start(player)
         else:
-            output += View.template_ai_turn_start(player)
-        output += View.template_ai_thought(player, 'Choosing pick up')
+            output += AiView.turn_start(player)
+        output += AiView.thinking(player, 'Choosing pick up')
         View.render(output)
 
     @staticmethod
     def show_end_turn(player: Player):
         output = ''
         if player.ai_only:
-            output += View.template_ai_turn_end(player)
-        output += View.template_ai_thought(player, 'Choosing card to discard')
+            output += AiView.turn_end(player)
+        output += AiView.thinking(player, 'Choosing card to discard')
         View.render(output)
 
     @staticmethod
     def show_knocked(player):
         if player.has_someone_knocked():
-            View.render(View.prepare_template('/knocked.txt'))
+            View.render(AiView.knocked())
 
     @staticmethod
     def show_discard(player: Player):
         output = ''
         if player.ai_only:
-            output += View.template_ai_hand_data(player.hand.get_score())
-        output += View.template_player_discarded(player.round.deck.inspect_discard())
+            output += AiView.hand_data(player.hand.get_score())
+        output += AiView.discarded(player.round.deck.inspect_discard())
         View.render(output)
 
     @classmethod
@@ -44,22 +46,22 @@ def draw_card(cls, player):
             current_score = player.hand.get_score()
             scores = player.melds.find_discard_scores(player.hand.get_hand(), player.round.deck.inspect_discard())
             if player.ai_only:
-                output += View.template_ai_discard_data(current_score, scores)
+                output += AiView.discard_data(current_score, scores)
             output += cls._choose_pickup(player, current_score, scores)
         else:
             player.take_from_deck()
-            output += View.template_ai_thought(player, 'Drawing from deck')
+            output += AiView.thinking(player, 'Drawing from deck')
         View.render(output)
 
     @staticmethod
     def _choose_pickup(player, current_score, scores):
         output = ''
         if min(scores) < current_score - 4 or min(scores) <= 10:
             player.take_from_discard()
-            output += View.template_ai_thought(player, 'Drawing from discard')
+            output += AiView.thinking(player, 'Drawing from discard')
         else:
             player.take_from_deck()
-            output += View.template_ai_thought(player, 'Drawing from deck')
+            output += AiView.thinking(player, 'Drawing from deck')
         return output
 
     @classmethod

rummy/controller/human_controller.py

@@ -1,31 +1,29 @@
-from rummy.player.human import Human
+from rummy.controller.player_controller import PlayerController
 from rummy.player.player import Player
 from rummy.ui.player_action_dialog import PlayerActionDialog
 from rummy.ui.user_input import UserInput
 from rummy.ui.view import View
+from rummy.view.human_view import HumanView
 
 
-class HumanController:
+class HumanController(PlayerController):
 
     @staticmethod
     def show_start_turn(player: Player):
-        if isinstance(player, Human):
-            View.render(View.template_turn_start(player))
+        View.render(HumanView.turn_start(player))
 
     @staticmethod
     def show_end_turn(player: Player):
-        if isinstance(player, Human):
-            View.render(View.template_player_turn_end(player))
+        View.render(HumanView.turn_end(player))
 
     @staticmethod
     def show_knocked(player):
         if player.has_someone_knocked():
-            View.render(View.prepare_template('/knocked.txt'))
+            View.render(HumanView.knocked())
 
     @staticmethod
     def show_discard(player: Player):
-        if isinstance(player, Human):
-            View.render(View.template_player_discarded(player.round.deck.inspect_discard()))
+        View.render(HumanView.discarded(player))
 
     @classmethod
     def draw_card(cls, player):

rummy/controller/player_controller.py

@@ -26,21 +26,11 @@ def show_discard(player: Player):
     def draw_card(cls, player):
         pass
 
-    @staticmethod
-    @abstractmethod
-    def _choose_pick_up(player):
-        pass
-
     @classmethod
     @abstractmethod
     def discard_or_knock(cls, player):
         pass
 
-    @staticmethod
-    @abstractmethod
-    def _choose_discard(player):
-        pass
-
     @staticmethod
     def show_knocked(player):
         if player.has_someone_knocked():

rummy/game/score.py

@@ -2,7 +2,7 @@
 
 from ansi_colours import AnsiColours as Colour
 
-from rummy.ui.view import View
+from rummy.view.round_view import RoundView
 
 
 class Score:
@@ -15,7 +15,7 @@ def get_current_game_scores(self):
     def get_end_of_round_scores(self):
         output = ''
         for p in self.players:
-            output += View.template_end_of_round_scores(p)
+            output += RoundView.end_of_round_scores(p)
         return output
 
     def update_player_scores(self):

rummy/play.py

@@ -15,6 +15,7 @@
 from rummy.ui.menu_action_dialog import MenuActionDialog
 from rummy.ui.user_input import UserInput
 from rummy.ui.view import View
+from rummy.view.round_view import RoundView
 
 
 class Play:
@@ -83,7 +84,7 @@ def confirm_start_new_round():
 
     def end_round(self):
         self.score.update_player_scores()
-        return View.template_this_round_score(
+        return RoundView.this_round_score(
             self.score.get_end_of_round_scores(),
             self.score.get_current_game_scores()
         )

rummy/ui/view.py

@@ -1,12 +1,13 @@
 # coding=utf-8
 
-from time import sleep
-
 from text_template import TextTemplate
 
 from rummy.constants.resource_path import TEMPLATE_PATH
 
 
+# Todo: Refactor -- These look more like controllers the current controller is more like a service.
+
+
 class View:
 
     @staticmethod
@@ -22,85 +23,3 @@ def prepare_template(template, **kwargs):
         complete_template = TEMPLATE_PATH + template
         return TextTemplate.render(complete_template, **kwargs)
 
-    @staticmethod
-    def template_turn_start(player):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/player-turn-start.txt',
-            turn_number=player.round.turn,
-            player_number=player.round.current_player + 1,
-            score=player.hand.get_score(),
-            hand=str(player.hand),
-            discard=player.round.deck.show_discard()
-        )
-
-    @staticmethod
-    def template_player_turn_end(player):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/player-turn-end.txt',
-            hand=str(player.hand),
-            key=player.hand.get_key()
-        )
-
-    @staticmethod
-    def template_ai_thought(ai, action):
-        output = TextTemplate.render(
-            TEMPLATE_PATH + '/ai-thinking.txt', action=action)
-        if not ai.ai_only:
-            sleep(0.8)
-        return output
-
-    @staticmethod
-    def template_ai_turn_start(player):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/turn-start.txt',
-            turn_number=player.round.turn,
-            player_number=player.round.current_player + 1,
-            discard=player.round.deck.show_discard()
-        )
-
-    @staticmethod
-    def template_ai_turn_end(player):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/ai-turn-end.txt',
-            hand=str(player.hand)
-        )
-
-    @staticmethod
-    def template_player_discarded(discard):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/player-discarded.txt',
-            discard=discard
-        )
-
-    @staticmethod
-    def template_ai_discard_data(current_score, scores):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/ai-discard-data.txt',
-            current_score=str(current_score),
-            scores=str(scores),
-            min_score=str(min(scores))
-        )
-
-    @staticmethod
-    def template_ai_hand_data(score):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/ai-hand-data.txt',
-            score=str(score)
-        )
-
-    @staticmethod
-    def template_end_of_round_scores(player):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/hand-score.txt',
-            player=player.get_name(),
-            hand=str(player.hand),
-            score=player.hand.get_score()
-        )
-
-    @staticmethod
-    def template_this_round_score(round_scores, game_scores):
-        return TextTemplate.render(
-            TEMPLATE_PATH + '/round-end.txt',
-            round_scores=round_scores,
-            game_scores=game_scores
-        )

rummy/view/__init__.py

@@ -0,0 +1,56 @@
+from time import sleep
+
+from text_template import TextTemplate
+
+from rummy.constants.resource_path import TEMPLATE_PATH
+from rummy.view.player_view import PlayerView
+
+
+class AiView(PlayerView):
+
+    @staticmethod
+    def thinking(ai, action):
+        output = TextTemplate.render(
+            TEMPLATE_PATH + '/ai-thinking.txt', action=action)
+        if not ai.ai_only:
+            sleep(0.8)
+        return output
+
+    @staticmethod
+    def turn_start(player):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/turn-start.txt',
+            turn_number=player.round.turn,
+            player_number=player.round.current_player + 1,
+            discard=player.round.deck.show_discard()
+        )
+
+    @staticmethod
+    def turn_end(player):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/ai-turn-end.txt',
+            hand=str(player.hand)
+        )
+
+    @staticmethod
+    def discarded(discard):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/player-discarded.txt',
+            discard=discard
+        )
+
+    @staticmethod
+    def discard_data(current_score, scores):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/ai-discard-data.txt',
+            current_score=str(current_score),
+            scores=str(scores),
+            min_score=str(min(scores))
+        )
+
+    @staticmethod
+    def hand_data(score):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/ai-hand-data.txt',
+            score=str(score)
+        )

rummy/view/ai_view.py

@@ -0,0 +1,33 @@
+from text_template import TextTemplate
+
+from rummy.constants.resource_path import TEMPLATE_PATH
+from rummy.view.player_view import PlayerView
+
+
+class HumanView(PlayerView):
+
+    @staticmethod
+    def turn_start(player):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/player-turn-start.txt',
+            turn_number=player.round.turn,
+            player_number=player.round.current_player + 1,
+            score=player.hand.get_score(),
+            hand=str(player.hand),
+            discard=player.round.deck.show_discard()
+        )
+
+    @staticmethod
+    def turn_end(player):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/player-turn-end.txt',
+            hand=str(player.hand),
+            key=player.hand.get_key()
+        )
+
+    @staticmethod
+    def discarded(player):
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/player-discarded.txt',
+            discard=player.round.deck.inspect_discard()
+        )

rummy/view/human_view.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod
+
+from text_template import TextTemplate
+
+from rummy.constants.resource_path import TEMPLATE_PATH
+
+
+class PlayerView:
+
+    @staticmethod
+    @abstractmethod
+    def turn_start(player):
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def turn_end(player):
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def discarded(discard):
+        pass
+
+    @staticmethod
+    def knocked():
+        return TextTemplate.render(
+            TEMPLATE_PATH + '/knocked.txt'
+        )