Merge branch 'view-separation'

Author: OrderAndCh4oS

rummy/controller/__init__.py

@@ -0,0 +1,81 @@
+from random import choice
+
+from rummy.player.player import Player
+from rummy.ui.view import View
+
+
+class AiController:
+
+    @staticmethod
+    def show_start_turn(player: Player):
+        output = ''
+        if player.ai_only:
+            output += View.template_turn_start(player)
+        else:
+            output += View.template_ai_turn_start(player)
+        output += View.template_ai_thought(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')
+        View.render(output)
+
+    @staticmethod
+    def show_knocked(player):
+        if player.has_someone_knocked():
+            View.render(View.prepare_template('/knocked.txt'))
+
+    @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())
+        View.render(output)
+
+    @classmethod
+    def draw_card(cls, player):
+        output = ''
+        if player.round.deck.has_discard():
+            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 += cls._choose_pickup(player, current_score, scores)
+        else:
+            player.take_from_deck()
+            output += View.template_ai_thought(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')
+        else:
+            player.take_from_deck()
+            output += View.template_ai_thought(player, 'Drawing from deck')
+        return output
+
+    @classmethod
+    def discard_or_knock(cls, player):
+        scores = player.melds.find_discard_scores(player.hand.get_hand())
+        score = min(scores)
+        if score <= 10 and not player.round.knocked:
+            player.round.knocked = True
+        discard = cls._choose_discard(player, score, scores)
+        player.round.deck.discard_card(discard)
+
+    @staticmethod
+    def _choose_discard(player, score, scores):
+        if scores.count(score) > 1:
+            choices = [(i, x) for (i, x) in enumerate(scores) if (x == score)]
+            discard = choice(choices)[0]
+        else:
+            discard = scores.index(score)
+        return player.hand.discard_card(discard)

rummy/controller/ai_controller.py

@@ -0,0 +1,64 @@
+from rummy.player.human import Human
+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
+
+
+class HumanController:
+
+    @staticmethod
+    def show_start_turn(player: Player):
+        if isinstance(player, Human):
+            View.render(View.template_turn_start(player))
+
+    @staticmethod
+    def show_end_turn(player: Player):
+        if isinstance(player, Human):
+            View.render(View.template_player_turn_end(player))
+
+    @staticmethod
+    def show_knocked(player):
+        if player.has_someone_knocked():
+            View.render(View.prepare_template('/knocked.txt'))
+
+    @staticmethod
+    def show_discard(player: Player):
+        if isinstance(player, Human):
+            View.render(View.template_player_discarded(player.round.deck.inspect_discard()))
+
+    @classmethod
+    def draw_card(cls, player):
+        if player.round.deck.has_discard():
+            View.render(cls._choose_pick_up(player))
+        else:
+            player.take_from_deck()
+            View.render('Drew from deck')
+
+    @staticmethod
+    def _choose_pick_up(player):
+        user_input = UserInput.create_input(PlayerActionDialog.pick_up_or_draw())
+        if user_input == 'p':
+            player.take_from_discard()
+            return 'Drawing from discard'
+        else:
+            player.take_from_deck()
+            return 'Drawing from deck'
+
+    @classmethod
+    def discard_or_knock(cls, player):
+        player.discard(cls._choose_discard(player))
+
+    @staticmethod
+    def _choose_discard(player):
+        user_input = ''
+        scores = player.melds.find_discard_scores(player.hand.get_hand())
+        while user_input not in [str(i) for i in range(1, 9)]:
+            if min(scores) <= 10 and not player.round.show_knocked:
+                user_input = UserInput.create_input(PlayerActionDialog.choose_discard_or_knock())
+                if user_input == "k":
+                    player.knock()
+                    continue
+            else:
+                user_input = UserInput.create_input(PlayerActionDialog.choose_discard())
+        return user_input

rummy/controller/human_controller.py

@@ -0,0 +1,47 @@
+from abc import abstractmethod, ABCMeta
+
+from rummy.player.player import Player
+from rummy.ui.view import View
+
+
+class PlayerController(metaclass=ABCMeta):
+
+    @staticmethod
+    @abstractmethod
+    def show_start_turn(player: Player):
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def show_end_turn(player: Player):
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def show_discard(player: Player):
+        pass
+
+    @classmethod
+    @abstractmethod
+    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():
+            View.render(View.prepare_template('/knocked.txt'))

rummy/controller/player_controller.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+from rummy.player.ai import AI
+from rummy.player.human import Human
+from rummy.ui.menu_action_dialog import MenuActionDialog
+from rummy.ui.user_input import UserInput
+
+
+class Players:
+    def __init__(self):
+        self.players = []
+        self.number_of_players = -1
+        self.number_of_opponents = -1
+
+    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) + 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) + 1, ai_only))
+
+    def is_ai_only(self):
+        return True if self.number_of_players is 0 else False
+
+    def get_players(self):
+        return self.players

rummy/game/players.py

@@ -2,7 +2,7 @@
 
 from ansi_colours import AnsiColours as Colour
 
-from ui.view import View
+from rummy.ui.view import View
 
 
 class Score:
@@ -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 = []