def handle_events(): events = pc.get_events() mouse_pos_x, mouse_pos_y = c_int(),c_int() pc.SDL_GetMouseState(mouse_pos_x, mouse_pos_y) MouseController.mouse_input(int(mouse_pos_x.value), int(mouse_pos_y.value)) for a in events: if a.type == pc.SDL_QUIT: game_framework.quit() # ESC 게임 종료 if a.type == pc.SDL_KEYDOWN and a.key == pc.SDLK_ESCAPE: import TitleScene game_framework.change_state(TitleScene) # 마우스 입력 if a.type == pc.SDL_MOUSEBUTTONDOWN and a.button == 1: MouseController.interact_input(True) #if a.type == pc.SDL_MOUSEMOTION: # MouseController.mouse_input(a.x, a.y) if a.type == pc.SDL_MOUSEBUTTONUP and a.button == 1: MouseController.interact_input(False) # 키보드 입력 if a.type == pc.SDL_KEYDOWN: # print(a.key) if a.key == 97: # a KeyController.x -= 1 if KeyController.x < -1: KeyController.x = -1 Player2.this.move_stair(Player2.KEY_A) if a.key == 100: # d KeyController.x += 1 if KeyController.x > 1: KeyController.x = 1 Player2.this.move_stair(Player2.KEY_D) if a.key == 115: # s KeyController.interact_input(True) Player2.this.move_stair(Player2.KEY_S) if a.key == 119: # w Player2.this.move_stair(Player2.KEY_W) # 카메라 줌 확인용 if a.key == 61: # View.views[0].cam.size += 0.5 Player2.this.is_die = True if a.key == 45: #View.views[0].cam.size -= 0.5 GameManager.game_end(GameManager.KEYUSER) if a.type == pc.SDL_KEYUP: if a.key == 97: # a KeyController.x += 1 if a.key == 100: # d KeyController.x -= 1 if a.key == 115: # s KeyController.interact_input(False) if GameManager.is_paused: Player2.this.is_paused = True
def __init__(self): self.IMAGE_HEIGHT = 30 self.IMAGE_WIDTH = 30 BOARD_SIZE = 100 BOARD_SIGMA = 10 self.channels = 3 self.game_list = [] output_size = 30 self.model = Model(self.IMAGE_HEIGHT, self.IMAGE_WIDTH, self.channels, "Fred", output_size) self.init_model = Model(self.IMAGE_HEIGHT, self.IMAGE_WIDTH, self.channels, "Terry", output_size) self.saved_batches = [] self.MAX_SAVED_BATCH_SIZE = 100 self.saved_batch_index = 1 self.need_reset = False self.saved_batches_in_use = True np.random.seed(33127436) expansion_levels = (15, 18, 30) self.expanders = [] for expansion_index in range(len(expansion_levels)): if 0 == expansion_index: self.expanders.append( np.random.random_sample( (expansion_levels[expansion_index], 11))) else: self.expanders.append( np.random.random_sample( (expansion_levels[expansion_index], expansion_levels[expansion_index - 1]))) np.random.seed() self.compressors = [] for expander in self.expanders[::-1]: self.compressors.append(np.linalg.pinv(expander)) self.game = GameManager(BOARD_SIZE, BOARD_SIGMA)
class Environment: def __init__(self): self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE) self.current_state = None self.total_reward = 0 self.reset() @property def action_shape(self): return self.game.env.action_space.shape @property def obs_shape(self): return self.game.env.observation_space.shape @property def name(self): return self.game.env.spec._env_name def reset(self): self.total_reward = 0 self.current_state = self.game.reset() def step(self, action): observation, reward, done, _ = self.game.step(action) self.current_state = observation self.total_reward += reward return reward, done
def test_GameManagerInputs(self): """ Tests GameManager input data prompter and respondents and GET abilities of those props """ gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"]) self.assertEqual((str==type(gameManager.get_prompter()[0])), True) self.assertEqual((list==type(gameManager.get_respondents())), True)
def test_lobby_password(self): game_manager = GameManager() game_manager.create_lobby("TEST", password="******") lobbies = game_manager.get_lobbies_list() self.assertTrue(lobbies[0]["hasPassword"])
def check_collisions(self): head_mag = self.get_head_pos()[0] for obs in Obstacle.current_obstacles: if obs.is_on_angle(self.y) and obs.get_max_magnitude( self.y) > head_mag > obs.get_min_magnitude(self.y): GameManager.game_over()
class Environment: def __init__(self): self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE) self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset() @staticmethod def _rgb2gray(rgb): return np.dot(rgb[..., :3], [0.299, 0.587, 0.114]) @staticmethod def _preprocess(image): image = Environment._rgb2gray(image) image = misc.imresize(image, [Config.IMAGE_HEIGHT, Config.IMAGE_WIDTH], 'bilinear') image = image.astype(np.float32) / 128.0 - 1.0 return image def _get_current_state(self): if not self.frame_q.full(): return None # frame queue is not full yet. x_ = np.array(self.frame_q.queue) x_ = np.transpose(x_, [1, 2, 0]) # move channels return x_ def _update_frame_q(self, frame): if self.frame_q.full(): self.frame_q.get() image = Environment._preprocess(frame) self.frame_q.put(image) def get_num_actions(self): # Updated with action space return self.game.max_actions def get_extended_action_space(self): # Get extended action space return self.game.acts def reset(self): self.total_reward = 0 self.frame_q.queue.clear() self._update_frame_q(self.game.reset()) self.previous_state = self.current_state = None def step(self, action): observation, reward, done, _ = self.game.step(action) self.total_reward += reward self._update_frame_q(observation) self.previous_state = self.current_state self.current_state = self._get_current_state() return reward, done
def setUp(self, mock_gm_app): self.auto_clicker_1 = AutoClickers('Factory', 5.0, 15.0, 0) self.auto_clicker_2 = AutoClickers('Farm', 10.0, 50.0, 3) self.auto_clicker_3 = AutoClickers('House', 20.0, 100.0, 5) self.game_manager = GameManager(auto_clickers=[ self.auto_clicker_1, self.auto_clicker_2, self.auto_clicker_3 ]) self.game_manager.app = mock_gm_app
def test_lobby_password_encrypted(self): game_manager = GameManager() lobby_key = game_manager.create_lobby("TEST", password="******") lobby: Lobby = game_manager.get_lobby(lobby_key) self.assertNotEqual(lobby.password_encrypted, "test") self.assertTrue(lobby.check_password_correct("test"))
def __init__(self): self.game = GameManager(Config.DATA_FRAME, display=Config.PLAY_MODE) # self.nb_frames = Config.STACKED_FRAMES # self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset()
def __init__(self): self.game = GameManager() self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset()
class Environment: def __init__(self, display=Config.SHOW_MODE): self.game = GameManager(display=display) self.previous_state = None self.current_state = None self.available = None self.total_reward = 0 self.envs_mean = None self.envs_std = None self.num_steps = 0 self.state_mean = 0 self.state_std = 0 self.alpha = 0.9999 self.num_steps = 0 #self.reset() def get_num_actions(self): return self.game.get_num_actions() def get_num_states(self): return self.game.get_num_state() def _observation(self, observation): self.num_steps += 1 self.state_mean = self.state_mean * self.alpha + \ observation.mean() * (1 - self.alpha) self.state_std = self.state_std * self.alpha + \ observation.std() * (1 - self.alpha) unbiased_mean = self.state_mean / (1 - pow(self.alpha, self.num_steps)) unbiased_std = self.state_std / (1 - pow(self.alpha, self.num_steps)) return (observation - unbiased_mean) / (unbiased_std + 1e-8) def reset(self): self.total_reward = 0 observation, available = self.game.reset() self.previous_state = self.current_state = None self.current_state = process_frame(observation) return self.current_state, available def step(self, action): observation, reward, done, available, envs_mean, envs_std = self.game.step( action) self.available = available self.total_reward += reward self.envs_mean = envs_mean self.envs_std = envs_std self.previous_state = self.current_state self.current_state = process_frame(observation) # self.current_state = self._observation(process_frame(observation)) return self.current_state, reward, done, available, envs_mean, envs_std
def test_lobby_create(self): game_manager = GameManager() lobby_key = game_manager.create_lobby("TEST") lobbies = game_manager.get_lobbies_list() self.assertTrue(len(lobbies) == 1) self.assertEqual(lobbies[0]["key"], lobby_key) self.assertEqual(lobbies[0]["name"], "TEST")
def main(): global player print "Loading..." pname = "" # Load player data if exists if os.path.isfile(playerDataFile): with open(playerDataFile, 'rb') as d: player = pickle.load(d) if os.path.isfile(gameDataFile): with open(gameDataFile, 'rb') as d: board = pickle.load(d) call(["clear"]) print "+" + "-" * 86 + "+" print "| BBBB A TTTTTT TTTTTT LL EEEEE SSSSS HH HH IIIIII PPPPPP |" print "| B B A A TT TT LL EE SSS HH HH II PP P |" print "| B B AAAAA TT TT LL EEE SSS HHHHHH II PPPPPP |" print "| B B AA AA TT TT LL EE SS HH HH II PP |" print "| BBBB AA AA TT TT LLLLLL EEEEE SSSSS HH HH IIIIII PP |" print "+" + "-" * 86 + "+\n" if player == "": print "Please create a player!" name = raw_input("Your name > ") player = Player(name) with open('./.playerdata.bpydata', 'wb') as d: pickle.dump(player, d) manager = GameManager(player) while True: choice = mainMenu() if choice == 1: call(["clear"]) manager.play() elif choice == 2: call(["clear"]) print(player) raw_input() call(["clear"]) elif choice == 3: player.setupPlayer() manager.updatePlayer(player) else: player.save() break
def test_gamemanager_query_get(self): gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"]) q = gameManager.get_suggestions("dogfish") # Check that the keys() of answers received correspond to the respondents del q['Jonathan'] del q['if_valid'] self.assertEqual(sorted(q.keys()),sorted(gameManager.get_respondents())) # Check to see if suggestions are shuffled: p1, p2, p3 = q.keys() self.assertEqual( (q[p1] != q[p2] != q[p3]), True)
def test_lobby_random_salt(self): game_manager = GameManager() all_keys = [] for i in range(10): lobby_key = game_manager.create_lobby("TEST{}".format(i)) all_keys.append(lobby_key) # remove duplicates with set, it should be equal removed_duplicates = list(set(all_keys)) self.assertEqual(sorted(all_keys), sorted(removed_duplicates))
def game_loop(): manager = GameManager() while manager.game_state != GameState.PAUSED: # handle quit for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() manager.update()
def testRegisterUsers(self): example = [[1 for i in range(10)] for j in range(10)] hall = Hallway((14, 5), (20, 5), []) zHall = Hallway((14, 14), (20, 10), [(17, 14), (17, 10)]) room = Room(example, (5, 5)) room2 = Room(example, (20, 5)) floor = Floor([room, room2], [hall, zHall]) game = GameState([floor]) gm = GameManager(game) gm.register_player_user(self.LocalPlayer1) gm.register_player_user(self.LocalPlayer2) self.assertEqual(2, len(gm.ID_to_user_character))
def test_check_password_correct(self): game_manager = GameManager() lobby_key = game_manager.create_lobby("TEST", password="******") lobby: Lobby = game_manager.get_lobby(lobby_key) # password is encrypted self.assertNotEqual(lobby.password_encrypted, "test") # correct password is working and others are not self.assertTrue(lobby.check_password_correct("test")) self.assertFalse(lobby.check_password_correct("test1")) self.assertFalse(lobby.check_password_correct("1234"))
def start_screen(window): while True: for event in pygame.event.get(): if event.type == pygame.QUIT: GameManager.close() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_p: return window.fill(0) pygame.display.flip()
def main(): args = parse_arguments() if args.Terminal: game = GameManager() game.start() else: game = Gui() game.start() game.stop()
class Environment: def __init__(self): self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE) self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset() @staticmethod def _rgb2gray(rgb): return np.dot(rgb[..., :3], [0.299, 0.587, 0.114]) @staticmethod def _preprocess(image): image = Environment._rgb2gray(image) image = misc.imresize(image, [Config.IMAGE_HEIGHT, Config.IMAGE_WIDTH], 'bilinear') image = image.astype(np.float32) / 128.0 - 1.0 return image def _get_current_state(self): if not self.frame_q.full(): return None # frame queue is not full yet. x_ = np.array(self.frame_q.queue, dtype=np.float32) return x_ def _update_frame_q(self, frame): if self.frame_q.full(): self.frame_q.get() image = Environment._preprocess(frame) self.frame_q.put(image) def get_num_actions(self): return self.game.env.action_space.n def reset(self): self.total_reward = 0 self.frame_q.clear() self._update_frame_q(self.game.reset()) self.previous_state = self.current_state = None def step(self, action): observation, reward, done, _ = self.game.step(action) self.total_reward += reward self._update_frame_q(observation) self.previous_state = self.current_state self.current_state = self._get_current_state() return reward, done
class Environment: def __init__(self): self.game = GameManager(Config.SC2_MAP_NAME, image_size=Config.IMAGE_SIZE) self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset() def _get_current_state(self): if not self.frame_q.full(): raise Exception("Current state should not be None") return None # frame queue is not full yet. x_ = self.frame_q.queue[0] return x_ def _update_frame_q(self, observation): if self.frame_q.full(): self.frame_q.get() # print (observation["screen"]) self.frame_q.put(observation) def get_num_actions(self): num_actions = dict() num_actions["base_action"] = len(actions.FUNCTIONS) for act_type in actions.TYPES: if act_type.name in ("screen", "screen2", "minimap"): num_actions[act_type.name] = (self.game.image_size, self.game.image_size) else: num_actions[act_type.name] = act_type.sizes[0] return num_actions def reset(self): self.total_reward = 0 self.frame_q.queue.clear() self._update_frame_q(self.game.reset()) self.previous_state = None self.current_state = self._get_current_state() def step(self, action): observation, reward, done, _ = self.game.step(action) self.total_reward += reward # self._update_frame_q(observation) self.previous_state = self.current_state.copy() self.current_state = observation return reward, done
def __init__(self, display=Config.SHOW_MODE): self.game = GameManager(display=display) self.previous_state = None self.current_state = None self.available = None self.total_reward = 0 self.envs_mean = None self.envs_std = None self.num_steps = 0 self.state_mean = 0 self.state_std = 0 self.alpha = 0.9999 self.num_steps = 0
def test_lobby_random_salt(self): game_manager = GameManager() lobby_key1 = game_manager.create_lobby("TEST1", password="******") lobby_key2 = game_manager.create_lobby("TEST2", password="******") lobby1: Lobby = game_manager.get_lobby(lobby_key1) lobby2: Lobby = game_manager.get_lobby(lobby_key2) # each lobby has different salt, passwords are the same but encrypted values are not self.assertNotEqual(lobby1.salt, lobby2.salt) self.assertNotEqual(lobby1.password_encrypted, lobby2.password_encrypted) # both lobbies have same password self.assertTrue(lobby1.check_password_correct("test")) self.assertTrue(lobby2.check_password_correct("test"))
def __init__(self, discrete=True): global locker global global_port locker.acquire(True) this_port = global_port global_port += 1 locker.release() #self.client = AirSimClient(port=this_port) #self.client.confirmConnection() #self.client.enableApiControl(True) #self.client.armDisarm(True) self.log_file = open('logs.txt', 'w') self.acc_file = open('accs.txt', 'w') self.episodes = 0 self.fps = 60 self.max_iter = 15 * self.fps self.t = np.matrix([10.0, 0.0, 0.0]) self.o = np.matrix([0.0, 0.0, 0.0]) self.c = np.matrix([0.0, 0.0, 0.0]) self.v = np.matrix([0.0, 0.0, 0.0]) self.v_t = np.matrix([0.0, 0.0, 0.0]) self.r = np.matrix([0.0, 0.0, 0.0]) self.queue_len = 4 self.coord_queue = None self.width = 256 self.height = 144 self.image = None self.iteration = 0 #self._render() self.current_state = self._get_obs() self.reset() self.viewer = None self.discrete = discrete if self.discrete: self.action_space = spaces.Discrete(27) self.observation_space = spaces.Box( low=np.zeros(self.current_state.shape), high=np.zeros(self.current_state.shape) + 1) else: self.action_space = spaces.Box(-1, 1, shape=(4, )) self.observation_space = spaces.Box( low=np.zeros(self.current_state.shape), high=np.zeros(self.current_state.shape) + 1) self.current_state = None self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.game = GameManager('AirSim', display=Config.PLAY_MODE, custom_env=self) self._seed()
def main(): """ The condition will defined if you want start in terminal, with the module GameManager or with in graphic version with the module Gui. To allow you to choose the version in shell, a argument "-g" is adding for the graphic version. """ laby = Labyrinth('labyrinth.txt') if args.gui: gui = Gui(laby) gui.launch_game() else: gamer = GameManager(laby) gamer.launch_game()
def __init__(self, s_width, s_height, setup): """ Initialize the game starting in main menu Args: s_width (int): screen_width s_width (int): screen_height setup (Setup[]): list of setup options: Desktop: default option. in this mode everything is controlled by keyboard Arcade: prevents user from quiting the game from ui and changing key bindings in this mode both the game and ui are controlled by joysticks Windowed: default option. Uses s_width and s_height to determine screen dimensions Fullscreen: ignores s_width and s_height args and enables fullscreen (duh) """ pygame.init() pygame.font.init() self.arcade = False fullscreen = False for opt in setup: if opt == Setup.Arcade: self.arcade = True elif opt == Setup.Fullscreen: fullscreen = True self.joysticks = [ pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count()) ] for j in self.joysticks: j.init() self.display = Display((s_width, s_height), fullscreen) self.clock = pygame.time.Clock() self.FPS = 60 self.ui = UI(self.display) if self.arcade: if len(self.joysticks) == 0: print( "=================== plug in the controller ===================" ) exit(1) self.ui.enable_arcade_mode() self.selected_speed = "speed Medium" self.game_manager = GameManager(self.display, self.ui, GameMode.EatToGrow, GameState.Menu)
def test_create_room(self): g = GameManager() username = '******' socket = 'socket' g.create_room(username, socket) self.assertEquals(socket in g.socket_to_room, True) self.assertEquals(g.socket_to_username[socket], username) reason = 'user is already a part of a room' expected = (socket, { 'type': 'Created', 'room_name': g.socket_to_room[socket], 'usernames': [username], 'status': 'failed', 'reason': reason }) self.assertEquals(g.create_room(username, socket), expected)
def test_GameManagerQueryGet(): """ Here we test the GameManager get_suggestions method We expect to see four answers (response from server) that are shuffled If they are not shuffled answers we will throw an error. """ gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"]) q = gameManager.get_suggestions("dogfish") # Check that the keys() of answers received correspond to the respondents del q['Jonathan'] del q['if_valid'] assert (sorted(q.keys()) == sorted(gameManager.get_respondents())) # Check to see if suggestions are shuffled: p1, p2, p3 = q.keys() assert (q[p1] != q[p2] != q[p3])
def make_objs(): global victory_img, background background = DrawObj() if GameManager.get_winning_player_idx() == GameManager.MOUSEUSER: background.load_img("img/leewin.png") else: background.load_img("img/enemywin.png") if GameManager.mouseuser_ui is not None: victory_img = DrawObj() if GameManager.get_winning_player_idx() == GameManager.MOUSEUSER: victory_img.imgs = GameManager.mouseuser_ui.imgs else: victory_img.imgs = GameManager.keyuser_ui.imgs background.pos = np.array(background.get_halfsize())
def __init__(self): self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE) self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset()
class Environment: def __init__(self): self.game = GameManager() self.nb_frames = Config.STACKED_FRAMES self.frame_q = Queue(maxsize=self.nb_frames) self.previous_state = None self.current_state = None self.total_reward = 0 self.reset() # @staticmethod # def _rgb2gray(rgb): # return np.dot(rgb[..., :3], [0.299, 0.587, 0.114]) # # @staticmethod # def _preprocess(image): # image = Environment._rgb2gray(image) # image = misc.imresize(image, [Config.IMAGE_HEIGHT, Config.IMAGE_WIDTH], 'bilinear') # image = image.astype(np.float32) / 128.0 - 1.0 # return image # def _get_current_state(self): # if not self.frame_q.full(): # return None # frame queue is not full yet. # x_ = np.array(self.frame_q.queue) # x_ = np.transpose(x_, [1, 2, 0]) # move channels return self.game.env.getstate_3() # # def _update_frame_q(self, frame): # if self.frame_q.full(): # self.frame_q.get() # image = Environment._preprocess(frame) # self.frame_q.put(image) def get_num_actions(self): return N_A def reset(self): self.total_reward = 0 self.frame_q.queue.clear() #self._update_frame_q(self.game.reset()) self.previous_state = self.current_state = None return self.game.env.getstate_3() def step(self, action): observation, reward, done = self.game.step(action) self.total_reward += reward #self._update_frame_q(observation) self.previous_state = self.current_state self.current_state = self._get_current_state() return reward, done
def begin_game(self, level, cheat): # To avoid the timer from beginning early first_time = True self.game_running = True # Create the game manager self.manager = GameManager(self, level, cheat) # If we got shut off before we began (level error) if not self.game_running: return # Press P to pause self.pause = False while self.game_running: if first_time: actual_tick = 0 first_time = False self.clock.tick(60) else: actual_tick = self.clock.tick(60) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit(0) if event.type == pygame.KEYDOWN: if event.key == 32: self.manager.player_shoot() if event.key in [112, 80]: self.pause = not self.pause if not self.pause: # Update the logical part self.manager.update_elements(actual_tick) if self.game_running: # And the graphical part self.update_graphics() pygame.display.update()
class MatchingGame: def __init__(self): # Set up a clock for managing the frame rate. self.clock = pygame.time.Clock() self.game = GameManager() self.game.startGame(4) def set_paused(self, paused): self.paused = paused # Called to save the state of the game to the Journal. def write_file(self, file_path): pass # Called to load the state of the game from the Journal. def read_file(self, file_path): pass # The main game loop. def run(self): self.running = True screen = pygame.display.get_surface() while self.running: # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: return elif event.type == pygame.VIDEORESIZE: pygame.display.set_mode(event.size, pygame.RESIZABLE) elif event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: self.direction = -1 elif event.key == pygame.K_RIGHT: self.direction = 1 elif event.type == pygame.MOUSEBUTTONUP: x, y = pygame.mouse.get_pos() self.game.onClick(screen, x, y) # Clear Display screen.fill((128, 128, 128)) # 255 for white self.game.draw(screen) # Flip Display pygame.display.flip() # Try to stay at 30 FPS self.clock.tick(30)
class GameWindow(object): WIN_IMAGE = pygame.image.load("res/game_over/win.png") LOSE_IMAGE = pygame.image.load("res/game_over/lose.png") def __init__(self, parent): # For drawing self.screen = parent.screen # To avoid having to make another button function self.button = parent.make_button # Runs at 60 FPS self.clock = pygame.time.Clock() # Font type of the enemy queue counter self.type_font = pygame.font.SysFont("arial", 10) def begin_game(self, level, cheat): # To avoid the timer from beginning early first_time = True self.game_running = True # Create the game manager self.manager = GameManager(self, level, cheat) # If we got shut off before we began (level error) if not self.game_running: return # Press P to pause self.pause = False while self.game_running: if first_time: actual_tick = 0 first_time = False self.clock.tick(60) else: actual_tick = self.clock.tick(60) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit(0) if event.type == pygame.KEYDOWN: if event.key == 32: self.manager.player_shoot() if event.key in [112, 80]: self.pause = not self.pause if not self.pause: # Update the logical part self.manager.update_elements(actual_tick) if self.game_running: # And the graphical part self.update_graphics() pygame.display.update() def update_graphics(self): # Draw the game area background pygame.draw.rect(self.screen, (124, 124, 124), (0, 0, 640, 576)) # The enemy queue counter pygame.draw.rect(self.screen, (206, 174, 125), (640, 0, 160, 576)) # And a button to return to the main menu self.button("Main menu", (640, 526, 160, 50), ((42, 120, 35), (27, 77, 23)), funcion=self.return_menu) # We ask the manager for the elements elements = self.manager.elements for block in elements["blocks"]: self.screen.blit(block.image, block.rect) for hole in elements["holes"]: self.screen.blit(hole.image, hole.rect) for enemy in elements["enemies"]: self.screen.blit(enemy.image, enemy.rect) self.screen.blit(elements["player"].image, elements["player"].rect) self.screen.blit(elements["heart"].image, elements["heart"].rect) for explosion in elements["explosions"]: self.screen.blit(explosion.image, explosion.rect) for bala in elements["bullets"]: self.screen.blit(bala.image, bala.rect) self.update_counter() def game_over(self, we_won): if we_won: self.screen.blit(self.WIN_IMAGE, (0,0)) else: self.screen.blit(self.LOSE_IMAGE, (0,0)) pygame.display.update() running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() exit(0) if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: self.return_menu() running = False def return_menu(self): self.game_running = False def update_counter(self): self.enemies = self.manager.enemy_count() self.screen.blit(self.type_font.render("Enemies left on queue", 1, (0,0,0)), (645, 10)) self.screen.blit(self.type_font.render("Weak: {}".format(self.enemies[0]), 1, (0,0,0)), (650, 30)) self.screen.blit(self.type_font.render("Med: {}".format(self.enemies[1]), 1, (0,0,0)), (650, 50)) self.screen.blit(self.type_font.render("Strong: {}".format(self.enemies[2]), 1, (0,0,0)), (650, 70))
def __init__(self): # Set up a clock for managing the frame rate. self.clock = pygame.time.Clock() self.game = GameManager() self.game.startGame(4)
class GraphicBoard(QtGui.QWidget): push_letter_first = QtCore.Signal(Coordinates) push_letter_second = QtCore.Signal(Coordinates) choose_letter_first = QtCore.Signal(CellLetter) choose_letter_second = QtCore.Signal(CellLetter) commit_word_first = QtCore.Signal() commit_word_second = QtCore.Signal() quit = QtCore.Signal() give_up_first = QtCore.Signal() give_up_second = QtCore.Signal() def __init__(self, width, height, parent): super(GraphicBoard, self).__init__() self.__width__ = width self.__height__ = height self.__language__ = None lang_list = ['Russian', 'English'] game_lang, flag2 = QtGui.QInputDialog.getItem(self, 'Choose language of the game', 'Выберите язык игры', lang_list) if game_lang == 'Russian': self.__language__ = RussianLanguage() else: self.__language__ = EnglishLanguage() self.table_layout = QtGui.QGridLayout() self.buttons = list() for i in range(height): tmp_button_list = list() for j in range(width): tmp_button = ButtonCell(self.__language__) tmp_button.connect_to_panel(self) self.table_layout.addWidget(tmp_button, i, j) tmp_button_list.append(tmp_button) self.buttons.append(tmp_button_list) self.game_panel = QtGui.QHBoxLayout() self.game_board_panel = QtGui.QVBoxLayout() self.game_board_panel.addLayout(self.table_layout) self.word_panel = QtGui.QHBoxLayout() self.current_word = QtGui.QLabel('') self.commit_button = QtGui.QPushButton('Enter!') self.commit_give_up = QtGui.QPushButton('Give up') self.word_panel.addWidget(self.commit_give_up) self.word_panel.addWidget(self.current_word) self.word_panel.addWidget(self.commit_button) self.game_board_panel.addLayout(self.word_panel) self.first_player_score = QtGui.QLabel('0', self) self.first_player_words = QtGui.QListWidget(self) self.first_player_panel = QtGui.QVBoxLayout() self.first_player_panel.addWidget(self.first_player_score) self.first_player_panel.addWidget(self.first_player_words) self.second_player_score = QtGui.QLabel('0', self) self.second_player_words = QtGui.QListWidget(self) self.second_player_panel = QtGui.QVBoxLayout() self.second_player_panel.addWidget(self.second_player_score) self.second_player_panel.addWidget(self.second_player_words) self.game_panel.addLayout(self.first_player_panel) self.game_panel.addLayout(self.game_board_panel) self.game_panel.addLayout(self.second_player_panel) self.setLayout(self.game_panel) players, flag = QtGui.QInputDialog.getInt(self, 'Enter number of players', 'Введите число игроков', 1, 1, 2) if players == 2: self.__game_manager__ = GameManager(self.__language__, width=width, height=height, players_number=players) else: list_levels = ['EASY', 'MEDIUM', 'HARD', 'HARDEST'] level = QtGui.QInputDialog.getItem(self, 'Choose level', 'Выберите сложность', list_levels) self.__game_manager__ = GameManager(self.__language__, width, height, players, level[0]) self.connect_to_players(self.__game_manager__.get_first_player(), self.__game_manager__.get_second_player()) self.__game_manager__.get_first_player().connect_to_interface(self) self.__game_manager__.get_second_player().connect_to_interface(self) word = self.__game_manager__.get_first_word() for i in range(width): self.buttons[height//2][i].setText(word[i]) self.buttons[height//2][i].setMenu(None) self.commit_button.clicked.connect(self.on_commit_button_clicked) self.commit_give_up.clicked.connect(self.on_commit_give_up_clicked) self.__game_manager__.game_ended.connect(self.finish_game) self.quit.connect(parent.reset_field) @QtCore.Slot() def on_cell_pushed(self): x_sender = 0 y_sender = 0 for i in range(self.__height__): for j in range(self.__width__): if self.sender() == self.buttons[i][j]: x_sender = i y_sender = j send_letter = Coordinates(x_sender, y_sender) if self.__game_manager__.get_current_player() == 1: self.push_letter_first.emit(send_letter) else: self.push_letter_second.emit(send_letter) @QtCore.Slot(str) def on_cell_chosen(self, letter): x_sender = 0 y_sender = 0 for i in range(self.__height__): for j in range(self.__width__): if self.sender() == self.buttons[i][j]: x_sender = i y_sender = j send_letter = CellLetter(x_sender, y_sender, letter) if self.__game_manager__.get_current_player() == 1: self.choose_letter_first.emit(send_letter) else: self.choose_letter_second.emit(send_letter) @QtCore.Slot(Coordinates) def after_cell_pushed(self, coordinates: Coordinates): self.current_word.setText(self.current_word.text() + self.buttons[coordinates.x][coordinates.y].text()) @QtCore.Slot(CellLetter) def after_cell_chosen(self, coordinates: CellLetter): self.buttons[coordinates.x][coordinates.y].setMenu(None) self.buttons[coordinates.x][coordinates.y].setText(coordinates.letter) @QtCore.Slot(str) def after_word_committed(self, word): self.current_word.setText(None) if self.sender() == self.__game_manager__.get_first_player(): self.first_player_words.addItem(word) score = self.__game_manager__.get_first_player().get_score() self.first_player_score.setText(str(score)) else: self.second_player_words.addItem(word) score = self.__game_manager__.get_second_player().get_score() self.second_player_score.setText(str(score)) self.run_step() @QtCore.Slot(Coordinates) def on_player_reset_word(self, coordinates: Coordinates): self.buttons[coordinates.x][coordinates.y].create_menu() self.buttons[coordinates.x][coordinates.y].setText('') self.current_word.setText('') @QtCore.Slot() def on_commit_button_clicked(self): if self.__game_manager__.get_current_player() == 1: self.commit_word_first.emit() else: self.commit_word_second.emit() @QtCore.Slot() def on_commit_give_up_clicked(self): if self.__game_manager__.get_current_player() == 1: self.give_up_first.emit() else: self.give_up_second.emit() @QtCore.Slot(str) def finish_game(self, message): box = QtGui.QMessageBox(self) box.setText(message) ok_button = box.addButton(QtGui.QMessageBox.Ok) box.exec_() if box.clickedButton() == ok_button: self.quit.emit() def connect_to_players(self, player1: Player, player2: Player): self.choose_letter_first.connect(player1.on_letter_chosen) self.push_letter_first.connect(player1.on_letter_pushed) self.choose_letter_second.connect(player2.on_letter_chosen) self.push_letter_second.connect(player2.on_letter_pushed) self.commit_word_first.connect(player1.on_word_committed) self.commit_word_second.connect(player2.on_word_committed) self.give_up_first.connect(player1.send_end) self.give_up_second.connect(player2.send_end) def run_step(self): self.__game_manager__.run_game()
def __init__(self, width, height, parent): super(GraphicBoard, self).__init__() self.__width__ = width self.__height__ = height self.__language__ = None lang_list = ['Russian', 'English'] game_lang, flag2 = QtGui.QInputDialog.getItem(self, 'Choose language of the game', 'Выберите язык игры', lang_list) if game_lang == 'Russian': self.__language__ = RussianLanguage() else: self.__language__ = EnglishLanguage() self.table_layout = QtGui.QGridLayout() self.buttons = list() for i in range(height): tmp_button_list = list() for j in range(width): tmp_button = ButtonCell(self.__language__) tmp_button.connect_to_panel(self) self.table_layout.addWidget(tmp_button, i, j) tmp_button_list.append(tmp_button) self.buttons.append(tmp_button_list) self.game_panel = QtGui.QHBoxLayout() self.game_board_panel = QtGui.QVBoxLayout() self.game_board_panel.addLayout(self.table_layout) self.word_panel = QtGui.QHBoxLayout() self.current_word = QtGui.QLabel('') self.commit_button = QtGui.QPushButton('Enter!') self.commit_give_up = QtGui.QPushButton('Give up') self.word_panel.addWidget(self.commit_give_up) self.word_panel.addWidget(self.current_word) self.word_panel.addWidget(self.commit_button) self.game_board_panel.addLayout(self.word_panel) self.first_player_score = QtGui.QLabel('0', self) self.first_player_words = QtGui.QListWidget(self) self.first_player_panel = QtGui.QVBoxLayout() self.first_player_panel.addWidget(self.first_player_score) self.first_player_panel.addWidget(self.first_player_words) self.second_player_score = QtGui.QLabel('0', self) self.second_player_words = QtGui.QListWidget(self) self.second_player_panel = QtGui.QVBoxLayout() self.second_player_panel.addWidget(self.second_player_score) self.second_player_panel.addWidget(self.second_player_words) self.game_panel.addLayout(self.first_player_panel) self.game_panel.addLayout(self.game_board_panel) self.game_panel.addLayout(self.second_player_panel) self.setLayout(self.game_panel) players, flag = QtGui.QInputDialog.getInt(self, 'Enter number of players', 'Введите число игроков', 1, 1, 2) if players == 2: self.__game_manager__ = GameManager(self.__language__, width=width, height=height, players_number=players) else: list_levels = ['EASY', 'MEDIUM', 'HARD', 'HARDEST'] level = QtGui.QInputDialog.getItem(self, 'Choose level', 'Выберите сложность', list_levels) self.__game_manager__ = GameManager(self.__language__, width, height, players, level[0]) self.connect_to_players(self.__game_manager__.get_first_player(), self.__game_manager__.get_second_player()) self.__game_manager__.get_first_player().connect_to_interface(self) self.__game_manager__.get_second_player().connect_to_interface(self) word = self.__game_manager__.get_first_word() for i in range(width): self.buttons[height//2][i].setText(word[i]) self.buttons[height//2][i].setMenu(None) self.commit_button.clicked.connect(self.on_commit_button_clicked) self.commit_give_up.clicked.connect(self.on_commit_give_up_clicked) self.__game_manager__.game_ended.connect(self.finish_game) self.quit.connect(parent.reset_field)