class Watson:
def __init__(self, context: Context):
self.context = context
self.clues = Clues(context)
self.knowledge_table = KnowledgeTable(self.context.players,
self.context.cards)
self.brute_forcer = BruteForcer(self.clues, self.knowledge_table)
self.deriver = Deriver(self.clues, self.knowledge_table)
def add_knowledge(self, player: Player, card: Card, knowledge: Knowledge):
self.clues.add_card(card, player)
self.deriver.derive_from_new_knowledge(player, card, knowledge)
self.brute_force_and_derive_from_findings()
def add_rumour(self, rumour: Rumour) -> None:
self.clues.add_rumour(rumour)
self.deriver.derive_from_new_rumour(rumour)
self.brute_force_and_derive_from_findings()
def brute_force_and_derive_from_findings(self):
for player in self.context.players:
for card in self.context.cards:
if self.knowledge_table.get(player, card) == Knowledge.MAYBE:
knowledge = self.brute_forcer.brute_force_on_card(
player, card)
if knowledge != Knowledge.MAYBE:
self.deriver.derive_from_new_knowledge(
player, card, knowledge)
def add_info_from_clues(self, clues: Clues):
self._add_cards_from_clues(clues)
self._add_rumours_from_clues(clues)
self.brute_force_and_derive_from_findings()
def _add_cards_from_clues(self, clues):
for player, cards in clues.cards_seen.items():
for card in cards:
self.clues.add_card(card, player)
self.deriver.derive_from_new_knowledge(player, card,
Knowledge.TRUE)
def _add_rumours_from_clues(self, clues):
for rumour in clues.get_rumours():
self.clues.add_rumour(rumour)
self.deriver.derive_from_new_rumour(rumour)
def display_state(self) -> str:
formatter = KnowledgeTableFormatter()
return formatter.format_knowledge_table(self.knowledge_table)
def get_knowledge_table(self) -> KnowledgeTable:
return self.knowledge_table
def get_context(self) -> Context:
return self.context
def get_clues(self) -> Clues:
return self.clues
class TestKnowledgeTable(TestCase):
def setUp(self):
self.context = context_fixture
self.some_player = tom
self.knowledge_table = KnowledgeTable(self.context.players, self.context.cards)
def test_new_knowledge_table(self):
for player in self.context.players:
for card in self.context.cards:
self.assertEqual(self.knowledge_table.get(player, card), Knowledge.MAYBE)
def test_set(self):
self.knowledge_table.set(self.some_player, Cards.KNUPPEL, Knowledge.TRUE)
self.assertEqual(
self.knowledge_table.get(self.some_player, Cards.KNUPPEL),
Knowledge.TRUE
)
def test_invalid_set(self):
self.knowledge_table.set(self.some_player, Cards.KNUPPEL, Knowledge.TRUE)
with self.assertRaises(ValueError):
self.knowledge_table.set(self.some_player, Cards.KNUPPEL, Knowledge.FALSE)
def test_set_forcefully(self):
self.knowledge_table.set(self.some_player, Cards.KNUPPEL, Knowledge.TRUE)
self.knowledge_table.set_forcefully(self.some_player, Cards.KNUPPEL, Knowledge.FALSE)
def test_current_player_hands(self):
knowledge_table = self.knowledge_table
for player in self.context.players:
knowledge_table.set(player, Cards.KNUPPEL, Knowledge.FALSE)
knowledge_table.set(self.some_player, Cards.TOUW, Knowledge.TRUE)
player_hands, murderer_cards, free_cards = knowledge_table.current_player_hands()
self.assertIn(Cards.KNUPPEL, murderer_cards)
self.assertIn(Cards.TOUW, player_hands[self.some_player])
self.assertIn(Cards.PIMPEL, free_cards)
def format_category_table(self, category: Category, knowledge_table: KnowledgeTable):
players = knowledge_table.players
category_cards = [card for card in knowledge_table.cards if card.category == category]
category_cards.sort(key=lambda card: card.name)
table = TableFormatter(len(category_cards) + 1, len(players) + 1)
# Set the player names in the table
for p in range(len(players)):
table.set(0, p + 1, players[p].name)
# Set the card names in the table
for c in range(len(category_cards)):
table.set(c + 1, 0, category_cards[c].name)
# fill the table
for card_i in range(len(category_cards)):
for player_i in range(len(players)):
card = category_cards[card_i]
player = players[player_i]
s = knowledge_to_str(knowledge_table.get(player, card))
table.set(card_i + 1, player_i + 1, s)
return table.to_string()