class LifeGame(object):
"""
Game of life.
This class controls a game cycle triggered by timer.
Attributes:
game_map: GameMap instance.
"""
def __init__(self, map_rows=10, map_cols=10, life_init_possibility=0.5):
self.game_map = GameMap(map_rows, map_cols)
self.game_map.reset(life_init_possibility)
def print_map(self):
"""Clear the console, then print the map"""
os.system('cls' if os.name == 'nt' else 'clear')
self.game_map.print_map()
def game_cycle(self):
nc_map = self.game_map.get_neighbor_count_map()
for row in range(self.game_map.rows):
for col in range(self.game_map.cols):
nc = nc_map[row][col]
if nc < 2 or nc > 3:
self.game_map.set(row, col, 0)
elif nc == 3:
self.game_map.set(row, col, 1)
self.print_map()
class LifeGame(object):
"""
Game of life.
This class controls a game cycle triggered by timer.
Attributes:
game_map: GameMap instance.
"""
def __init__(self, map_rows=10, map_cols=10, life_init_possibility=0.5):
self.game_map = GameMap(map_rows, map_cols)
self.game_map.reset(life_init_possibility)
def print_map(self):
"""Clear the console, then print the map"""
os.system('cls' if os.name == 'nt' else 'clear')
self.game_map.print_map()
def game_cycle(self):
nc_map = self.game_map.get_neighbor_count_map()
for row in range(self.game_map.rows):
for col in range(self.game_map.cols):
nc = nc_map[row][col]
if nc < 2 or nc > 3:
self.game_map.set(row, col, 0)
elif nc == 3:
self.game_map.set(row, col, 1)
self.print_map()
class TestGameMap(TestCase):
def setUp(self):
self.gmap = GameMap(4, 3)
def test_rows(self):
self.assertEqual(4, self.gmap.rows, "invalid rows")
def test_cols(self):
self.assertEqual(3, self.gmap.cols, "invalid cols")
@patch('random.random',
new=Mock(side_effect=chain(cycle([0.3, 0.6, 0.9]))))
def test_reset(self):
self.gmap.reset()
for i in range(4):
self.assertEqual(1, self.gmap.get(i, 0))
for j in range(1, 3):
self.assertEqual(0, self.gmap.get(i, j))
def test_get_set(self):
self.assertEqual(0, self.gmap.get(0, 0), "invalid value")
self.gmap.set(0, 0, 1)
self.assertEqual(1, self.gmap.get(0, 0), "invalid value")
def test_get_neighbor_count(self):
expected_value = [[8] * 3] * 4
self.gmap.cells = [[1] * 3] * 4
for i in range(4):
for j in range(3):
self.assertEqual(expected_value[i][j],
self.gmap.get_neighbor_count(i, j),
'%d,%d' % (i, j))
@patch('game_map.GameMap.get_neighbor_count', new=Mock(return_value=8))
def test_get_neighbor_count_map(self):
expected_value = [[8] * 3] * 4
self.assertEqual(expected_value, self.gmap.get_neighbor_count_map())
def test_set_map(self):
self.assertRaises(TypeError, self.gmap.set_map, {1, 2, 3})
self.assertRaises(AssertionError, self.gmap.set_map, [[1] * 3] * 3)
self.assertRaises(TypeError, self.gmap.set_map, [['1'] * 3] * 4)
self.assertRaises(AssertionError, self.gmap.set_map, [[10] * 3] * 4)
expected_value = [[1] * 3] * 4
self.gmap.set_map(expected_value)
self.assertEqual(expected_value, self.gmap.cells)
def test_print_map(self):
self.gmap.cells = [[1, 0, 1], [0, 1, 1], [1, 1, 1], [0, 0, 0]]
with patch('builtins.print') as mock:
self.gmap.print_map()
mock.assert_has_calls(
[call('1 0 1'),
call('0 1 1'),
call('1 1 1'),
call('0 0 0')])
class LifeGame(object):
def __init__(self, map_rows=10, map_cols=10, life_init_possibility=0.5):
self.game_map = GameMap(map_rows, map_cols)
self.game_map.reset(life_init_possibility)
def print_map(self):
os.system('cls' if os.name == 'nt' else 'clear')
self.game_map.print_map()
def game_cycle(self):
nc_map = self.game_map.get_neighbor_count_map()
for row in range(self.game_map.rows):
for col in range(self.game_map.cols):
nc = nc_map[row][col]
if nc < 2 or nc > 3:
self.game_map.set(row, col, 0)
elif nc == 3:
self.game_map.set(row, col, 1)
self.print_map()
class TestGameMap(TestCase):
def setUp(self):
self.game_map = GameMap(4, 3)
def test_rows(self):
self.assertEqual(4, self.game_map.rows, "Should get correct rows")
def test_cols(self):
self.assertEqual(3, self.game_map.cols, "Should get correct cols")
@patch('random.random',
new=Mock(side_effect=chain(cycle([0.3, 0.6, 0.9]))))
def test_reset(self):
self.game_map.reset()
for i in range(0, 4):
self.assertEqual(1, self.game_map.get(i, 0))
for j in range(1, 3):
self.assertEqual(0, self.game_map.get(i, j))
def test_get_set(self):
self.assertEqual(0, self.game_map.get(0, 0), "Cells init to zero")
self.game_map.set(0, 0, 1)
self.assertEqual(1, self.game_map.get(0, 0),
"Should get value set by set")
def test_get_neighbor_count(self):
expected_value = [[8] * 3] * 4
self.game_map.cells = [[1] * 3] * 4
for i in range(0, 4):
for j in range(0, 3):
x = self.game_map.get_neighbor_count(i, j)
self.assertEqual(expected_value[i][j], x, '(%d,%d)' % (i, j))
@patch('game_map.GameMap.get_neighbor_count', new=Mock(return_value=8))
def test_get_neighbor_count_map(self):
expected_value = [[8] * 3] * 4
self.assertEqual(expected_value,
self.game_map.get_neighbor_count_map())
def test_set_map(self):
self.assertRaises(TypeError, self.game_map.set_map, {(0, 0): 1})
self.assertRaises(AssertionError, self.game_map.set_map, [[1] * 3] * 3)
self.assertRaises(TypeError, self.game_map.set_map, [['1'] * 3] * 4)
self.assertRaises(AssertionError, self.game_map.set_map, [[2] * 3] * 4)
self.game_map.set_map([[1] * 3] * 4)
self.assertEqual([[1] * 3] * 4, self.game_map.cells)
def test_print_map(self):
self.game_map.cells = [[0, 1, 1], [0, 0, 1], [1, 1, 1], [0, 0, 0]]
with patch('builtins.print') as mock:
self.game_map.print_map()
mock.assert_has_calls([
call('0 1 1'),
call('0 0 1'),
call('1 1 1'),
call('0 0 0'),
])
self.game_map.cells = [[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]]
with patch('builtins.print') as mock:
self.game_map.print_map()
mock.assert_has_calls([
call('1 1 1'),
call('1 1 1'),
call('1 1 1'),
call('1 1 1'),
])
class Game:
TREASURE_TO_WIN = 3
def __init__(self):
self.game_map = GameMap(10)
self.player = Player("Halk", 3)
self.enemy = Enemy()
@decorators.info_decorator
@decorators.debug_decorator
def start(self):
"""
Start Game.
:returns: None.
:rtype: None.
"""
while True:
debug_status = "Off" if decorators.is_debug else "On"
info_status = "Off" if decorators.is_info else "On"
string = input(
f"Start Game(1)/Load Game(2)/Exit Game(3)/Turn { debug_status } Debug(4)/Turn { info_status } Info(5):"
)
if string == '1':
self.player = Player("Halk", 3)
self.game_map = GameMap(10)
custom_log.logger.info("Game Started!")
self.play()
elif string == '2':
game_map = Serializer.load_map()
if game_map == "":
custom_log.logger.error("Failed to Load Game")
continue
custom_log.logger.info("Game Started!")
self.play()
elif string == '3':
break
elif string == '4':
decorators.is_debug = not decorators.is_debug
elif string == '5':
decorators.is_info = not decorators.is_info
@decorators.info_decorator
@decorators.debug_decorator
def play(self):
"""
Function where whole game is happening.
:returns: None.
:rtype: None.
"""
stop_flag = Event()
enemy_thread = EnemyThread(self.enemy, self.player, self.game_map,
stop_flag)
enemy_thread.start()
custom_log.logger.info(
"---------------------------------------------------")
while True:
valid_direction = self.game_map.get_player_valid_directions()
custom_log.logger.info(
"Input 'save'/'load' to save/load the game.")
custom_log.logger.info(f"Valid directions - {valid_direction}")
self.player.check_status(self.game_map)
self.player.print_status()
self.game_map.print_map()
direction = DungeonInput.get_direction()
if direction == "save":
Serializer.save_map(self.game_map)
continue
elif direction == "load":
new_game_map = Serializer.load_map()
if new_game_map == "":
custom_log.logger.error("Failed to Load Game")
continue
self.game_map = new_game_map
continue
if direction not in valid_direction:
custom_log.logger.warning("Can't move there!")
continue
self.player.move(self.game_map, direction)
custom_log.logger.info(
"---------------------------------------------------")
if self.player.hp <= 0:
self.end_game()
break
elif self.player.bag == Game.TREASURE_TO_WIN:
self.win_game()
break
stop_flag.set()
@decorators.info_decorator
@decorators.debug_decorator
def end_game(self):
"""
Ends game prints map.
:returns: None.
:rtype: None.
"""
custom_log.logger.info("You Lost!")
self.game_map.print_map()
@decorators.info_decorator
@decorators.debug_decorator
def win_game(self):
"""
Wins game prints map.
:returns: None.
:rtype: None.
"""
custom_log.logger.info("You Won!")
self.game_map.print_map()
class TestGameMap(TestCase):
def setUp(self):
self.game_map = GameMap(4, 3)
def test_init(self):
self.assertRaises(TypeError, GameMap, ('a', 3))
self.assertRaises(TypeError, GameMap, (4, 'b'))
def test_rows(self):
self.assertEqual(4, self.game_map.rows, "Should get correct rows")
def test_cols(self):
self.assertEqual(3, self.game_map.cols, "Should get correct rows")
@mock.patch('random.random',
new=mock.Mock(side_effect=chain(cycle([0.3, 0.6, 0.9]))))
def test_reset(self):
self.game_map.reset()
for i in range(0, 4):
self.assertEqual(1, self.game_map.get(i, 0))
for j in range(1, 3):
self.assertEqual(0, self.game_map.get(i, j))
self.assertRaises(TypeError, self.game_map.reset, possibility='ab')
def test_get_set(self):
self.assertEqual(0, self.game_map.get(0, 0), "Cells init to 0")
self.game_map.set(0, 0, 1)
self.assertEqual(1, self.game_map.get(0, 0),
"Should get value set by set")
self.assertRaises(TypeError, self.game_map.get, ("d3d3f", 0))
self.assertRaises(TypeError, self.game_map.get, (0, 'b'))
self.assertRaises(TypeError, self.game_map.set, ('a', 0, 1))
self.assertRaises(TypeError, self.game_map.set, (0, 'b', 1))
self.assertRaises(TypeError, self.game_map.set, (0, 0, 'c'))
def test_get_neighbor_count(self):
expected_value = [[8] * 3] * 4
self.game_map.cells = [[1] * 3] * 4
for i in range(0, 4):
for j in range(0, 3):
self.assertEqual(expected_value[i][j],
self.game_map.get_neighbor_count(i, j),
'(%d %d)' % (i, j))
self.assertRaises(TypeError, self.game_map.get_neighbor_count,
('a', 0))
self.assertRaises(TypeError, self.game_map.get_neighbor_count,
(0, 'b'))
@mock.patch('game_map.GameMap.get_neighbor_count',
new=mock.Mock(return_value=8))
# game_map.GameMap.get_neighbor_count
def test_get_neighbor_count_map(self):
expected_value = [[8] * 3] * 4
self.assertEqual(expected_value,
self.game_map.get_neighbor_count_map())
def test_set_map(self):
self.assertRaises(TypeError, self.game_map.set_map, {(0, 0): 1})
self.assertRaises(AssertionError, self.game_map.set_map, [[1] * 3] * 3)
self.assertRaises(TypeError, self.game_map.set_map, [['1'] * 3] * 4)
self.assertRaises(AssertionError, self.game_map.set_map, [[2] * 3] * 4)
self.game_map.set_map([[1] * 3] * 4)
self.assertEqual([[1] * 3] * 4, self.game_map.cells)
def test_print_map(self):
self.game_map.cells = [[0, 1, 1], [0, 0, 1], [1, 1, 1], [0, 0, 0]]
with mock.patch('builtins.print') as mock1:
self.game_map.print_map()
mock1.assert_has_calls([
mock.call('0 1 1'),
mock.call('0 0 1'),
mock.call('1 1 1'),
mock.call('0 0 0'),
])
class Game:
"""Defines a game object. Is the acctual game populated with it's map component objects."""
def __init__(self, name, text, robot_point = None):
"""
"""
self._name = name
self._game_map = GameMap(text, robot_point)
self._status = globals_.Status.NEW
self._visible_map = None
def start(self):
"""
Method that starts a game, loading the robot if needed.
It leaves the game ready to be played.
"""
self._game_map.load_robot()
if self._visible_map is None:
self._visible_map = GameMap(robot_point = self._game_map.get_robot_point())
self._visible_map.append(self._game_map.get_new_room(self._visible_map))
os.system("setterm -cursor off")
self._play()
os.system("setterm -cursor on")
def get_name(self):
"""
"""
return self._name
def get_status(self):
"""
"""
return self._status
def get_game_map(self):
"""
"""
return self._game_map
def print_map(self, visible_only = True):
"""
Cleans terminal and prints map
"""
os.system("clear")
# os.system("cls") # windows
if visible_only:
self._visible_map.print_map()
else:
self._game_map.print_map()
#### private functions ###
def _on_key_press(self):
"""
Method that allows to the input on the key stroke without sowing in the terminal
Reference:
- http://code.activestate.com/recipes/134892-getch-like-unbuffered-character-reading-from-stdin/
"""
stdin_file_descriptor = sys.stdin.fileno()
old_settings = termios.tcgetattr(stdin_file_descriptor)
try:
tty.setraw(stdin_file_descriptor)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(stdin_file_descriptor, termios.TCSADRAIN, old_settings)
return ch
def _play(self):
"""
Game loop.
"""
self._status = globals_.Status.IN_PLAY
known_door_points = list()
while True:
self.print_map()
self._print_keys()
move = self._on_key_press()
# move = raw_input() # windows
while not self._game_map.move_is_valid(move):
move = self._on_key_press()
# move = raw_input() # windows
if move == globals_.KEYS['QUIT']:
print 'quit'
break
self._game_map.move_robot(move)
if self._game_map.robot_at_door():
current_point = self._game_map.get_robot_point()
current_point = Point(current_point.get_x(),current_point.get_y())
if current_point not in known_door_points:
self._visible_map.append(self._game_map.get_new_room(self._visible_map, move))
known_door_points.append(current_point)
if self._game_map.is_end_of_game():
self.print_map()
self._status = globals_.Status.OVER
print "---- YOU WIN!! ----"
break
def _print_keys(self):
"""
Prints the keys to be used to play
"""
keys = ""
for name, k in globals_.KEYS.items():
if name != 'QUIT':
keys = "{}\n{}\t-\t[{}]".format(keys, name, k)
keys = "{}\n{}\t-\t[{}]".format(keys, 'QUIT', globals_.KEYS['QUIT'])
print keys
def __repr__(self):
"""
"""
return "<Game: name {},\ntext: \n{}>".format(self._name, str(self))
def __str__(self):
"""
Tranforms the _game_map into text
"""
game_text = ""
robot_point = self._robot.get_point()
row = 0
for obj in self._game_map:
if robot_point is not None and obj.get_point() == robot_point:
obj = self._robot
if obj.get_point().get_y() == row + 1:
game_text = "{}\n".format(game_text)
row += 1
game_text = "{}{}".format(game_text, obj.get_symbol())
return game_text