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 test_add_info_from_clues(self):
clues = Clues(context_fixture)
clues.add_card(Cards.BLAAUWVANDRAET, tom)
clues.add_card(Cards.KANDELAAR, tom)
rumour_cards = [
Cards.BLAAUWVANDRAET, Cards.KANDELAAR, Cards.GASTENVERBLIJF
]
clues.add_rumour(
Rumour(menno, rumour_cards, [(menno, Knowledge.FALSE),
(michiel, Knowledge.TRUE)]))
watson = self.empty_watson
watson.add_info_from_clues(clues)
for card in rumour_cards:
for player in context_fixture.players:
if (card is Cards.KANDELAAR
or card is Cards.BLAAUWVANDRAET) and player is tom:
self.assertEqual(
Knowledge.TRUE,
watson.get_knowledge_table().get(player, card))
elif card is Cards.GASTENVERBLIJF and player is michiel:
self.assertEqual(
Knowledge.TRUE,
watson.get_knowledge_table().get(player, card))
else:
self.assertEqual(
Knowledge.FALSE,
watson.get_knowledge_table().get(player, card))
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
def load_clues(filename: str) -> Clues:
with open(filename, 'r') as file:
config = json.load(file)
players_json = config["players"]
cards_json = config["cards"]
open_cards_json = config["open_cards"]
cards_seen_json = config["cards_seen"]
rumours_json = config["rumours_made"]
check_if_all_categories_present(cards_json)
all_cards = retrieve_cards(cards_json)
players = retrieve_players(players_json)
open_cards = retrieve_open_cards(all_cards, open_cards_json)
used_cards = [c for c in all_cards if c not in open_cards]
cards_seen = retrieve_cards_seen(all_cards, cards_seen_json, players)
rumours = retrieve_rumours(players, rumours_json, used_cards)
clues = Clues(Context(players, used_cards, open_cards))
add_cards_to_clues(cards_seen, clues)
add_rumours_to_clues(rumours, clues)
return clues
def __init__(self, clues: Clues, knowledge_table: KnowledgeTable):
self.clues = clues
self.context = clues.get_context()
self.knowledge_table = knowledge_table
self.available_players_for_card = {}
self.player_hands = {}
self.start_time = time.time()
def setUp(self) -> None:
context = context_fixture
self.empty_solution_finder = SolutionFinder(Clues(context),
KnowledgeTable(context.players, context.cards))
knowledge_table = KnowledgeTable(context.players, context.cards)
tom_cards = [Cards.BLAAUWVANDRAET, Cards.BUBBELBAD, Cards.BIJL, Cards.HALTER]
menno_cards = [Cards.ROODHART, Cards.ZITKAMER, Cards.KNUPPEL, Cards.GASTENVERBLIJF]
michiel_cards = [Cards.DEWIT, Cards.THEATER, Cards.TOUW]
for card in tom_cards:
knowledge_table.set(tom, card, Knowledge.TRUE)
for card in menno_cards:
knowledge_table.set(menno, card, Knowledge.TRUE)
for card in michiel_cards:
knowledge_table.set(michiel, card, Knowledge.TRUE)
self.half_full_solution_finder = SolutionFinder(Clues(context), knowledge_table)
def save_clues_to_file_object(clues: Clues, file_object):
context = clues.context
config = {
"players":
players_of_context_to_json_object(context.players),
"cards":
cards_of_context_to_json_object(context.cards + context.open_cards),
"open_cards":
cards_to_json_object(context.open_cards),
"cards_seen":
cards_seen_to_json_object(clues.cards_seen),
"rumours_made":
rumours_to_json_object(clues.get_rumours())
}
json.dump(config, file_object, indent=2)
def setUp(self) -> None:
clues = Clues(context_fixture)
self.context = clues.get_context()
self.empty_knowledge_table = KnowledgeTable(self.context.players,
self.context.cards)
self.empty_deriver = Deriver(clues, self.empty_knowledge_table)
def add_rumours_to_clues(rumours: List[Rumour], clues: Clues):
for r in rumours:
clues.add_rumour(r)
def add_cards_to_clues(cards_seen: Dict[Player, List[Card]], clues: Clues):
for player, cards in cards_seen.items():
for c in cards:
clues.add_card(c, player)
def setUp(self) -> None:
self.knowledge_table = KnowledgeTable(context_fixture.players,
context_fixture.cards)
self.clues = Clues(context_fixture)
self.empty_brute_forcer = BruteForcer(self.clues, self.knowledge_table)