def __init__(self):
self.codemaker = CodeMaker()
self.codebreaker = MathematicianCodeBreaker()
self.knowledge_manager = KnowledgeManager()
self.knowledge_manager.get_real_world(self.codemaker.code)
self.agent_knowledge = AgentKnowledge()
self.agent_knowledge.update_code_maker_knowledge(self.codemaker.code)
def test_get_real_world():
input_code = [4, 1, 3, 2]
expected_world_assignment = {
'1:green': True,
'2:yellow': True,
'3:red': True,
'4:violet': True
}
km = KnowledgeManager()
km.get_real_world(input_code)
assert km.real_world.assignment == expected_world_assignment
assert km.real_world.name == "w13"
def __get_reduced_knowledge_model():
knowledge = KnowledgeManager()
random.seed(time.time())
worlds_to_eliminate = random.randint(20, 300)
for _ in range(0, worlds_to_eliminate):
world = random.choice(knowledge.model.worlds)
knowledge.model.remove_node_by_name(world.name)
return knowledge
def test_get_first_move():
"""
1. Test if the length of move is correct
2. Test if all the elements of the move belong to the given set
3. Test if all the elements appear only once within the move
"""
available_elements = [1, 2, 3, 4, 5, 6]
knowledge = KnowledgeManager()
codebreaker_player = LogicianCodeBreaker(knowledge)
first_move = codebreaker_player.get_first_move()
assert len(first_move) == 4
for i in range(0, 4):
assert available_elements.count(first_move[i]) != 0
assert first_move.count(first_move[i]) == 1
def run_simulation(self):
for i in range(0, self.number_of_games):
self.knowledge_manager = KnowledgeManager()
self.codemaker = CodeMaker()
# print("Running Game : ", i+1, " : Code : ", self.codemaker.code)
self.codes.append(self.codemaker.code)
self.mathematician_codebreaker = MathematicianCodeBreaker()
self.logician_codebreaker = LogicianCodeBreaker(
self.knowledge_manager)
self.random_codebreaker = RandomCodeBreaker()
self.__play(self.mathematician_codebreaker)
self.__play(self.logician_codebreaker)
self.__play(self.random_codebreaker)
return
def run_simulation(self):
"""
Runs the strategy analyser simulation.
Allows 'n' games to be played, with new instances
of all the players and the knowledge model
for each game.
"""
for i in range(0, self.number_of_games):
self.knowledge_manager = KnowledgeManager()
self.codemaker = CodeMaker()
print("Running Game : ", i + 1, " : Code : ", self.codemaker.code)
self.mathematician_codebreaker = MathematicianCodeBreaker()
self.logician_codebreaker = LogicianCodeBreaker(
self.knowledge_manager)
self.random_codebreaker = RandomCodeBreaker()
self.__play(self.mathematician_codebreaker)
self.__play(self.logician_codebreaker)
self.__play(self.random_codebreaker)
return
class Game:
"""
Provides an interface for the code-maker and the code-breaker
to play the game.
Passes on the code and feedback from code-maker to the code breaker.
Passes on the moves from the code-breaker to the code-maker.
Keeps track of the common knowledge in the game.
Keeps track of the state of the game and decides the winner.
"""
def __init__(self):
self.codemaker = CodeMaker()
self.codebreaker = MathematicianCodeBreaker()
self.knowledge_manager = KnowledgeManager()
self.knowledge_manager.get_real_world(self.codemaker.code)
self.agent_knowledge = AgentKnowledge()
self.agent_knowledge.update_code_maker_knowledge(self.codemaker.code)
self.moves = []
self.feedback = []
self.log = ""
def play(self):
feedback = self.__handle_first_move()
if self.__codebreaker_won(feedback):
return
for i in range(2, NUMBER_OF_CHANCES+1):
next_move = self.codebreaker.get_next_move(feedback)
feedback = self.codemaker.analyze_move(next_move)
self.__update_knwoledge(next_move, feedback)
self.moves.append(next_move)
self.feedback.append(feedback)
print_game_state(i, next_move, feedback,
self)
if self.__codebreaker_won(feedback):
return
self.winner = CODE_MAKER
return
def __handle_first_move(self):
first_move = self.codebreaker.get_first_move()
feedback = self.codemaker.analyze_move(first_move)
self.__update_knwoledge(first_move, feedback)
self.moves.append(first_move)
self.feedback.append(feedback)
print_game_state(1, first_move, feedback,
self)
return feedback
def __update_knwoledge(self, move, feedback):
self.knowledge_manager.handle_move(move, feedback)
self.agent_knowledge.update_move_knowledge(move, feedback)
return
def __codebreaker_won(self, feedback):
for val in feedback:
if val == 0 or val == -1:
return False
self.winner = CODE_BREAKER
return True
class Game:
"""
Provides an interface for the code-maker and the code-breaker
to play the game.
Passes on the code and feedback from code-maker to the code breaker.
Passes on the moves from the code-breaker to the code-maker.
Keeps track of the common knowledge in the game.
Keeps track of the state of the game and decides the winner.
"""
def __init__(self):
self.codemaker = CodeMaker()
self.codebreaker = MathematicianCodeBreaker()
self.knowledge_manager = KnowledgeManager()
self.knowledge_manager.get_real_world(self.codemaker.code)
self.agent_knowledge = AgentKnowledge()
self.agent_knowledge.update_code_maker_knowledge(self.codemaker.code)
def play(self):
"""
Provides interface to conduct the game.
Provides opportunities to the code-breaker to
make moves, passes them to code-maker, gets the feedback
and passes it to the code-breaker, to get the next move.
Also, keeps track of the winner for the game.
"""
feedback = self.__handle_first_move()
if self.__codebreaker_won(feedback):
return
for i in range(2, NUMBER_OF_CHANCES + 1):
next_move = self.codebreaker.get_next_move(feedback)
feedback = self.codemaker.analyze_move(next_move)
self.__update_knwoledge(next_move, feedback)
print_game_state(i, next_move, feedback, self)
if self.__codebreaker_won(feedback):
return
self.winner = CODE_MAKER
return
def __handle_first_move(self):
"""
Handles the first move for the game.
Gets the move from code-breaker, passes it
onto the code-maker, and gets feedback from it.
"""
first_move = self.codebreaker.get_first_move()
feedback = self.codemaker.analyze_move(first_move)
self.__update_knwoledge(first_move, feedback)
print_game_state(1, first_move, feedback, self)
return feedback
def __update_knwoledge(self, move, feedback):
"""
Updates the knowledge model and the agent knowledge
of the game, with the knowledge acquired from this
move and its feedback.
"""
self.knowledge_manager.handle_move(move, feedback)
self.agent_knowledge.update_move_knowledge(move, feedback)
return
def __codebreaker_won(self, feedback):
"""
Checks if the codebreaker has correctly
guessed the secret code, and won the game.
"""
for val in feedback:
if val == 0 or val == -1:
return False
self.winner = CODE_BREAKER
return True
def test_handle_move():
"""
when feedback contains all 1s
that is, all the elements are perfectly guessed
"""
input_move = [2, 3, 5, 6]
input_feedback = [1, 1, 1, 1]
expected_number_of_worlds = 1
expected_number_of_relations_agent1 = 1
expected_number_of_relations_agent2 = 1
expected_world_assignment = {
'1:violet': True,
'2:red': True,
'3:pink': True,
'4:blue': True
}
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2
assert km.model.worlds[0].assignment == expected_world_assignment
"""
when feedbck contains some -1s with 1s
that is, there are some incorrect elements guessed
"""
input_move = [2, 3, 5, 6]
input_feedback = [-1, 1, -1, 1]
expected_number_of_worlds = 2
expected_number_of_relations_agent1 = 2
expected_number_of_relations_agent2 = 4
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2
"""
when feedback has all -1s
that is, all elements are incorrect
"""
input_move = [2, 3, 5, 6]
input_feedback = [-1, -1, -1, -1]
expected_number_of_worlds = 0
expected_number_of_relations_agent1 = 0
expected_number_of_relations_agent2 = 0
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2
"""
when feedback has some 0s with 1s
that is, the position for some elements is
different than what is guessed
"""
input_move = [2, 3, 5, 6]
input_feedback = [1, 0, 0, 1]
expected_number_of_worlds = 7
expected_number_of_relations_agent1 = 7
expected_number_of_relations_agent2 = 49
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2
"""
when feedback has all 0s
that is, the position for all elements is
different than what is guessed
"""
input_move = [2, 3, 5, 6]
input_feedback = [0, 0, 0, 0]
expected_number_of_worlds = 181
expected_number_of_relations_agent1 = 181
expected_number_of_relations_agent2 = 32761
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2
"""
when feedback has 0s with -1s
that is, some elements are incorrect and
some have different positions
"""
input_move = [2, 3, 5, 6]
input_feedback = [0, -1, -1, 0]
expected_number_of_worlds = 14
expected_number_of_relations_agent1 = 14
expected_number_of_relations_agent2 = 196
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2
"""
when feedback has 1s, -1s and 0s
"""
input_move = [2, 3, 5, 6]
input_feedback = [1, 0, 0, -1]
expected_number_of_worlds = 14
expected_number_of_relations_agent1 = 14
expected_number_of_relations_agent2 = 196
km = KnowledgeManager()
km.handle_move(input_move, input_feedback)
assert len(km.model.worlds) == expected_number_of_worlds
assert len(km.model.relations['1']) == expected_number_of_relations_agent1
assert len(km.model.relations['2']) == expected_number_of_relations_agent2