def test_winner(game_instance: game.Game) -> None:
"""
Test the final winner.
"""
# Round 1
with mock.patch("random.choice", lambda seq: "Paper"):
# Reload game module
reload(game)
# Instantiate a new player and game
human = player.Player("Madalin")
new_game = game.Game(human)
new_game.player.choice = "Rock"
computer_choice = new_game.computer_choice
result = new_game.winner()
assert result == "Computer won!"
reload(game)
# Round 2
with mock.patch("random.choice", lambda seq: "Human"):
# Reload game module
reload(game)
# Instantiate a new player and game
human = player.Player("Madalin")
new_game = game.Game(human)
new_game.player.choice = "Human"
computer_choice = new_game.computer_choice
result = new_game.winner()
assert result == "Nobody won. It is a draw!"
reload(game)
# Round 3
with mock.patch("random.choice", lambda seq: "Tree"):
# Reload game module
reload(game)
# Instantiate a new player and game
human = player.Player("Madalin")
new_game = game.Game(human)
new_game.player.choice = "Human"
computer_choice = new_game.computer_choice
result = new_game.winner()
assert result == "Madalin won!"
# Final Score
assert new_game.player.score > new_game.computer_score
reload(game)
def setUp(self):
self.g1 = game.Game(
['Unicorn', 'Consultant', 'Ada Lovelace', 'Grace Hopper'], [
4, 52, 17, 20, 35, 42, 13, 37, 5, 9, 29, 28, 39, 27, 30, 24,
11, 50, 51, 38
])
self.g2 = game.Game(
['Unicorn', 'Consultant', 'Ada Lovelace', 'Grace Hopper'], [
4, 52, 17, 20, 35, 42, 13, 37, 5, 9, 29, 28, 39, 27, 30, 24,
11, 50, 51, 38
])
self.g3 = game.Game(
['Steve Jobs', 'Steve Balmer', 'Bill Gates'],
[4, 10, 17, 20, 35, 52, 51, 50, 49, 47, 22, 13, 37, 5, 9])
def test_fruit_op(self):
game = gm.Game()
for _ in range(625):
ret = game.add_fruit()
self.assertEqual(ret, "Fruit added!")
ret = game.add_fruit()
self.assertEqual(ret, "Impossible to add fruit. Field is full!")
ret = game.rm_fruit((0, 0))
self.assertEqual(ret, "Fruit (0, 0) removed!")
ret = game.rm_fruit((0, 0))
self.assertEqual(ret, "Fruit (0, 0) does not exist!")
ret = game.add_fruit()
self.assertEqual(ret, "Fruit added!")
ret = game.add_fruit()
self.assertEqual(ret, "Impossible to add fruit. Field is full!")
for pos in gm.POSITIONS:
ret = game.rm_fruit(pos)
self.assertEqual(ret, f"Fruit {pos} removed!")
ret = game.rm_fruit((0, 0))
self.assertEqual(ret, "Fruit (0, 0) does not exist!")
del game
def test_collision(self):
game = gm.Game()
ret = game.add_fruit()
self.assertEqual(ret, "Fruit added!")
ret = game.add_player(1)
self.assertEqual(ret, "Player 1 added!")
x, y = list(game.state["fruits"].keys())[0]
game.state["players"][1] = {"x": x, "y": y, "p": 0}
player_id = 1
player = game.state["players"][player_id]
pos = player["x"], player["y"]
ret = game.check_collision(player_id)
self.assertEqual(ret,
f"Player {player_id} collected a fruit at {pos}!")
player_id = 1
player = game.state["players"][player_id]
pos = player["x"], player["y"]
ret = game.check_collision(player_id)
self.assertEqual(ret, f"There's no fruit at {pos}!")
del game
def replay(self):
"""Odtworzenie powtórki ostatniej gry"""
self.game = game.Game(0)
self.setCentralWidget(self.game)
self.resize(const.BOARD_WIDTH * const.TILE_WIDTH, const.BOARD_HEIGHT * const.TILE_HEIGHT)
self.center()
def __init_game(self, music_on, line_wait):
self.__game = game.Game(music_on, line_wait)
self.__where_to_go = {
commands.C_NORTH: self.__game.go_north,
commands.C_SOUTH: self.__game.go_south,
commands.C_WEST: self.__game.go_west,
commands.C_EAST: self.__game.go_east
}
def it_should_handle_too_many_cards(self):
with self.assertRaises(Exception) as context:
game.Game(
["a", "b"],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
self.assertTrue(
"There were too many cards for the amount of players" in str(
context.exception))
def test_computer_choice(game_instance: game.Game) -> None:
"""
Test computer choice.
"""
with mock.patch("random.choice", lambda seq: seq[0]):
reload(game)
human = player.Player("Madalin")
new_game = game.Game(human)
assert new_game.computer_choice == "Gun"
reload(game)
def game_instance() -> game.Game:
"""
Game setup
"""
# Define player
human_player = player.Player("Madalin Popa")
# Create a game instance
game_instance = game.Game(human_player)
return game_instance
def it_should_handle_incorrect_values_for_players(self):
with self.assertRaises(Exception) as context:
game.Game(0, [])
self.assertTrue(
"You need to specify the players as an array of players" in
str(context.exception))
with self.assertRaises(Exception) as context:
game.Game(None, [])
self.assertTrue(
"You need to specify the players as an array of players" in
str(context.exception))
with self.assertRaises(Exception) as context:
game.Game("two", [])
self.assertTrue(
"You need to specify the players as an array of players" in
str(context.exception))
with self.assertRaises(Exception) as context:
game.Game([], [])
self.assertTrue(
"You need to specify the players as an array of players" in
str(context.exception))
def __init__(self):
"""Domyślne ustawienia klasy"""
super().__init__()
self.centralWidget = QStackedWidget()
self.setCentralWidget(self.centralWidget)
self.mainMenuWidget = MainMenu()
self.game = game.Game(1)
self.menu()
self.setWindowTitle('Bomberman')
self.setWindowIcon(QIcon('../res/images/icon.png'))
self.show()
def main():
# Pygame window setup
pygame.init()
pygame.display.set_caption('Pytanks')
game_system = game.Game()
default_player = player.Player("Player 1")
default_player.set_colour((65, 105, 225))
test_ai = player.Player("AI - Sentry")
test_ai.set_colour((255, 0, 0))
game_system.add_player(default_player)
game_system.add_player(test_ai)
game_system.load_map('default.json')
game_system.assign_tanks()
game_system.start()
def _state(self):
""" main code for loop """
if self.state == 1:
# main menu
mouse_events = self.main_menu.display()
# events:
# "play" - transition to game setup state
# "options" - transition to options state
for event in mouse_events:
if event == "play":
log.info("Transitioning to Game Setup")
self.state = 3
elif event == "options":
log.info("Transitioning to Options")
self.state = 2
elif self.state == 2:
# options
mouse_events = self.options_menu.display()
# events: - (there are currently no events)
for event in mouse_events:
pass
elif self.state == 3:
# game setup
mouse_events = self.game_setup_options.display()
# events: - (there are currently no events)
for event in mouse_events:
if event == "play":
log.info("Starting Game!")
# initialise game
self.game = game.Game(self.graphics)
self.resolution_dependants.append(self.game)
# transition to game state
self.state = 4
elif self.state == 4:
# game running
self.game.update(self.events)
def main():
"""
Main function
"""
# Instantiate server
with SimpleXMLRPCServer((IP, PORT)) as server:
# Instantiate game
game = gm.Game()
# Register game instance allowing access to methods
server.register_instance(GameService(game), allow_dotted_names=True)
print(f'Serving XML-RPC on {IP} port {PORT}')
# Start game
game.start()
try:
# Serve
server.serve_forever()
except KeyboardInterrupt:
# Stop game
game.stop()
print("\nKeyboard interrupt received, exiting.")
sys.exit(0)
import sys
from src import game
game = game.Game(True, 0.05)
while True:
game.new_turn()
instruction = sys.stdin.readline().strip().lower()
game.interpret(instruction)
def it_should_handle_too_few_cards(self):
with self.assertRaises(Exception) as context:
game.Game(["a", "b"], [1, 2, 3])
self.assertTrue("There was not enough cards for all players" in
str(context.exception))
def it_should_handle_no_cards(self):
with self.assertRaises(Exception) as context:
game.Game(["a", "b"], [])
self.assertTrue("You need to specify a list of cards" in str(
context.exception))
from src import game G = game.Game() G.play()
def it_should_not_allow_multiple_copies_of_the_same_card(self):
with self.assertRaises(Exception) as context:
game.Game(["a", "b"], [1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
self.assertTrue("The same card can't be dealt more than once" in
str(context.exception))
def main(args):
# TODO: Do any setup stuff, like loading things or logging in.
main_game = game.Game()
m = modes.MainMenu()
main_game.start_mode(m)
main_game.mainloop()
def mainloop():
cardUID = 0
deck = []
love1card = Love1Card.Love1Card()
for i in range(7):
deck.append((love1card,cardUID))
cardUID += 1
colette = Card.Card()
for i in range(3):
deck.append((colette,cardUID))
cardUID += 1
shuffle(deck)
print "Game START"
print deck"""
game = game.Game()
players = player.Player(game)
def mainloop():
game.setup_game(None, players)
while game.running:
game.update()
mainloop()
def test_player_op(self):
game = gm.Game()
ret = game.add_player(1)
self.assertEqual(ret, "Player 1 added!")
# print(ret, game.state["players"])
ret = game.add_player(1)
self.assertEqual(ret, "Player 1 already exists!")
# print(ret, game.state["players"])
ret = game.add_player(2)
self.assertEqual(ret, "Player 2 added!")
# print(ret, game.state["players"])
ret = game.rm_player(2)
self.assertEqual(ret, "Player 2 removed!")
# print(ret, game.state["players"])
ret = game.rm_player(2)
self.assertEqual(ret, "Player 2 does not exist!")
# print(ret, game.state["players"])
ret = game.move_player("UP", 1)
self.assertEqual(ret, "Player 1 moved UP!")
# print(ret, game.state["players"])
ret = game.move_player("DOWN", 1)
self.assertEqual(ret, "Player 1 moved DOWN!")
# print(ret, game.state["players"])
ret = game.move_player("LEFT", 1)
self.assertEqual(ret, "Player 1 moved LEFT!")
# print(ret, game.state["players"])
ret = game.move_player("RIGHT", 1)
self.assertEqual(ret, "Player 1 moved RIGHT!")
# print(ret, game.state["players"])
ret = game.move_player("UPPER", 1)
self.assertEqual(ret, "Invalid move!")
# print(ret, game.state["players"])
ret = game.move_player("UP", 2)
self.assertEqual(ret, "Invalid move!")
# print(ret, game.state["players"])
game.state["players"][1] = {"x": 0, "y": 0, "p": 0}
ret = game.move_player("UP", 1)
self.assertEqual(ret, "Player 1 moved UP!")
# print(ret, game.state["players"])
ret = game.move_player("LEFT", 1)
self.assertEqual(ret, "Player 1 moved LEFT!")
# print(ret, game.state["players"])
ret = game.move_player("DOWN", 1)
self.assertEqual(ret, "Player 1 moved DOWN!")
# print(ret, game.state["players"])
ret = game.move_player("RIGHT", 1)
self.assertEqual(ret, "Player 1 moved RIGHT!")
# print(ret, game.state["players"])
del game
from src import game
if __name__ == '__main__':
game.Game().run()
def setUp(self):
self.g = game.Game()
def main():
pygame.init()
fps_clock = pygame.time.Clock()
fps = 23.8
window = pygame.display.set_mode((640, 480), pygame.DOUBLEBUF)
mode = "menu"
menu = m.Menu('config/menu.conf', 'config/user.conf',
'config/default.conf', MIXER)
while (mode):
while (mode == "menu"):
if menu.resolution != window.get_size():
window = pygame.display.set_mode(menu.resolution,
pygame.DOUBLEBUF)
m.draw_menu(menu, window)
pygame.display.flip()
fps_clock.tick(fps)
mode = menu.menu_navigation()
if mode == "game":
try:
print "loading map: {0}".format(menu.config["map"])
game = g.Game(menu.config,
'assets/maps/{0}.npy'.format(menu.config["map"]),
menu.setup["font"], menu.setup["fontsize"], fps)
pygame.event.set_grab(True)
pygame.mouse.set_visible(False)
pygame.mouse.get_rel()
except IOError:
print "no such map: {0}; using Legacy".format(
menu.config["map"])
game = g.Game(menu.config, 'assets/maps/legacy.npy',
menu.setup["font"], menu.setup["fontsize"], fps)
pygame.event.set_grab(True)
pygame.mouse.set_visible(False)
pygame.mouse.get_rel()
while (mode == "game"):
mode = game.do_step(window)
pygame.display.flip()
fps_clock.tick(fps)
while (mode == "hiscore"):
print "high-score list is not implemented. returning to menu ..."
mode = "menu"
while (mode == "gallery"):
print "gallery is not implemented. returning to menu ..."
mode = "menu"
while (mode == "credits"):
print "credits is not implemented. returning to menu ..."
mode = "menu"
while (mode == "quit"):
print "quitting game ..."
pygame.quit()
mode = False
def it_should_handle_empty_constructor(self):
with self.assertRaises(Exception) as context:
game.Game()
self.assertTrue(
"You need to specify the number of players and cards" in str(
context.exception))
