def _game_restart(self): """ Send the score to the server, and ask the player to continue """ # Send the score to the server post_result = self.player.post_score() # Show the gameover screen game_continue = self.gameover.run(self.view.window, self.player, post_result) # If restarting the game if game_continue: # Recreate the snake and gameview self.snake = Snake() self.view = GameView() # Reset the score self.player.score = 0 return True else: return False
def on_game_started(self, event): module_logger.info("MainMenuController: on_game_started called.") model = GameModel(self.event_dispatcher) view = GameView(self.event_dispatcher) controllers = [] game_controller = GameController(model, self.event_dispatcher) mouse_controller = MouseController(self.event_dispatcher) controllers.append(game_controller) controllers.append(mouse_controller) event = MVCChangeEvent(model, view, controllers) self.event_dispatcher.dispatch_event(event)
def main(): from main_window import MainWindow from network import Network window = MainWindow(WIDTH, HEIGHT, "PyMMO") window.set_update_rate(1 / 1000) # SET FPS menu_view = GameView() window.show_view(menu_view) network = Network(window) n = threading.Thread(target=network.action) n.daemon = True n.start() g = threading.Thread(target=arcade.run) g.daemon = True g.run()
def test_game_display(): """1001 - Tests if the game display maze structure correctly""" maze_object = Maze("tests/test1.txt", "P") view = GameView(maze_object) assert "xPx x" in view.display_maze()
class GameController(): def __init__(self): """ Initializing what instances of classes """ self.snake = Snake() self.view = GameView() self.apple = Apple() self.poison = Poison() self.player = Player() self.gameover = GameOverController() self.gamestart = GameStartController() def run(self): """ Run the game """ clock = pygame.time.Clock() # Game is running running = True # Show start screen and get the player's name players_name = self.gamestart.run(self.view.window) if not players_name: running = False else: # assigning player name that's typed in to the player instance self.player.name = players_name while running: clock.tick(20) # Apple apples = pygame.sprite.Group() apples.add(self.apple) # Poison poisons = pygame.sprite.Group() poisons.add(self.poison) # Show the game screen self.view.display(self.snake, self.player.score) apples.draw(self.view.window) poisons.draw(self.view.window) # checking to see if snake has eaten apple eaten_apple = self.apple.apple_eaten(self.snake.group) # if apple has been eaten, generate new apple, make snake longer, and add a point to score if eaten_apple: self.snake.add_body() self.player.add_point() # checking to see if new apple overlaps static poison self.apple.overlap_poison_with_apple(self.poison, poisons) # checking to see if new apple is placed under snake body, if it is, generate new apple self.apple.overlap_snake_new_apple(self.snake.group) # checking to see if poison has been eaten by snake overlap_snake = self.poison.poison_eaten(self.snake.group) # if snake has eaten the poison if overlap_snake == True: # Ask the player to continue if not self._game_restart(): running = False # When the snake hits the wall if self.snake.check_hit_wall(self.view.window): # Ask the player to continue if not self._game_restart(): running = False # Catch the event for event in pygame.event.get(): # If the window is closed if event.type == pygame.locals.QUIT: running = False # If the direction keys are typed if event.type == pygame.KEYDOWN: if event.key == pygame.locals.K_RIGHT: self.snake.turn("Right") elif event.key == pygame.locals.K_LEFT: self.snake.turn("Left") elif event.key == pygame.locals.K_UP: self.snake.turn("Up") elif event.key == pygame.locals.K_DOWN: self.snake.turn("Down") # Move the snake self.snake.move() pygame.display.update() def _game_restart(self): """ Send the score to the server, and ask the player to continue """ # Send the score to the server post_result = self.player.post_score() # Show the gameover screen game_continue = self.gameover.run(self.view.window, self.player, post_result) # If restarting the game if game_continue: # Recreate the snake and gameview self.snake = Snake() self.view = GameView() # Reset the score self.player.score = 0 return True else: return False
class GraphicEngine(Tk): def __init__(self, _graphic_engine_options=None): #Initialize game engine super().__init__() self.graphic_engine_on = True self.save_number = 0 if _graphic_engine_options == None: self.options = self.loadGraphicEngineOptions() else: self.options = _graphic_engine_options self.textures, self.pil_textures = self.loadTextures() self.matrix = self.loadMatrix() self.protocol("WM_DELETE_WINDOW", self.onWindowClosing) MainMenuView(self, self.textures["ui"], self.options["x_window_size"], self.options["y_window_size"]) def onWindowClosing(self): #Closing window event try: while self.chunck_loader.is_map_generating == True: time.sleep(.1) except AttributeError: pass self.graphic_engine_on = False try: self.game_view.player.player_move_loop.join(1) except AttributeError: pass #Save game if not os.path.exists("saves"): os.mkdir("saves") if self.save_number != 0: with open("saves/save_{}.json".format(str(self.save_number)), "w") as f: f.write(self.createDataToSave()) self.destroy() def showWindow(self): self.geometry("{}x{}".format(self.options["x_window_size"], self.options["y_window_size"])) self.resizable(width=False, height=False) self.mainloop() def loadGraphicEngineOptions(self): #Load all graphic engine options def createOptions(): #Generate default options options = {} #Init all options here options["x_window_size"] = 600 options["y_window_size"] = 600 options["progressive_map_generation"] = False options["texture_size"] = 25 with open("ressources/configuration/graphic_engine.json", "w") as file: file.write(json.dumps(options, indent=4)) return options def loadOptions(): #Load options from file with open("ressources/configuration/graphic_engine.json", "r") as file: json_content = json.loads(file.read()) return json_content #Execute good function in good case if not os.path.exists("ressources/configuration/graphic_engine.json"): return createOptions() else: return loadOptions() def loadMatrix(self): #Load matrix from json file map_name = "earth" with open("ressources/maps/{}.json".format(map_name), "r") as file: matrix = json.loads(file.read()) return matrix def saveGraphicEngineConfiguration(self): #Save graphic engine configuration with open("ressources/configuration/graphic_engine.json", "w") as file: file.write(json.dumps(self.options, indent=4)) def loadTextures(self): #Load textures from json file and png pictures with open("ressources/configuration/textures.json", "r") as file: json_content = json.loads(file.read()) textures = {} pil_textures = {} size = self.options["texture_size"] for category in json_content.keys(): textures[category] = {} pil_textures[category] = {} for content in json_content[category].keys(): if json_content[category][content] != "NONE": try: textures[category][content] = PhotoImage( file="ressources/textures/{}/{}".format( category, json_content[category][content])) pil_textures[category][content] = PIL.Image.open( "ressources/textures/{}/{}".format( category, json_content[category][content])).resize( (size, size)) except TclError as e: print(e) return textures, pil_textures def loadMap(self, options): x, y = options["player_x"], options["player_y"] self.screen_size = (self.options["x_window_size"], self.options["y_window_size"]) self.map_x = self.screen_size[0] * (-1.5) - x % self.screen_size[0] self.map_y = self.screen_size[1] * (-1.5) - y % self.screen_size[1] coef_x = x // self.screen_size[0] * self.screen_size[0] coef_y = y // self.screen_size[1] * self.screen_size[1] self.chunck_loader = ChunckLoader(x, y, self, self.pil_textures, self.matrix, (coef_x, coef_y)) self.map = self.chunck_loader.loadMapFromCenter(x, y) self.player = Player(self.map_x, self.map_y, self.map, self, self, self.textures["fight_ui"]) threading.Thread(target=self.chunck_loader.startCheckLoop, args=(self.player, )).start() self.physical_engine = PhysicalEngine(self.chunck_loader, self) self.physical_engine.start() self.displayMap() def displayMap(self): #Display map on screen try: self.game_view = GameView(self, self.options, self.player, self.textures, self.pil_textures, self.map) self.game_view.start() except AttributeError: return 1 def createDataToSave(self): try: data_dict = {} if self.chunck_loader.x >= 0: if self.chunck_loader.y >= 0: data_dict["player_x"] = self.chunck_loader.x % 15000 data_dict["player_y"] = self.chunck_loader.y % 15000 else: data_dict["player_x"] = self.chunck_loader.x % 15000 data_dict["player_y"] = self.chunck_loader.y % -15000 elif self.chunck_loader.x <= 0: if self.chunck_loader.y >= 0: data_dict["player_x"] = self.chunck_loader.x % -15000 data_dict["player_y"] = self.chunck_loader.y % 15000 else: data_dict["player_x"] = self.chunck_loader.x % -15000 data_dict["player_y"] = self.chunck_loader.y % -15000 return json.dumps(data_dict) except AttributeError as e: return str(e)
def test_init_argument(): """ 020A test if constructor recieves two argument """ with pytest.raises(TypeError): maze = GameView() with pytest.raises(TypeError): maze = GameView([], "as", "as")
class GameController: '''Call functions from GameView to display the maze. Call functions from Maze to get position of player, items, and exit Set up how player will move based on "↑,↓,←,→" command''' def __init__(self, maze, window): """Constructor for GameController class Args: maze (Maze): instance of the Maze class window (pygame.Surface): display the pygame surface """ self._maze = maze self._game_over = False self._view = GameView(maze, window) self._keyboard_controller = KeyboardController() @property def player_current_location(self): """Getter for player's current location Returns: (tuple): current location of the player """ return (self._maze.locations["P"][0] + self._maze.movements_player[0], self._maze.locations["P"][1] + self._maze.movements_player[1]) def run(self): """This is the main function that calls the methods that control the game based on user's input (↑,↓,←,→,q) The pygame window closes when user presses 'q'. """ user_input = self._keyboard_controller.get_action() if user_input in ("up", "left", "down", "right"): self.move_with_input(user_input) elif user_input == "q": pygame.quit() self._view.display_maze() def move_with_input(self, user_input): """Gets user input from KeyboardController, matches it with the movement dict and updates the player position accordingly. Args: user_input (str): key pressed by the user """ movement = { "up": (-1, 0), "down": (1, 0), "left": (0, -1), "right": (0, 1) } # position will not change if user_input is not a recognized command shift = movement.get(user_input, (0, 0)) x = shift[0] y = shift[1] self._maze.move_player(x, y) # pygame - set new position in the window player_row = self.player_current_location[0] player_col = self.player_current_location[1] self._maze.player.rect.x = player_col * GridSize.SIZE self._maze.player.rect.y = player_row * GridSize.SIZE self._view.display_maze() if self._maze.get_item(): self._view.get_items(self._maze.player.backpack)
def __init__(self): self.view = GameView() self.player_controller = PlayerController.get_instance() self.tournament_controller = TournamentController.get_instance()
class GameController: def __init__(self): self.view = GameView() self.player_controller = PlayerController.get_instance() self.tournament_controller = TournamentController.get_instance() def launch(self): self.player_controller.load_player_list() self.tournament_controller.load_tournament_list() while True: menu_choice = self.view.show_menu_options() if menu_choice == 1: self.launch_tournament() elif menu_choice == 2: while True: self.player_controller.create_new_player() choice = self.view.ask_validation( 'Créer un autre joueur ?') self.player_controller.save_player_list() if choice == "0": continue elif choice == "1": break elif menu_choice == 3: self.player_controller.modify_player_elo() elif menu_choice == 4: self.generate_rapports() elif menu_choice == 5: self.exit() break def launch_tournament(self): tournament = self.tournament_controller.get_tournament() if tournament is not None: self.tournament_controller.save_tournament_list() while True: choice = self.view.ask_validation( 'Voulez vous lancer ce tournoi tout de suite ?') if choice == "0": self.tournament_controller.run_tournament(tournament) break elif choice == "1": break else: continue def generate_rapports(self): while True: choice, subchoice = self.view.display_rapport_menu() if choice == 0: self.player_controller.display_players(subchoice) elif choice == 1: self.tournament_controller.display_tournament_player(subchoice) elif choice == 2: self.tournament_controller.display_tournaments() elif choice == 3: self.tournament_controller.display_round_tournament() elif choice == 4: self.tournament_controller.display_match_tournament() elif choice == 5: break choice = self.view.ask_validation('Générer un autre rapport ?') if choice == "0": continue elif choice == "1": break def exit(self): self.player_controller.save_player_list() self.tournament_controller.save_tournament_list()