def __init__(self, driver): self.PATH = 'serials' self.popup_film = PopupFilm(driver) super(SerialPage, self).__init__(driver, self.popup_film.locators.root) self.infoblock_film = InfoblockFilm(self.driver) self.navbar_form = NavbarForm(self.driver) self.card = Card(self.driver) self.player = Player(self.driver) self.auth_form = AuthForm(driver)
def update_card_owned( self, card_input: Union[str, list], player_to_update: Player ) -> None: # Not to proceed further if information about the player is complete if player_to_update.all_cards_known: return card_input_as_set = utilities.input_to_set(card_input) player_to_update.add_cards_owned(card_input_as_set)
def __init__(self): # Starting screen self.is_playing = False # Generate a new player self.all_players = pygame.sprite.Group() self.player = Player(self) self.all_players.add(self.player) # Create an empty group of monsters self.all_monsters = pygame.sprite.Group() # Get pressed keys self.pressed = {}
def add_player(self, name, player_id): existing_names = [player.name for player in self.players] while name in existing_names: name = name + "!" # avoid duplicate names by adding exclamation marks player = Player(name, player_id) self.players.append(player) return name
def start_hard(self): self.clear() self.scoreObj, self.bestObj = spawn_score(self.window) update_score(self.best, self.bestObj) self.PauseObj.draw(self.window) self.Players = Player(self.window, 3) self.draw_map() self.generate_coins() self.gameLoop(JERRY_WEIGHT_HARD)
def run_game(num_of_players, stdscr): turn = 1 active_player = 0 players = [] for _ in range(num_of_players): players.append(Player()) state = GameStateUi(stdscr, players) shop = Shop() update_board(players, active_player, state, shop) # game loop while True: curses.panel.update_panels() write_message(f"\nIt's player {active_player + 1}'s turn", state) two_dice = parse_yes_no_input("Do you want to roll with two dice?", state) if players[active_player].landmarks["Train Station"][0] \ else False rolls = roll_dice(two_dice) roll = rolls[0] + rolls[1] write_message(f"Rolled: {rolls[0]}, {rolls[1]}", state) if rolls[1] else write_message(f"Rolled: {rolls[0]}", state) if players[active_player].landmarks['Radio Tower'][0]: if parse_yes_no_input("Do you want to roll again?", state): rolls = roll_dice(two_dice) roll = rolls[0] + rolls[1] write_message(f"Rolled: {rolls[0]}, {rolls[1]}", state) if rolls[1] else write_message(f"Rolled: {rolls[0]}", state) for ind in range(num_of_players): player_ind = (ind + active_player + 1) % 4 for card in players[player_ind].cards: card_obj = card() if roll in card_obj.rolls_active and (card_obj.active_on_others_turns or player_ind == active_player): for num_of_cards in range(players[player_ind].cards[card]): card_obj.on_activate(players=players, card_owner_ind=player_ind, active_player_ind=active_player, state=state) update_board(players, active_player, state, shop) parse_buy(players[active_player], state, shop) update_board(players, active_player, state, shop) if len([x for x in players[active_player].landmarks if players[active_player].landmarks[x][0]]) == 4: write_message(f"Player {active_player + 1} wins the game!", state) write_message(f"Type yes to end the game", state) while get_input(state).lower() not in ["yes", 'y']: pass break turn += 1 if not (rolls[0] == rolls[1] and players[active_player].landmarks['Amusement Park'][0]): active_player = (active_player + 1) % 4 else: write_message(f"You rolled doubles this turn and own the Amusement Park! Have another", state)
def startup(self, persistent): # pygame.mixer.music.load('assets/music/Omega.ogg') # pygame.mixer.music.set_volume(0.5) # pygame.mixer.music.play(-1, 0.0) pygame.mouse.set_visible(False) bg = parallax.ParallaxSurface((1400, 400), pygame.RLEACCEL) bg.add(BL3, 8, (WIDTH * 2, HEIGHT)) bg.add(BL2, 6, (WIDTH * 2, HEIGHT)) bg.add(BL1, 3, (WIDTH * 2, HEIGHT)) bg.add(BL0, 2, (WIDTH * 2, HEIGHT)) self.background = bg self.finished = False self.phase = 0 self.num_of_enemies = 0 self.score = 0 self.shots_fired = 0 self.streak = 1 self.misses = 0 self.mssg_group = pygame.sprite.Group() self.enemy_list = pygame.sprite.Group() self.asteroid_list = Asteroid_group() self.boss_list = pygame.sprite.Group() self.hud_items = pygame.sprite.Group() self.player_list = pygame.sprite.Group() self.player = Player(self.player_list) self.crosshair = Crosshair() self.wave1() signaly.subscribe('GAME_OVER', self.game_over, 1) signaly.subscribe('PLAYER_MSSG', self.player_mssg) super().startup(persistent)
def loadLevelPart2(self, keys, sounds): """ Terminates the level loading by defining the sprite layer, and moving the player to the spawn point. Keyword Arguments: - keys: The instance of the keyboard assignments dictionary - sounds: The instance of the sounds dictionary """ # Creates the sprite level, positions the player # and the backgrounds # v--------------------------------------------------------------v self.mod_logger.info("Starting loadLevelPart2 Routine") self.sprites = tmx.SpriteLayer() start_cell = self.tilemap.layers['Triggers'].find('playerEntrance')[0] self.tilemap.layers.append(self.sprites) self.backpos, self.middlepos, self.middlebackpos = 3*[[0, 0]] self.mod_logger.debug("Positioning Player") if self.player is not None: self.player.rect.x, self.player.rect.y = start_cell.px,\ start_cell.py else: self.player = Player((start_cell.px, start_cell.py), self.sprites, keys=keys, game=self, sounds=sounds, log=self.mainLogger) self.player.lastcheckpoint = start_cell.px, start_cell.py self.sprites.add(self.player) # ^--------------------------------------------------------------^ self.mod_logger.debug("Creating Particle Surface") # Builds the particle surface # v--------------------------------------------------------------v self.particlesurf = pygame.surface.Surface((self.tilemap.px_width, self.tilemap.px_height), pygame.SRCALPHA, 32).convert_alpha() # In case the invertedgravity glitch is up, invert gravity # And check for highjump and speed glitches # v--------------------------------------------------------------v if self.glitches["invertedGravity"]: self.gravity = -1 pl = self.player self.customGlitchToggle("highJump", pl.HiJumpOn, pl.HiJumpOff) self.customGlitchToggle("speed", pl.DoubleSpeedOn, pl.DoubleSpeedOff) self.customGlitchToggle("featherFalling", pl.FeatherFallOn, pl.FeatherFallOff) self.customGlitchToggle("highAccel", pl.HighAccel, pl.ResetAccel) self.customGlitchToggle("lowAccel", pl.LowAccel, pl.ResetAccel) self.player.RealignCollision(self.gravity) self.mod_logger.info("Loading of the level completed" + " successfully, ready to play")
class Game: def __init__(self): # Starting screen self.is_playing = False # Generate a new player self.all_players = pygame.sprite.Group() self.player = Player(self) self.all_players.add(self.player) # Create an empty group of monsters self.all_monsters = pygame.sprite.Group() # Get pressed keys self.pressed = {} def start(self): self.is_playing = True # Generate monsters when initialization self.spawn_monster() self.spawn_monster() def game_over(self): # Reset game self.all_monsters = pygame.sprite.Group() self.player.health = self.player.max_health self.is_playing = False def update(self, screen): screen.blit(self.player.image, self.player.rect) self.player.update_health_bar(screen) # Projectiles' moving for projectile in self.player.all_projectiles: projectile.move() # Monsters' moving for monster in self.all_monsters: monster.forward() monster.update_health_bar(screen) # Draw sprites on the screen self.player.all_projectiles.draw(screen) self.all_monsters.draw(screen) # Player's moving if self.pressed.get( pygame.K_RIGHT ) and self.player.rect.x + self.player.rect.width < screen.get_width(): self.player.move_right() elif self.pressed.get(pygame.K_LEFT) and self.player.rect.x > 0: self.player.move_left() def check_collision(self, sprite, group): return pygame.sprite.spritecollide(sprite, group, False, pygame.sprite.collide_mask) def spawn_monster(self): monster = Monster(self) self.all_monsters.add(monster)
def startup(self, persistent): pygame.mixer.music.load('assets/music/Omega.ogg') pygame.mixer.music.set_volume(0.5) pygame.mixer.music.play(-1, 0.0) self.phase = 0 self.num_of_enemies = 15 self.score = 0 self.shots_fired = 0 self.streak = 1 self.misses = 0 self.ammo = int(self.num_of_enemies * 100) self.enemy_list = pygame.sprite.Group() self.asteroid_list = Asteroid_group() self.bullet_list = pygame.sprite.Group() self.boss_list = pygame.sprite.Group() self.hud_items = pygame.sprite.Group() self.boss = Boss() self.player = Player() for i in range(self.num_of_enemies): enemy = Enemy() self.enemy_list.add(enemy) self.boss_list.add(self.boss) self.hud_score = Hud(570, 350, 120, 40, 'SCORE') self.hud_ammo = Hud(570, 300, 120, 40, 'AMMO') self.hud_multiplier = Hud(510, 350, 50, 40, '', 'x', True) self.hud_items.add(self.hud_score) self.hud_items.add(self.hud_ammo) self.hud_items.add(self.hud_multiplier) super().startup(persistent)
def play(self, mode: str): self.root.bind('<Escape>', self.reset_game) if mode == 'Easy': self.player1 = Player(1) self.player2 = RandomComputer(2) self.computer = True elif mode == 'Unbeatable': self.player1 = Player(1) self.player2 = SmartComputer(2) self.computer = True else: self.player1 = Player(1) self.player2 = Player(2) self.render()
def create_player(self): return Entity().add_component( Stats(5), Inventory(), Controllable(), GridMovement(C.PLAYER_WALK_RELOAD), Orientable(C.DIRECTION_O, C.PLAYER_WALK_RELOAD), Position(None, None, None), AlignedBox(-0.5, -0.5, 0.5, 0.5), Sprite({ tuple(self.load_images.obtain_entity('Player', 3)): lambda e: e.get_component(Orientable ).orientation == C.DIRECTION_N, tuple(self.load_images.obtain_entity('Player', 1)): lambda e: e.get_component(Orientable).orientation == C. DIRECTION_O, tuple(self.load_images.obtain_entity('Player', 0)): lambda e: e.get_component(Orientable ).orientation == C.DIRECTION_S, tuple(self.load_images.obtain_entity('Player', 2)): lambda e: True }), Player())
class TestPlayer(unittest.TestCase): def setUp(self) -> None: self.pl1 = Player("Test", 3) def test_all_cards_known_false(self): """All cards known is false when player is created""" self.assertFalse(self.pl1.all_cards_known) def test_all_cards_known_true(self): """All cards known is true if player is assigned all the cards""" self.pl1.cards_owned = [{"Spa"}, {"Green"}, {"Axe"}] self.assertTrue(self.pl1.all_cards_known) def test_card_not_owned_is_added(self): """Card added to not owned is stored correctly""" # Adding one card when none is present self.pl1.add_cards_not_owned({"Spa"}) self.assertEqual(self.pl1.cards_not_owned, {"Spa"}) # Adding a card when already present self.pl1.add_cards_not_owned({"Spa"}) self.assertEqual(self.pl1.cards_not_owned, {"Spa"}) # Adding two cards when none is present self.pl1.cards_not_owned = set() self.pl1.add_cards_not_owned({"Spa", "Green"}) self.assertEqual(self.pl1.cards_not_owned, {"Spa", "Green"}) # Adding one duplicate and one new self.pl1.add_cards_not_owned({"Spa", "Axe"}) self.assertEqual(self.pl1.cards_not_owned, {"Spa", "Green", "Axe"}) def test_remove_card_not_owned(self): """Card is removed from the owned ones""" # Remove an existing card self.pl1.cards_owned = [{"Spa"}, {"Spa", "Axe"}, {"Green"}] self.pl1.remove_cards_owned({"Spa"}) self.assertEqual(self.pl1.cards_owned, [set(), {"Axe"}, {"Green"}]) # Remove a non-existing card self.pl1.cards_owned = [{"Spa"}, {"Spa", "Axe"}, {"Green"}] self.pl1.remove_cards_owned({"Rope"}) self.assertEqual(self.pl1.cards_owned, [{"Spa"}, {"Spa", "Axe"}, {"Green"}]) def test_card_not_owned_is_removed_from_owned(self): """Card added to not owned is removed from the owned ones""" # Add an existing owed card to the non-owned ones self.pl1.cards_owned = [{"Spa"}, {"Spa", "Axe"}, {"Green"}] self.pl1.add_cards_not_owned({"Spa"}) self.assertEqual(self.pl1.cards_owned, [set(), {"Axe"}, {"Green"}]) # No effect if add a non-owned card to the non-owned ones self.pl1.add_cards_not_owned({"Rope"}) self.assertEqual(self.pl1.cards_owned, [set(), {"Axe"}, {"Green"}]) def test_single_card_added_to_owned(self): """Single card is correctly added to the owned ones""" # Add a single card when no card is owned self.pl1.add_cards_owned({"Spa"}) self.assertEqual(self.pl1.cards_owned, [{"Spa"}, set(), set()]) # Add a single new card when one individual card is owned self.pl1.add_cards_owned({"Green"}) self.assertEqual(self.pl1.cards_owned, [{"Spa"}, {"Green"}, set()]) # Add a single new card when a pair of cards is owned self.pl1.cards_owned = [{"Spa", "Axe"}, set(), set()] self.pl1.add_cards_owned({"Green"}) self.assertEqual( self.pl1.cards_owned, [{"Spa", "Axe"}, {"Green"}, set()]) # Add a duplicate single card when that card is owned as single self.pl1.add_cards_owned({"Green"}) self.assertEqual( self.pl1.cards_owned, [{"Spa", "Axe"}, {"Green"}, set()]) # Add a duplicate single card when that card is owned as pair self.pl1.add_cards_owned({"Spa"}) self.assertEqual(self.pl1.cards_owned, [{"Spa"}, {"Green"}, set()]) # Add a duplicate single card when that card is owned as pair twice self.pl1.cards_owned = [{"Spa", "Axe"}, {"Green"}, {"Rope", "Spa"}] self.pl1.add_cards_owned({"Spa"}) self.assertEqual(self.pl1.cards_owned, [{"Spa"}, {"Green"}, set()]) def test_multiple_cards_added_to_owned(self): """Multiple cards are correctly added to owned ones""" # Add multiple cards when no card is owned self.pl1.add_cards_owned({"Spa", "Green"}) self.assertEqual( self.pl1.cards_owned, [{"Spa", "Green"}, set(), set()]) # Add multiple new cards when a pair of cards is owned self.pl1.add_cards_owned({"Axe", "Rope"}) expected = [{"Spa", "Green"}, {"Axe", "Rope"}, set()] self.assertEqual(self.pl1.cards_owned, expected) # Add multiple new cards when one individual card is owned self.pl1.cards_owned = [{"Spa"}, set(), set()] self.pl1.add_cards_owned({"Green", "Rope"}) self.assertEqual( self.pl1.cards_owned, [{"Spa"}, {"Green", "Rope"}, set()]) # Add a duplicate pair of cards when the pair is owned self.pl1.add_cards_owned({"Green", "Rope"}) self.assertEqual( self.pl1.cards_owned, [{"Spa"}, {"Green", "Rope"}, set()]) # Add a pair of cards when one is owned as single self.pl1.add_cards_owned({"Spa", "Axe"}) self.assertEqual( self.pl1.cards_owned, [{"Spa"}, {"Green", "Rope"}, set()]) # Add three cards when two are owned as a pair self.pl1.add_cards_owned({"Green", "Rope", "Axe"}) self.assertEqual( self.pl1.cards_owned, [{"Spa"}, {"Green", "Rope"}, set()]) # Add two cards when are included in a set of three self.pl1.cards_owned = [{"Spa"}, {"Green", "Rope", "Axe"}, set()] self.pl1.add_cards_owned({"Green", "Rope"}) self.assertEqual( self.pl1.cards_owned, [{"Spa"}, {"Green", "Rope"}, set()]) def test_cards_added_to_owned_when_not_owned(self): """Not owned cards are correctly from owned cards""" # Add two cards when one of them is not owned self.pl1.cards_not_owned = {"Green"} self.pl1.add_cards_owned({"Green", "Spa"}) self.assertEqual(self.pl1.cards_owned, [{"Spa"}, set(), set()]) # Add three cards when one of them is not owned self.pl1.add_cards_owned({"Green", "Rope", "Knife"}) self.assertEqual( self.pl1.cards_owned, [{"Spa"}, {"Rope", "Knife"}, set()])
def setUp(self) -> None: self.pl1 = Player("Test", 3)
class TicTacToe(Ui): board: np.ndarray = np.zeros(shape=(3, 3)) reset_board: bool = False winner: bool = False alien_starts: bool = True alien_turns: bool = True computer: bool = False alien_score: int = 0 skeleton_score: int = 0 draw_score: int = 0 def mainloop(self): position_right = int(self.root.winfo_screenwidth() / 2 - self.board_size / 2) position_down = int(self.root.winfo_screenheight() / 2 - self.board_size / 2) self.root.geometry("+{}+{}".format(position_right, position_down)) self.root.mainloop() def play(self, mode: str): self.root.bind('<Escape>', self.reset_game) if mode == 'Easy': self.player1 = Player(1) self.player2 = RandomComputer(2) self.computer = True elif mode == 'Unbeatable': self.player1 = Player(1) self.player2 = SmartComputer(2) self.computer = True else: self.player1 = Player(1) self.player2 = Player(2) self.render() def reset_game(self, *args, **kwargs): self.root.unbind('<Button-1>') self.root.unbind('<Escape>') self.canvas.delete("all") self.__init__() super().__init__() self.board = np.zeros(shape=(3, 3)) def idx_to_coordinates(self, matrix_pos: List[int]) -> List[int]: return [ axis * (self.board_size // 3) + self.board_size // 6 for axis in matrix_pos ] def coordinates_to_idx(self, grid_position: List[int]) -> List[int]: return [axis // (self.board_size // 3) for axis in grid_position] def get_available_moves(self, board: np.ndarray) -> np.ndarray: empty_cells = np.argwhere(self.board == 0) return empty_cells def computer_move(self, empty_cells: np.ndarray): move = self.player2.get_move(empty_cells, self) self.draw_skeleton((move[1], move[0])) self.board[move[0]][move[1]] = self.player2.mark self.alien_turns = not self.alien_turns def move(self, event: tk.Event): coordinates = [event.x, event.y] matrix_pos = self.coordinates_to_idx(coordinates) if self.winner and not self.reset_board: self.reset_board = True self.display_gameover() elif not self.reset_board: if self.alien_turns: if self.board[matrix_pos[1]][matrix_pos[0]] == 0: self.draw_alien(matrix_pos) self.board[matrix_pos[1]][ matrix_pos[0]] = self.player1.mark self.alien_turns = not self.alien_turns empty_cells = self.get_available_moves(self.board) self.check_winner(self.board) if self.computer and empty_cells.any() and not self.winner: self.computer_move(empty_cells) else: if self.board[matrix_pos[1]][matrix_pos[0]] == 0: self.draw_skeleton(matrix_pos) self.board[matrix_pos[1]][ matrix_pos[0]] = self.player2.mark self.alien_turns = not self.alien_turns self.check_winner(self.board) if self.winner: self.draw_winner(self.board) else: self.canvas.delete("all") self.play_again() def check_winner(self, board: np.ndarray): for i in range(board.shape[0]): # Horizontal if np.all(board[i] == board[i][0]) and board[i][0]: self.winner = board[i][0] return board[i][0] # Vertical if np.all(board[:, i] == board[0][i]) and board[0][i]: self.winner = board[0][i] return board[0][i] # Diagonals diagonals = board.diagonal(), np.fliplr(board).diagonal() for diag in diagonals: if np.all(diag == diag[0]) and diag[0]: self.winner = diag[0] return diag[0] if np.all(self.board != 0): self.winner = 'Draw' return 'Draw' def play_again(self): self.reset_board = False self.winner = None self.alien_starts = not self.alien_starts self.alien_turns = self.alien_starts self.board = np.zeros(shape=(3, 3)) self.render() if self.alien_starts is False and self.computer: empty_cells = self.get_available_moves(self.board) self.computer_move(empty_cells)
class SerialPage(BasePage): """ Страница сериала """ def __init__(self, driver): self.PATH = 'serials' self.popup_film = PopupFilm(driver) super(SerialPage, self).__init__(driver, self.popup_film.locators.root) self.infoblock_film = InfoblockFilm(self.driver) self.navbar_form = NavbarForm(self.driver) self.card = Card(self.driver) self.player = Player(self.driver) self.auth_form = AuthForm(driver) def open_popup(self): self.popup_film.open_popup() def click_season_button(self) -> bool: return self.popup_film.click_season_if_exist() def check_season_changed(self) -> bool: return self.popup_film.check_season_changed() def click_serial_episode(self) -> bool: return self.popup_film.click_episode() def check_player_is_open(self) -> bool: return self.popup_film.check_player_is_open() def open_infoblock(self): self.infoblock_film.open_infoblock() def click_infoblock_details(self): self.infoblock_film.click_infoblock_tab_button("Детали") def check_infoblock_details_open(self) -> bool: return self.infoblock_film.check_details_clicked() def click_infoblock_seasons(self): self.infoblock_film.click_infoblock_tab_button("Сезоны") def check_infoblock_seasons_open(self) -> bool: return self.infoblock_film.check_seasons_clicked() def click_infoblock_season_button(self): self.infoblock_film.click_season_button() def check_episodes_open(self) -> bool: return self.infoblock_film.check_episodes_open() def click_episode(self): self.infoblock_film.click_episode() def check_player_open(self) -> bool: return self.infoblock_film.check_player_open() def close_infoblock(self): self.infoblock_film.click_close_button() def check_infoblock_close(self) -> bool: return self.infoblock_film.check_infoblock_closed() def open_auth_popup(self): self.navbar_form.click_login_menu() self.navbar_form.click_login_button() def auth(self, email, password): self.auth_form.set_email(email) self.auth_form.set_password(password) self.auth_form.submit() def open_card_player(self): self.card.click_player_btn() def move_to_card(self): self.card.move_to() def check_auth(self) -> bool: return self.navbar_form.check_auth_is_right() def check_player_appearance(self) -> bool: return self.player.check_appearance() def check_switch_next_episode(self) -> bool: self.player.move_to_player_bar() self.player.click_on_next_ep_btn() return self.player.check_next_ep() def check_switch_prev_episode(self) -> bool: self.player.move_to_player_bar() self.player.click_on_next_ep_btn() self.player.click_on_prev_ep_btn() return self.player.check_prev_ep()
def parse_buy(active_player: Player, state: GameStateUi, shop: Shop): establishments = ["Wheat Field", "Ranch", "Bakery", "Cafe", "Convenience Store", "Forest", "Stadium", "TV Station", "Business Center", "Cheese Factory", "Furniture Factory", "Mine", "Family Restaurant", "Apple Orchard", "Fruit And Vegetable Market"] bought_purples = [x for x in ["Stadium", "TV Station", "Business Center"] if active_player.cards[type(establishment_str_to_obj(x.lower()))]] valid_establishments = [] for establishment in establishments: card_obj = establishment_str_to_obj(establishment.lower()) # establishments with inventory left in the shop if shop.inventory[type(card_obj)] and establishment not in bought_purples: if active_player.wallet >= card_obj.cost: valid_establishments.append(establishment) valid_landmarks = [] for landmark in active_player.landmarks: if active_player.landmarks[landmark][0] and active_player.wallet >= active_player.landmarks[landmark][1]: valid_landmarks.append(landmark) options = ["Nothing"] + valid_establishments + valid_landmarks while True: write_message("What establishment or landmark do you want to buy?", state) write_message(f"Your options are: {', '.join(options)}", state) choice = get_input(state) if choice.lower() in "nothing": write_message(f"Choosing not to buy an establishment", state) break elif choice.lower() in [x.lower() for x in valid_establishments]: chosen_establishment = establishment_str_to_obj(choice.lower()) if active_player.wallet >= chosen_establishment.cost: if shop.inventory[type(chosen_establishment)] > 0: if not active_player.cards[type(chosen_establishment)] or chosen_establishment.symbol != "tower": write_message(f"Buying establishment: {chosen_establishment.name} for {chosen_establishment.cost} coins ", state) active_player.wallet -= chosen_establishment.cost active_player.cards[type(chosen_establishment)] += 1 shop.inventory[type(chosen_establishment)] -= 1 break else: write_message(f"You already have a {chosen_establishment.name()}, choose a different establishment or landmark", state) else: write_message(f"There aren't any {chosen_establishment.name}'s left in the shop", state) else: write_message(f"Not enough money to buy a {choice}, please choose a different establishment or landmark", state) elif choice.lower() in [x.lower() for x in valid_landmarks]: # find the capitalised name for landmark in valid_landmarks: if choice.lower() == landmark.lower(): chosen_landmark = landmark if active_player.wallet >= active_player.landmarks[chosen_landmark][1]: write_message(f"Buying landmark: {chosen_landmark} for {active_player.landmarks[chosen_landmark][1]} coins ", state) active_player.wallet -= active_player.landmarks[chosen_landmark][1] active_player.landmarks[chosen_landmark] = (True, active_player.landmarks[chosen_landmark][1]) break else: write_message(f"Not enough money to buy {chosen_landmark}, please choose a different establishment or landmark", state) else: write_message(f"Please respond with an establishment or landmark in the list", state)
from constants import Constants constants = Constants() # initialize pygame pygame.init() # creating screen of width 800 and height 600 screen = pygame.display.set_mode((800, 600)) # game status running = True # background background = pygame.image.load(constants.background) # score score_value = 0 # player player = Player(screen=screen) # enemy invader/s enemies = Enemies(screen=screen, number_of_enemies=6) enemies.init_enemies() # bullet bullet = Bullet(screen=screen) # mechanics mechanics = Mechanics() def set_defaults(): # background music mixer.music.load(constants.background_music) mixer.music.play(-1)
def init_new_game(self, params): choice = params self.player = None self.levels = None self.time_counter = None # Create player inventory_component = Inventory(26) f_data = self.data.fighters["player"] fighter_component = Fighter(hp=f_data["hp"], ac=f_data["ac"], ev=f_data["ev"], power=f_data["power"], mv_spd=f_data["mv_spd"], atk_spd=f_data["atk_spd"], size=f_data["size"], fov=f_data["fov"]) light_component = LightSource(radius=fighter_component.fov) player_component = Player(50) abilities_component = Abilities("player") status_effects_component = StatusEffects("player") summoner_component = Summoner() player = Entity(1, 1, 3, player_component.char["player"], "default", "player", blocks=True, player=player_component, fighter=fighter_component, inventory=inventory_component, light_source=light_component, summoner=summoner_component, indicator_color="gray", abilities=abilities_component, status_effects=status_effects_component, stand_on_messages=False) player.player.avatar["player"] = fighter_component avatar_f_data = self.data.fighters[choice] a_fighter_component = Fighter(hp=avatar_f_data["hp"], ac=avatar_f_data["ac"], ev=avatar_f_data["ev"], power=avatar_f_data["power"], mv_spd=avatar_f_data["mv_spd"], atk_spd=avatar_f_data["atk_spd"], size=avatar_f_data["size"], fov=avatar_f_data["fov"]) player.player.avatar[choice] = a_fighter_component player.player.avatar[choice].owner = player player.abilities.initialize_abilities(choice) player.player.char[choice] = tilemap()["monsters"][choice] player.player.char_exp[choice] = 20 player.player.avatar[choice].max_hp += 20 player.player.avatar[choice].hp += 20 player.player.avatar[choice].power += 1 player.player.insights = 200 self.player = player character_menu = MenuData(name="avatar_info", params=self.player) self.menus.create_or_show_menu(character_menu) message_log = MessageLog(4) self.message_log = message_log self.message_log.owner = self # Initialize game camera game_camera = Camera(1, 1, self.ui.viewport.w, self.ui.viewport.h, self.options) self.game_camera = game_camera self.game_camera.owner = self levels = Levels(tileset=self.options.gfx) self.levels = levels self.levels.owner = self blt.clear_area(2, self.ui.viewport.offset_h + self.ui.offset_y + 1, self.ui.viewport.x, 1) # if settings.gfx == "ascii": # player.char = tilemap()["player"] # player.color = "lightest green" self.levels.change("hub") self.fov_recompute = True self.game_state = GameStates.PLAYER_TURN self.time_counter = self.TimeCounter(owner=self)
def __init__(self, num_players): self.table = Table( players=[Player(player_id=i) for i in range(num_players)])
class Level1(GameState): def __init__(self): super().__init__() self.scores = scores self.next_state = 'START' def startup(self, persistent): # pygame.mixer.music.load('assets/music/Omega.ogg') # pygame.mixer.music.set_volume(0.5) # pygame.mixer.music.play(-1, 0.0) pygame.mouse.set_visible(False) bg = parallax.ParallaxSurface((1400, 400), pygame.RLEACCEL) bg.add(BL3, 8, (WIDTH * 2, HEIGHT)) bg.add(BL2, 6, (WIDTH * 2, HEIGHT)) bg.add(BL1, 3, (WIDTH * 2, HEIGHT)) bg.add(BL0, 2, (WIDTH * 2, HEIGHT)) self.background = bg self.finished = False self.phase = 0 self.num_of_enemies = 0 self.score = 0 self.shots_fired = 0 self.streak = 1 self.misses = 0 self.mssg_group = pygame.sprite.Group() self.enemy_list = pygame.sprite.Group() self.asteroid_list = Asteroid_group() self.boss_list = pygame.sprite.Group() self.hud_items = pygame.sprite.Group() self.player_list = pygame.sprite.Group() self.player = Player(self.player_list) self.crosshair = Crosshair() self.wave1() signaly.subscribe('GAME_OVER', self.game_over, 1) signaly.subscribe('PLAYER_MSSG', self.player_mssg) super().startup(persistent) def get_event(self, event): if event.type == pygame.QUIT: pygame.mixer.music.stop() self.done = True pygame.quit() quit() self.player.get_event(event, enemy_list=self.enemy_list, boss_list=self.boss_list, shots_fired=self.shots_fired, done=self.done) def game_over(self): print('game over') FallingMssg('DEFEATED BY HEDGELORD', (255, 255, 255, 255), self.end, ((WIDTH / 2), -10), 30, self.mssg_group) def player_mssg(self, mssg): # amt = str(amount).replace('0', '', 1) OnScreenDmg('+{}'.format(mssg), (0, 135, 236, 200), self.player.rect.center, 17, self.mssg_group) def end(self): self.done = True def bullet_mechanics(self, multiplier): # --- calculate mechanics for each bullet pos = (self.player.rect.center[0] - 2, self.player.rect.center[1] + 2) self.player.weapon.fire(pos) self.shots_fired += 1 for boss in self.boss_list: for bullet in boss.bullets: enemy_bullet_player_hit_list = pygame.sprite.spritecollide( bullet, self.player_list, False, pygame.sprite.collide_mask) if enemy_bullet_player_hit_list: self.player.collision_detected(1) if not self.player.dying: OnScreenDmg('{}'.format('HIT'), (255, 255, 255, 200), bullet.rect.center, 25, self.mssg_group) if self.player.hp <= 0: pygame.mixer.music.fadeout(1000) # message_display('YOU LOOSE HIT BY BULLET!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.player.explode() if not self.player.hp <= 0: bullet.kill() for bullet in self.player.weapon.bullets: # see if bullet hit a enemy enemy_hit_list = pygame.sprite.spritecollide( bullet, self.enemy_list, False) # see if asteroid hit ship asteroid_hit_list = pygame.sprite.spritecollide( bullet, self.asteroid_list, False) boss_hit_list = pygame.sprite.spritecollide( bullet, self.boss_list, False, pygame.sprite.collide_mask) for boss in boss_hit_list: if not boss.hit: crit_roll = random.randint(1, 101) will_crit = crit_roll > 96 if will_crit: dmg = 5 * floor(random.randint(1.0, 5.0)) OnScreenDmg('{}'.format(dmg), (255, 31, 31, 230), bullet.rect.center, 25, self.mssg_group) else: dmg = 5 OnScreenDmg('{}'.format(dmg), (255, 51, 51, 175), bullet.rect.center, 20, self.mssg_group) boss.hp -= dmg boss.collision_detected() bullet.kill() if boss.hp <= 0: self.score += (150 * multiplier) boss.explode() for asteroid in asteroid_hit_list: asteroid.hp -= 3 if asteroid.hp <= 0: self.score += 20 bullet.kill() # for each enemy hit, remove the bullet and add to the score for enemy in enemy_hit_list: if not enemy.hit: bullet.kill() self.score += (1 * multiplier) self.streak += 1 enemy.explode() # remove the bullet if it flies up off the screen if bullet.rect.y < -50: self.streak = 0 self.misses += 1 def player_collisions(self): # --- handle collisions player_hit_list = pygame.sprite.spritecollide( self.player, self.asteroid_list, False, pygame.sprite.collide_mask) if player_hit_list: pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE HIT BY ASTEROID!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True player_enemy_hit_list = pygame.sprite.spritecollide( self.player, self.enemy_list, False, pygame.sprite.collide_mask) if player_enemy_hit_list: for enemy in player_enemy_hit_list: if not enemy.hit: pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE HIT BY ENEMY!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True player_boss_hit_list = pygame.sprite.spritecollide( self.player, self.boss_list, False, pygame.sprite.collide_mask) if player_boss_hit_list: for boss in player_boss_hit_list: if not boss.hit: pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE HIT BY ENEMY!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True def check_game_over(self, total_score): # checking enemy list is empty ensures that the last explode() has completed # before ending game;) if not self.enemy_list and not self.boss_list: if self.phase == 0: self.phase = 1 Boss((200, -70), self.boss_list) return if not self.finished: print('winner', self.shots_fired, self.score, total_score) pygame.mixer.music.fadeout(1000) if total_score > self.scores.top_score: self.scores.update_ts(total_score) if self.player.weapon.ammo == 0: FallingMssg( 'CLOSE ONE, YOU WIN!! score: {}'.format( str(total_score)), (255, 255, 255, 255), self.end, ((WIDTH / 2), -10), 30, self.mssg_group) else: FallingMssg( 'YOU DESTOYED HEDGELORD'.format(str(total_score)), (255, 255, 255, 255), self.end, ((WIDTH / 2), -10), 30, self.mssg_group) self.finished = True def wave1(self): for i in range(self.num_of_enemies): Enemy(self.enemy_list) def update(self, dt): multiplier = int(self.streak / 2) or 1 total_score = int(self.score * 100) or 0 # self.hud_ammo.prop = self.player.weapon.ammo # self.hud_score.prop = total_score # self.hud_multiplier.prop = multiplier self.check_game_over(total_score) # call the update method on all the sprites self.player.update(dt) self.mssg_group.update(dt) self.crosshair.update() self.boss_list.update(dt, self.player.rect.center) self.enemy_list.update(dt, self.player.rect.center) self.asteroid_list.update() self.hud_items.update() self.player_collisions() self.bullet_mechanics(multiplier) def draw(self, surface): surface.fill(WHITE) # surface.blit(self.background.image, self.background.rect) # direction = -1 if self.player.vel[0] < 0 else 1 self.background.scroll(self.player.vel[0] / 28) self.background.draw(surface) self.hud_items.draw(surface) self.mssg_group.draw(surface) self.asteroid_list.draw(surface) self.enemy_list.draw(surface) self.boss_list.draw(surface) for boss in self.boss_list: boss.bullets.draw(surface) boss.health_bar.draw(surface) self.player.weapon.bullets.draw(surface) self.player.health_bar.draw(surface) self.crosshair.draw(surface) self.player.draw(surface)
def main(): # hardware acceleration to reduce flickering. Works only in full screen flags = DOUBLEBUF | HWSURFACE | FULLSCREEN screen = pg.display.set_mode(WINDOW_SIZE, flags) # Display until loading finishes. screen.fill(COLORS["BLACK"]) _render = FONTS["GAMEOVER"].render("LOADING...", 0, pg.Color("white")) SCREEN_RECT = pg.Rect((0, 0), WINDOW_SIZE) screen.blit(_render, _render.get_rect(center=SCREEN_RECT.center)) pg.display.set_caption("QPong") # clock for timing clock = pg.time.Clock() old_clock = pg.time.get_ticks() # initialize scene, level and input Classes scene = Scene(QUBIT_NUM) # players players = [] input = Input() # define ball ball = Ball() balls = (pg.sprite.Group() ) # sprite group type is needed for sprite collide function in pg balls.add(ball) # Show start screen to select difficulty input.running = scene.mode(screen) # start screen returns running flag if not input.running: pg.quit() return input.running = scene.difficulty( screen, ball) # start mode selections returns flag if not input.running: pg.quit() return if scene.game_mode == MODES["ONE_PLAYER"]: players += [ Player(QUBIT_NUM, POSITIONS["RIGHT"], QUANTUM_COMPUTER_1P, scene.game_mode) ] players += [ Player(QUBIT_NUM, POSITIONS["LEFT"], CLASSICAL_COMPUTER, scene.game_mode) ] elif scene.game_mode == MODES["TWO_PLAYER"]: players += [ Player(QUBIT_NUM, POSITIONS["RIGHT"], QUANTUM_COMPUTER_1P, scene.game_mode) ] players += [ Player(QUBIT_NUM, POSITIONS["LEFT"], QUANTUM_COMPUTER_2P, scene.game_mode) ] # Put all moving sprites a group so that they can be drawn together moving_sprites = pg.sprite.Group() moving_sprites.add(ball) for player in players: moving_sprites.add(player.paddle) # update the screen pg.display.flip() # reset the ball ball.reset() # a valuable to record the time when the paddle is measured measure_time = 100000 # Main Loop while input.running: # set maximum frame rate clock.tick(60) # refill whole screen with black color at each frame screen.fill(COLORS["BLACK"]) ball.update() # update ball position scene.dashed_line( screen) # draw dashed line in the middle of the screen scene.score(players, screen) # print score for _, player in enumerate(players): if player.player_type in (QUANTUM_COMPUTER_1P, QUANTUM_COMPUTER_2P): player.statevector.draw( screen) # draw right paddle together with statevector grid player.circuit_grid.draw(screen) # draw circuit grid moving_sprites.draw(screen) # draw moving sprites # Show game over screen if the score reaches WIN_SCORE, reset everything if replay == TRUE if player.score >= WIN_SCORE: input.running = scene.gameover(screen, player.player_type) scene.replay(screen, players) player.update_paddle(screen) if player.score >= WIN_SCORE: input.running = scene.gameover(screen, player.player_type) scene.replay(screen, players) player.update_paddle(screen) # computer paddle movement if scene.game_mode == MODES["ONE_PLAYER"]: cpu_player = next( filter(lambda p: p.player_type == CLASSICAL_COMPUTER, players)) qcpu_player = next( filter( lambda p: p.player_type in (QUANTUM_COMPUTER_1P, QUANTUM_COMPUTER_2P), players, )) if cpu_player: if pg.time.get_ticks() - old_clock > 300: cpu_player.paddle.rect.y = ( ball.y - qcpu_player.statevector_grid.block_size / 2 + random.randint(-WIDTH_UNIT * 4, WIDTH_UNIT * 4)) old_clock = pg.time.get_ticks() # handle input events input.handle_input(players, screen) # check ball location and decide what to do ball.action(players) if ball.ball_action == BALL_ACTIONS["MEASURE_RIGHT"]: circuit = qcpu_player.circuit_grid_model.compute_circuit() pos = qcpu_player.statevector_grid.paddle_after_measurement( qcpu_player.position, circuit, QUBIT_NUM, 1) qcpu_player.statevector.arrange() # paddle after measurement qcpu_player.paddle.rect.y = (pos * round(WINDOW_HEIGHT * 0.7) / (2**QUBIT_NUM)) measure_time = pg.time.get_ticks() if pg.sprite.spritecollide(qcpu_player.paddle, balls, False): ball.bounce_edge() if pg.sprite.spritecollide(cpu_player.paddle, balls, False): ball.bounce_edge() if pg.time.get_ticks() - measure_time > 400: # refresh the screen a moment after measurement to update visual qcpu_player.update_paddle(screen) # add a buffer time before measure again measure_time = pg.time.get_ticks() + 100000 elif scene.game_mode == MODES["TWO_PLAYER"]: # handle input events input.handle_input(players, screen) # check ball location and decide what to do ball.action(players) if ball.ball_action == BALL_ACTIONS["MEASURE_RIGHT"]: circuit = players[0].circuit_grid_model.compute_circuit() pos = players[0].statevector_grid.paddle_after_measurement( players[0].position, circuit, QUBIT_NUM, 1) players[0].statevector.arrange() # paddle after measurement players[0].paddle.rect.y = (pos * round(WINDOW_HEIGHT * 0.7) / (2**QUBIT_NUM)) measure_time = pg.time.get_ticks() if ball.ball_action == BALL_ACTIONS["MEASURE_LEFT"]: circuit = players[1].circuit_grid_model.compute_circuit() pos = players[1].statevector_grid.paddle_after_measurement( players[1].position, circuit, QUBIT_NUM, 1) players[1].statevector.arrange() # paddle after measurement players[1].paddle.rect.y = (pos * round(WINDOW_HEIGHT * 0.7) / (2**QUBIT_NUM)) measure_time = pg.time.get_ticks() if pg.sprite.spritecollide(players[0].paddle, balls, False): ball.bounce_edge() if pg.sprite.spritecollide(players[1].paddle, balls, False): ball.bounce_edge() if pg.time.get_ticks() - measure_time > 400: # refresh the screen a moment after measurement to update visual players[0].update_paddle(screen) players[1].update_paddle(screen) # add a buffer time before measure again measure_time = pg.time.get_ticks() + 100000 # Update the screen if input.running: pg.display.flip() pg.quit()
class Game(object): def customGlitchToggle(self, glitchname, trueFunction, falseFunction): """ Toggles glitches via a custom function by checking the self.glitches list Keyword Parameters: - glitchname: Name of the glitch to toggle - trueFunction: Function to be executed when enabling the glitch - falseFunction: Function to be executed when disabling the glitch """ if self.glitches[glitchname]: trueFunction() else: falseFunction() def changeGravity(self): """Inverts gravity""" self.gravity *= -1 def toggleGlitch(self, glitch, garble): """ Debug method for toggling glitches Works only with glitches in the "Glitches" dictionary Keyword Arguments: - Glitch: String key which identifies the glitch to toggle - Garble: Allows to enable a "static" effect on toggle """ # Inverts the status of the glitch # v--------------------------------------------------v self.glitches[glitch] = not self.glitches[glitch] self.mod_logger.debug("{0} Glitch has been set to {1}".format( glitch, self.glitches[glitch])) # ^--------------------------------------------------^ # Does a custom toggle of Highjump, speed, and inverted gravity glitch # v--------------------------------------------------v pl = self.player self.customGlitchToggle("highJump", pl.HiJumpOn, pl.HiJumpOff) self.customGlitchToggle("speed", pl.DoubleSpeedOn, pl.DoubleSpeedOff) self.customGlitchToggle("featherFalling", pl.FeatherFallOn, pl.FeatherFallOff) self.customGlitchToggle("highAccel", pl.HighAccel, pl.ResetAccel) self.customGlitchToggle("lowAccel", pl.LowAccel, pl.ResetAccel) if glitch == "invertedGravity": self.changeGravity() # ^--------------------------------------------------^ # Plays static # v--------------------------------------------------v if garble: self.garble = True self.sounds["sfx"]["static"].play() # ^--------------------------------------------------^ def generatePath(self, campaignname, level): """ Generates a level path from the campaign Name and its level name Keyword Arguments: - campaignname: Name of the campaign - level: Name of the level """ self.gameStatus["currentLevel"] = level return pjoin("data", "maps", campaignname, level) def showLoadingScreen(self): self.screen.fill((0, 0, 0)) self.screen.blit(self.loadWriting, (50, 50)) pygame.display.update() def RealLoadLevel(self, path, mode, screen): """ Loads a level structure, given path, mode and screen Keyword Arguments: - path: Full path to the level - mode: Mode to open the level in - screen: The screen instance """ self.mod_logger.info("LoadLevel Routine is loading %(path)s" % locals()) # Erases level and if we're doing a campaign, checks for intermissions # v--------------------------------------------------v self.eraseCurrentLevel() self.showLoadingScreen() if mode not in ["singlemap"]: self.checkIntermission() # ^--------------------------------------------------^ self.showLoadingScreen() # Loads the level configuration and its chaos parameters # v--------------------------------------------------v with open(path+".json") as f: levelconfig = json.loads(f.read()) self.mod_logger.debug("Level configuration loaded") self.loadChaosParameters(levelconfig) # ^--------------------------------------------------^ # If we're in the single timer Critical Failure, load the level time # And reset the time to 0. # v--------------------------------------------------v if mode == "cfsingle": self.gameStatus["cftime"] = levelconfig["Level Info"]["CFTime"] self.gameStatus["time"] = 0. # ^--------------------------------------------------^ # Loads the level glitches # v--------------------------------------------------v self.glitches = levelconfig["Glitches"]["Standard"] self.mod_logger.debug("Glitches Active: {0}".format(self.glitches)) # ^--------------------------------------------------------------^ # Loads the level map # v--------------------------------------------------------------v self.mod_logger.debug("Loading Tilemap") self.tilemap = tmx.load(path+".tmx", self.screensize) self.mod_logger.debug("Tilemap Loaded, building map") # ^--------------------------------------------------------------^ # Loads backgrounds and overlays, optimised in case # the same ones are used # v--------------------------------------------------------------v self.mod_logger.debug("Loading Backgrounds") self.oldComponentPaths = self.componentPaths.copy() for key in self.componentPaths.keys(): self.componentPaths[key] = pjoin("resources", "backgrounds", levelconfig["Level Components"] [key]) if self.componentPaths[key] != self.oldComponentPaths[key]: self.components[key] = pygame.image.load( self.componentPaths[key]).convert_alpha() self.hasOverlay = levelconfig["Level Components"]["overlay"]\ is not None if self.hasOverlay: self.overpath = pjoin("resources", "overlays", levelconfig["Level Components"] ["overlay"]) if self.overpath != self.oldoverpath: self.overlay = pygame.image.load(self.overpath).convert_alpha() # ^--------------------------------------------------------------^ # Creates all the mobile obstacles # v--------------------------------------------------------------v self.obstacles = tmx.SpriteLayer() for obstacle in self.tilemap.layers['Triggers'].find('Obstacle'): Obstacle((obstacle.px, obstacle.py), ("v" in obstacle['Obstacle']), obstacle['ObsSpeed'], None, self.obstacles, preloaded_ani=self.preloaded_sprites["glitches"]) self.tilemap.layers.append(self.obstacles) # ^--------------------------------------------------------------^ # Creates all the triggerable platforms # v--------------------------------------------------------------v for platform in self.tilemap.layers['Triggers'].find('Platform'): bouncy = "bouncyplat" in platform bouncepwr = int(platform['bouncyplat']) if bouncy else 0 TriggerablePlatform( platform.px, platform.py, ("v" in platform['Platform']), bouncepwr, int(platform['PlatSpeed']), int(platform['PlatSize']), False, platform['id'], self.plats, game=self, bouncy=bouncy, image=self.preloaded_sprites["platforms"]) self.tilemap.layers.append(self.plats) # Creates all the lasers # v--------------------------------------------------------------v self.lasers = tmx.SpriteLayer() for laser in self.tilemap.layers['Triggers'].find('Laser'): time = laser['Laser'] number = 0 if 'id' in laser: number = laser['id'] size = (laser.width, laser.height) vertical = size[1] > size[0] definingsize = size[1] if vertical else size[0] Laser(definingsize, vertical, time, number, (laser.px, laser.py), self.lasers) self.tilemap.layers.append(self.lasers) # ^--------------------------------------------------------------^ # Creates all the buttons # v--------------------------------------------------------------v self.btns = tmx.SpriteLayer() for btn in self.tilemap.layers['Triggers'].find('button'): ident = btn['button'] password = None msg="" if "password" in btn: password = btn["password"] if "message" in btn: msg = btn["message"] button((btn.px, btn.py), ident, password, self.btns, message=msg) self.tilemap.layers.append(self.btns) # ^--------------------------------------------------------------^ # Creates all the checkpoints # v--------------------------------------------------------------v self.checkpoints = tmx.SpriteLayer() for chk in self.tilemap.layers["Triggers"].find('CheckPoint'): checkPoint((chk.px, chk.py), self.checkpoints) self.tilemap.layers.append(self.checkpoints) # ^--------------------------------------------------------------^ # Creates all the glitch toggles # v--------------------------------------------------------------v for trig in self.tilemap.layers['Triggers'].find('ToggleGlitch'): if "message" in trig: msg = trig["message"] else: msg = "" self.GlitchTriggers.add(CollectibleTrigger( trig.px, trig.py, self, trig['ToggleGlitch'], preloaded_animation=self.preloaded_sprites[ "collectibleitem" ], message=msg)) self.tilemap.layers.append(self.GlitchTriggers) # ^--------------------------------------------------------------^ # In case of critical failure modes, further garbles # level title texts, then renders the title # v--------------------------------------------------------------v if self.gameStatus["mode"] in ["criticalfailure", "cfsingle"]: self.titletxt = makeMoreGlitched( str(levelconfig['Level Info']['Name']), 50) else: self.titletxt = str(levelconfig['Level Info']['Name']) self.title = makeGlitched(self.titletxt, self.font) # ^--------------------------------------------------------------^ # Finds the center position of the title # v--------------------------------------------------------------v center = (self.screensize[0] - int(self.title.get_rect().width))/2 self.titleposition = (center, self.gsize[1] + 2) # ^--------------------------------------------------------------^ self.mod_logger.info("Map Loaded and built Successfully") # ^--------------------------------------------------------------^ if self.config["General"]["autosaving"] and self.SaveFile: self.mod_logger.debug("Saved with data: {0}" % self.gameStatus) with open(self.SaveFile, "w") as savefile: savefile.write(json.dumps(self.gameStatus)) """self.mod_logger.info("Game autosaved on the file: {0}" % (self.SaveFile))""" message = levelconfig["Message"] if message != "": self.showMessage = True self.messageSurf = animatedText(message) def LoadLevel(self, level, campaignname, mode, screen): """ Check if the level exists and loads it Keyword Arguments: - level: The level name, without the file extension. - campaignname: The campaign name - mode: The game mode - screen: The surface to draw the level to """ if not level: # No more levels, close if ":CampaignEnd:" in self.gameStatus["intermissions"]: self.startIntermission( self.gameStatus["intermissions"][":CampaignEnd:"]) pygame.mouse.set_visible(True) self.running = False else: lvl = self.generatePath(campaignname, level) self.RealLoadLevel(lvl, mode, screen) def loadCampaign(self, campaignfile, mode): """ Loads the levels of the campaign defined in the argument Keyword Arguments: - campaignFile: The file (Without extension) defining the campaign - mode: The game mode """ self.mod_logger.info("Loading campaign {0}".format(campaignfile)) with open(campaignfile, "r") as campfile: cmpf = json.loads(campfile.read()) self.gameStatus["currentLevel"] = cmpf["FirstMap"] self.gameStatus["intermissions"] = cmpf["Intermissions"] if mode == "criticalfailure": self.gameStatus["cftime"] = cmpf["CFTime"] def startIntermission(self, ID): """Starts an comicReader intermission instance Keyword Arguments: - ID: The intermission Identifier """ IM = comicReader(pjoin("resources", "intermissions", self.gameStatus["campaignName"], ID), self.screen, self.keys["action"], self.mainLogger) IM.look() def checkIntermission(self): """ Checks if in the current level that is about to load there is an intermission to be played """ if self.gameStatus["currentLevel"] in\ self.gameStatus["intermissions"].keys(): self.mod_logger.debug("Intermission found, starting intermission") self.startIntermission( self.gameStatus[ "intermissions"][self.gameStatus["currentLevel"]]) def eraseCurrentLevel(self): # At first call, does nothing (Player still has to be created) # Self-remaps at runtime to the stage deleting function self.eraseCurrentLevel = self.eraseCurrentLevel_Post def eraseCurrentLevel_Post(self): """ Erases the whole level, tilemap, memorises the player and prepares for a new load """ self.gravity = 1 self.titletxt = None self.tilemap = None self.player.x_speed, self.player.y_speed = 0, 0 self.plats.empty() self.GlitchTriggers.empty() self.sprites.empty() self.btns.empty() def loadLevelPart2(self, keys, sounds): """ Terminates the level loading by defining the sprite layer, and moving the player to the spawn point. Keyword Arguments: - keys: The instance of the keyboard assignments dictionary - sounds: The instance of the sounds dictionary """ # Creates the sprite level, positions the player # and the backgrounds # v--------------------------------------------------------------v self.mod_logger.info("Starting loadLevelPart2 Routine") self.sprites = tmx.SpriteLayer() start_cell = self.tilemap.layers['Triggers'].find('playerEntrance')[0] self.tilemap.layers.append(self.sprites) self.backpos, self.middlepos, self.middlebackpos = 3*[[0, 0]] self.mod_logger.debug("Positioning Player") if self.player is not None: self.player.rect.x, self.player.rect.y = start_cell.px,\ start_cell.py else: self.player = Player((start_cell.px, start_cell.py), self.sprites, keys=keys, game=self, sounds=sounds, log=self.mainLogger) self.player.lastcheckpoint = start_cell.px, start_cell.py self.sprites.add(self.player) # ^--------------------------------------------------------------^ self.mod_logger.debug("Creating Particle Surface") # Builds the particle surface # v--------------------------------------------------------------v self.particlesurf = pygame.surface.Surface((self.tilemap.px_width, self.tilemap.px_height), pygame.SRCALPHA, 32).convert_alpha() # In case the invertedgravity glitch is up, invert gravity # And check for highjump and speed glitches # v--------------------------------------------------------------v if self.glitches["invertedGravity"]: self.gravity = -1 pl = self.player self.customGlitchToggle("highJump", pl.HiJumpOn, pl.HiJumpOff) self.customGlitchToggle("speed", pl.DoubleSpeedOn, pl.DoubleSpeedOff) self.customGlitchToggle("featherFalling", pl.FeatherFallOn, pl.FeatherFallOff) self.customGlitchToggle("highAccel", pl.HighAccel, pl.ResetAccel) self.customGlitchToggle("lowAccel", pl.LowAccel, pl.ResetAccel) self.player.RealignCollision(self.gravity) self.mod_logger.info("Loading of the level completed" + " successfully, ready to play") # ^--------------------------------------------------------------^ def loadGame(self, path=None): """ Opens the game from a JSON file """ self.mod_logger.info("Loading Save from: %(path)s" % locals()) if self.config["General"]["autosaving"]: self.SaveFile = path with open(path, "r") as savefile: self.gameStatus = json.loads(savefile.read()) if self.gameStatus["mode"] in ["criticalfailure", "cfsingle"]: self.mod_logger.debug("Using Load Game mode -\ Critical Failure Modifier") self.redsurf = pygame.surface.Surface(self.gsize, pygame.SRCALPHA) linesize = 3 bot = self.redsurf.get_rect().bottom self.redsurf.fill((255, 0, 0, 50)) self.redsurf.fill((255, 255, 255, 255), pygame.rect.Rect(0, bot - linesize, self.gsize[0], linesize)) self.redsurfrect = self.redsurf.get_rect() def newChaosTime(self): """ Generates a new timer to countdown to a new random glitch toggle""" self.chaosParameters["timer"] = float(randint(5, 20)) def loadChaosParameters(self, lvlconf): """ Loads the chaos mode glitches from a level config instance Keyword Parameters: - lvlconf: The level config instance """ self.chaosParameters = {"glitches": None, "timer": None} self.chaosParameters["glitches"] = \ [x for x in lvlconf["Glitches"]["ChaosMode"] if lvlconf["Glitches"]["ChaosMode"][x]] self.newChaosTime() self.mod_logger.debug("Chaos Mode Parameters: {0}".format( self.chaosParameters)) def forceNextLevel(self): """ DEBUG METHOD Used to jump to the first playerexit level found """ return self.tilemap.layers["Triggers"].find( "playerExit")[0]["playerExit"] def givePosition(self, op, fact): """ Returns the viewport position, scaled by a certain factor, according to a certain operation Keyword Arguments: - op: Operation to perform (usually __mul__ or __floordiv__) - fact: Scaling factor """ return (min(op(-self.tilemap.viewport.x, fact), 0), min(op(-self.tilemap.viewport.y, fact), 0)) def main(self, screen, keys, mode, cmp, config, sounds, modifiers, log): """ Main Game method Keyword Arguments: - Screen: The surface to draw the game to. - keys: The control keys to use. - Mode: Identifies the mode of the game (newgame, load, singlemap, criticalfailure, cfsingle) - cmp: campaign file - config: Game configuration instance - sounds: Sounds dictionary instance - modifiers: Modifiers Dictionary instance - log: The main logger, inherited by the bootstrapper """ self.showMessage = False self.messageTime = _defaultMessageTime_ self.messageSurf = None self.SaveFile = None self.showCollision = False self.activeHelpList = [] self.gameStatus = { "campaignFile": None, "campaignName": None, "mode": mode, "cftime": None, "time": 0., "deathCounter": 0, "modifiers": modifiers, "currentLevel": None } self.oldComponentPaths = { "background": None, "middle_back1": None, "middle_back2": None } self.componentPaths = { "background": None, "middle_back1": None, "middle_back2": None } self.components = { "background": None, "middle_back1": None, "middle_back2": None } self.oldoverpath = None self.mainLogger = log self.mod_logger = log.getChild("game") self.mod_logger.info("Entering main game") self.running = True self.showFPS = False self.titletxt = None self.gravity = 1 self.sounds = sounds self.screensize = screen.get_size() self.gsize = (screen.get_width(), screen.get_height() - 24) self.gameviewport = pygame.surface.Surface(self.gsize) self.clock = pygame.time.Clock() self.titleholder = pygame.image.load(pjoin( "resources", "UI", "TitleHolder.png")) self.font = pygame.font.Font(pjoin( "resources", "fonts", "TranscendsGames.otf"), 20) self.loadWriting = self.font.render("Loading...", False, (255, 255, 255)) self.title, self.titleposition, self.player = 3 * [None] self.screen = screen self.keys = keys self.config = config self.helptxts = pygame.sprite.Group() self.plats = tmx.SpriteLayer() self.GlitchTriggers = tmx.SpriteLayer() self.mod_logger.debug("Current Active Modifiers: {0}".format( modifiers)) # Preloading graphics area # v-------------------------------------------------------------------v self.preloaded_sprites = { "platforms": pygame.image.load(pathjoin("resources", "tiles", "Plats.png") ).convert_alpha(), "glitches": pathjoin("resources", "sprites", "MobileObstacle.png"), "collectibleitem": pathjoin("resources", "sprites", "GlitchTrigger.png" ), "static": pygame.image.load(pathjoin("resources", "backgrounds", "screengarble.png") ).convert_alpha() } # ^-------------------------------------------------------------------^ # Defines if a level should be loaded or a # new campaign should be started. # It also defines the modes # v--------------------------------------------------------------v if self.gameStatus["mode"] == "load": self.mod_logger.debug("Using Load mode") try: self.loadGame(cmp) self.LoadLevel(self.gameStatus["currentLevel"], self.gameStatus["campaignName"], self.gameStatus["mode"], self.screen) except FileNotFoundError: self.mod_logger.info("No file provided, loading cancelled") self.running = False elif self.gameStatus["mode"] == "newgame": self.mod_logger.debug("Using New Game mode") self.gameStatus["campaignFile"] = cmp self.gameStatus["campaignName"] = splitext(basename(cmp))[0] self.loadCampaign(self.gameStatus["campaignFile"], self.gameStatus["mode"]) self.LoadLevel(self.gameStatus["currentLevel"], self.gameStatus["campaignName"], self.gameStatus["mode"], self.screen) elif self.gameStatus["mode"] in ["criticalfailure", "cfsingle"]: self.mod_logger.debug("Using New Game mode - \ Critical Failure Modifier") self.gameStatus["cftime"] = 0 self.gameStatus["campaignFile"] = cmp self.gameStatus["campaignName"] = splitext(basename(cmp))[0] self.loadCampaign(self.gameStatus["campaignFile"], self.gameStatus["mode"]) self.redsurf = pygame.surface.Surface(self.gsize, pygame.SRCALPHA) linesize = 3 bot = self.redsurf.get_rect().bottom self.redsurf.fill((255, 0, 0, 50)) self.redsurf.fill((255, 255, 255, 255), pygame.rect.Rect(0, bot - linesize, self.gsize[0], linesize)) self.redsurfrect = self.redsurf.get_rect() self.LoadLevel(self.gameStatus["currentLevel"], self.gameStatus["campaignName"], self.gameStatus["mode"], self.screen) elif self.gameStatus["mode"] == "singlemap": self.RealLoadLevel(cmp, "singlemap", self.screen) # ^--------------------------------------------------------------^ self.fps = 60 self.garble = False self.garbletimer = _garbletimer_ self.deadbodies = pygame.sprite.Group() pygame.display.set_caption("Glitch_Heaven - Pre-Pre-Alpha Version") if self.running: self.loadLevelPart2(self.keys, sounds) self.mod_logger.debug("Glitches Loaded: {0}".format(self.glitches)) """Game Loop""" while self.running: dt = min(self.clock.tick(self.fps)/1000., 0.05) # For Critical Failure mode # v-------------------------------------------------------------------v if self.gameStatus["mode"] in ["criticalfailure", "cfsingle"]: self.gameStatus["time"] += dt self.redsurfrect.y = -self.gsize[1] + \ (self.gsize[1] * self.gameStatus["time"]) \ / self.gameStatus["cftime"] self.rcftime = self.gameStatus["cftime"] \ - self.gameStatus["time"] self.timer = makeGlitched("Time Before Failure: {0}".format( str(timedelta(seconds=self.rcftime))), self.font) if self.redsurfrect.y > 0: pygame.mouse.set_visible(True) # Make the cursor visible self.running = False # ^-------------------------------------------------------------------^ # For Chaos Mode # v-------------------------------------------------------------------v if self.gameStatus["modifiers"]["chaos"]: self.chaosParameters["timer"] -= dt if self.chaosParameters["timer"] <= 0.: self.toggleGlitch(choice( self.chaosParameters["glitches"]), True) self.newChaosTime() # ^-------------------------------------------------------------------^ for event in pygame.event.get(): if event.type == pygame.QUIT: self.mod_logger.info("QUIT signal received, quitting") pygame.quit() quit() # Debug Area - Glitch Toggles # v----------------------------------------------------------v mods = pygame.key.get_mods() # if config.getboolean("Debug", "debugmode") and\ if config["Debug"]["debugmode"] and\ mods & pygame.KMOD_LSHIFT and\ mods & pygame.KMOD_LCTRL and\ mods & pygame.KMOD_LALT: if event.type == pygame.KEYDOWN: if event.key in _debugkeys_: self.toggleGlitch(_debugkeys_[event.key], True) if event.key == pygame.K_RETURN: self.garble = True if event.key == pygame.K_BACKSPACE and\ self.gameStatus["mode"] not in ["singlemap"]: self.mod_logger.debug("Debug key used, " + "Loading next level") level = self.forceNextLevel() self.LoadLevel(level, self.gameStatus["campaignName"], self.gameStatus["mode"], self.screen) if level: self.loadLevelPart2(self.keys, sounds) if event.key == pygame.K_KP_DIVIDE: self.mod_logger.info( "Toggled Collision Rectangle View") self.showCollision = not self.showCollision if event.key == pygame.K_KP_MULTIPLY: self.showFPS = not self.showFPS if event.key == pygame.K_c: self.mod_logger.info("Forced Checkpoint Save") self.player.lastcheckpoint = ( self.player.rect.x, self.player.rect.y) # Temporary toggles for pause menu and saveGame # v----------------------------------------------------------v elif event.type == pygame.KEYDOWN and\ event.key == keys["escape"]: pauseMenu(screen, keys, self, self.config, sounds, self.mainLogger).mainLoop() elif event.type == pygame.KEYDOWN and\ event.key == self.keys["restart"]: self.sprites.remove(*self.deadbodies) self.deadbodies.empty() self.player.respawn(self) # if config.getboolean("Debug", "keydebug") and\ if config["Debug"]["keydebug"] and\ event.type == pygame.KEYDOWN: self.mod_logger.debug("A key was pressed: {0}" .format(pygame.key.name(event.key))) # ^----------------------------------------------------------^ self.backpos = self.givePosition(__floordiv__, 6) self.middlebackpos = self.givePosition(__floordiv__, 4) self.middlepos = self.givePosition(__floordiv__, 2) self.gameviewport.blit(self.components["background"], self.backpos) self.gameviewport.blit(self.components["middle_back1"], self.middlebackpos) self.tilemap.update(dt, self) self.gameviewport.blit(self.components["middle_back2"], self.middlepos) self.tilemap.draw(self.gameviewport) self.helptxts.update(dt, self) if not self.glitches["timeLapse"] or self.player.x_speed != 0: self.particlesurf.fill((0, 0, 0, 0)) self.player.particles.update() self.player.particles.draw(self.particlesurf) self.gameviewport.blit(self.particlesurf, (-self.tilemap.viewport.x, -self.tilemap.viewport.y)) if self.hasOverlay: self.gameviewport.blit(self.overlay, self.givePosition(__mul__, 1.5)) if self.gameStatus["mode"] in ["criticalfailure", "cfsingle"]: self.gameviewport.blit(self.redsurf, (0, self.redsurfrect.y)) if self.gameStatus["modifiers"]["vflip"] or\ self.gameStatus["modifiers"]["hflip"]: self.gameviewport = pygame.transform.flip( self.gameviewport, self.gameStatus["modifiers"]["hflip"], self.gameStatus["modifiers"]["vflip"]) screen.blit(self.gameviewport, (0, 0)) if self.gameStatus["mode"] in ["criticalfailure", "cfsingle"]: screen.blit(self.timer, (50, 70)) screen.blit(self.titleholder, (0, self.gsize[1])) screen.blit(self.title, self.titleposition) # if config.getboolean("Video", "deathcounter"): if config["Video"]["deathcounter"]: self.dcounttxt = makeGlitched( "Deaths: %d" % self.gameStatus["deathCounter"], self.font) screen.blit(self.dcounttxt, (50, 50)) if self.garble: screen.blit(self.preloaded_sprites["static"], (0, 0)) self.garbletimer -= dt if self.garbletimer <= 0: self.garble = False self.garbletimer = _garbletimer_ if self.showCollision: rec = self.player.collisionrect.copy() rec.x, rec.y = self.tilemap.pixel_to_screen( self.player.collisionrect.x, self.player.collisionrect.y) pygame.draw.rect(screen, (255, 0, 0), rec, 1) if self.showFPS: fps = self.font.render(str(1/dt), False, (255, 0, 0)) screen.blit(fps, (screen.get_width() - 50, screen.get_height() - 50)) if self.showMessage: self.messageSurf.update(dt) self.messageTime -= dt rect = self.messageSurf.surface.get_rect() screen.blit(self.messageSurf.surface, self.tilemap.pixel_to_screen(self.player.rect.x - rect.width/2 + 16, self.player.rect.y - rect.height)) if self.messageTime <= 0: self.showMessage = False self.messageTime = _defaultMessageTime_ pygame.display.update()
def setPlayer2(self, name, ip, conn): self._players[1] = Player(name, ip, conn)
def setPlayer1(self, name, ip, conn): self._players[0] = Player(name, ip, conn)
class PlayerPage(BasePage): """ Главная Страница """ def __init__(self, driver): self.PATH = 'watch/' super(PlayerPage, self).__init__(driver, '') self.player = Player(self.driver) def set_pause_by_pause_btn(self): self.player.move_to_player_bar() self.player.click_on_btn_pause() def set_pause_by_space(self): self.player.click_on_space() def set_pause_by_click_on_screen(self): self.player.click_on_screen() def check_mute(self) -> bool: self.player.move_to_player_bar() self.player.click_on_sound() return self.player.check_mute() def check_sound(self) -> bool: self.player.move_to_player_bar() self.player.click_on_sound() self.player.click_on_mute() return self.player.check_sound() def check_volume_slider(self) -> bool: self.player.move_to_player_bar() self.player.move_to_volume_btn() return self.player.check_volume_slider() def check_share_popup(self) -> bool: self.player.move_to_player_bar() self.player.click_on_share_btn() return self.player.check_share_popup() def check_closing_share_popup(self) -> bool: self.player.move_to_player_bar() self.player.click_on_share_btn() self.player.click_on_close_share_popup() return self.player.check_disappear_share_popup() def check_closing_player(self) -> bool: self.player.click_on_close_player_btn() return self.player.check_disappear_player() def check_player_pause(self) -> bool: return self.player.check_paused()
class Level1(GameState): def __init__(self): super().__init__() self.scores = scores self.background = Background(BACKGROUND, [0, 0]) self.next_state = 'START' def startup(self, persistent): pygame.mixer.music.load('assets/music/Omega.ogg') pygame.mixer.music.set_volume(0.5) pygame.mixer.music.play(-1, 0.0) self.phase = 0 self.num_of_enemies = 15 self.score = 0 self.shots_fired = 0 self.streak = 1 self.misses = 0 self.ammo = int(self.num_of_enemies * 100) self.enemy_list = pygame.sprite.Group() self.asteroid_list = Asteroid_group() self.bullet_list = pygame.sprite.Group() self.boss_list = pygame.sprite.Group() self.hud_items = pygame.sprite.Group() self.boss = Boss() self.player = Player() for i in range(self.num_of_enemies): enemy = Enemy() self.enemy_list.add(enemy) self.boss_list.add(self.boss) self.hud_score = Hud(570, 350, 120, 40, 'SCORE') self.hud_ammo = Hud(570, 300, 120, 40, 'AMMO') self.hud_multiplier = Hud(510, 350, 50, 40, '', 'x', True) self.hud_items.add(self.hud_score) self.hud_items.add(self.hud_ammo) self.hud_items.add(self.hud_multiplier) super().startup(persistent) def get_event(self, event): if event.type == pygame.QUIT: pygame.mixer.music.stop() self.done = True pygame.quit() quit() elif event.type == pygame.MOUSEBUTTONDOWN: can_fire = self.ammo > 0 if can_fire and event.button == 1: self.player.weapon.begin_fire() bullet = self.player.weapon.ammo_type(self.player.rect.center) self.bullet_list.add(bullet) self.shots_fired += 1 self.ammo -= 1 elif can_fire and event.button == 3: for i in range(3): bullet = Chain_Lightning(self.player.rect.center) bullet.find_next_target(self.enemy_list.sprites() + self.boss_list.sprites()) self.bullet_list.add(bullet) self.shots_fired += 1 self.ammo -= 1 elif event.button == 2: self.ammo += 30 elif not can_fire: print('you loose') pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE OUT OF AMMO!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True elif event.type == pygame.MOUSEBUTTONUP: if event.button == 1: self.player.weapon.cease_fire() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_a: self.player.move('left') if event.key == pygame.K_d: self.player.move('right') elif event.type == pygame.KEYUP: if event.key == pygame.K_a: self.player.move('stop') if event.key == pygame.K_d: self.player.move('stop') def bullet_mechanics(self, multiplier, total_score): # --- calculate mechanics for each bullet if self.player.weapon.firing_timer.is_finished() and self.ammo > 0: bullet = self.player.weapon.ammo_type(self.player.rect.center) self.bullet_list.add(bullet) self.shots_fired += 1 self.ammo -= 1 for bullet in self.bullet_list: # see if bullet hit a enemy enemy_hit_list = pygame.sprite.spritecollide( bullet, self.enemy_list, False) # see if asteroid hit ship asteroid_hit_list = pygame.sprite.spritecollide( bullet, self.asteroid_list, False) boss_hit_list = pygame.sprite.spritecollide( bullet, self.boss_list, False) for boss in boss_hit_list: boss.hp -= 15 self.bullet_list.remove(bullet) if boss.hp <= 0: self.score += (150 * multiplier) boss.explode() for asteroid in asteroid_hit_list: asteroid.hp -= 3 if asteroid.hp <= 0: self.score += 20 self.bullet_list.remove(bullet) # for each enemy hit, remove the bullet and add to the score for enemy in enemy_hit_list: if not enemy.hit: self.bullet_list.remove(bullet) self.score += (1 * multiplier) self.streak += 1 enemy.explode() # remove the bullet if it flies up off the screen if bullet.rect.y < -50: self.bullet_list.remove(bullet) self.streak = 0 self.misses += 1 def player_collisions(self): # --- handle collisions player_hit_list = pygame.sprite.spritecollide( self.player, self.asteroid_list, False, pygame.sprite.collide_mask) if player_hit_list: pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE HIT BY ASTEROID!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True player_enemy_hit_list = pygame.sprite.spritecollide( self.player, self.enemy_list, False, pygame.sprite.collide_mask) if player_enemy_hit_list: for enemy in player_enemy_hit_list: if not enemy.hit: pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE HIT BY ENEMY!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True player_boss_hit_list = pygame.sprite.spritecollide( self.player, self.boss_list, False, pygame.sprite.collide_mask) if player_boss_hit_list: for boss in player_boss_hit_list: if not boss.hit: pygame.mixer.music.fadeout(1000) message_display('YOU LOOSE HIT BY ENEMY!!!', WHITE, pygame.display.get_surface(), (700, 400)) self.done = True def check_game_over(self, total_score): # checking enemy list is empty ensures that the last explode() has completed # before ending game;) if not self.enemy_list and not self.boss_list: if self.phase == 0: self.phase = 1 boss2 = Boss((-30, -30)) boss3 = Boss((445, -30)) boss4 = Boss((-30, 100)) self.boss_list.add(boss2, boss3, boss4) return print('winner', self.shots_fired, self.score, total_score) pygame.mixer.music.fadeout(1000) perfect = self.shots_fired <= self.num_of_enemies and not self.misses if total_score > self.scores.top_score: self.scores.update_ts(total_score) if perfect: message_display( 'PERFECT!! YOU WIN!! score: {}'.format(str(total_score)), WHITE, pygame.display.get_surface(), (700, 400)) elif self.ammo == 0: message_display( 'CLOSE ONE, YOU WIN!! score: {}'.format(str(total_score)), WHITE, pygame.display.get_surface(), (700, 400)) else: message_display( 'YOU WIN!!! total score: {}'.format(str(total_score)), WHITE, pygame.display.get_surface(), (700, 400)) self.done = True def update(self, dt): multiplier = int(self.streak / 2) or 1 total_score = int(self.score * 100) or 0 self.hud_ammo.prop = self.ammo self.hud_score.prop = total_score self.hud_multiplier.prop = multiplier # call the update method on all the sprites self.player.update(dt) self.bullet_list.update(dt) self.boss_list.update(dt, self.player.rect.center) self.enemy_list.update(dt, self.player.rect.center) self.asteroid_list.update() self.hud_items.update() self.player_collisions() self.bullet_mechanics(multiplier, total_score) self.check_game_over(total_score) def draw(self, surface): surface.fill(WHITE) surface.blit(self.background.image, self.background.rect) self.hud_items.draw(surface) self.asteroid_list.draw(surface) self.enemy_list.draw(surface) self.boss_list.draw(surface) self.bullet_list.draw(surface) self.player.draw(surface)
def __init__(self, driver): self.PATH = 'watch/' super(PlayerPage, self).__init__(driver, '') self.player = Player(self.driver)
def setup_data_state(constants, run_tutorial=True, previous_data=None): pygame.init() pygame.display.set_caption("Formula") pygame.mixer.quit() pygame.key.set_repeat(100) main = pygame.display.set_mode( (constants.window_size.width, constants.window_size.height)) assets = Assets.setup() godmode = False fps_per_second = 30 story_loader = StoryLoader() story_data = StoryData(story_loader) timesystem = TimeSystem() visuals = VisualEffectSystem.setup(fps_per_second) clock = pygame.time.Clock() windows = WindowManager() rpw = RightPanelWindow(constants) windows.push(rpw) windows.push(GameWindow(constants, parent=rpw)) windows.push(MessageLogWindow(constants, parent=rpw)) windows.push(StoryWindow(constants, story_data, visible=True)) windows.push(StoryHelpWindow(constants)) windows.push(FormulaWindow(constants)) windows.push(FormulaHelpWindow(constants)) windows.push(GeneralHelpWindow(constants)) windows.push(LevelUpWindow(constants)) windows.push(AskQuitWindow(constants)) windows.push(DeadWindow(constants)) windows.push(VictoryWindow(constants)) windows.push(ConsoleWindow(constants)) windows.push(CraftingWindow(constants)) windows.push(CraftingHelpWindow(constants)) windows.push(InventoryWindow(constants)) windows.push(InventoryHelpWindow(constants)) text_width = constants.message_log_text_size.width / get_width( Assets.get().font_message) log = MessageLog(text_width) # for some margin on the sides player = Player(godmode) formula_builder = FormulaBuilder(player.caster.num_slots, player.caster.num_formulas, run_tutorial) levels = 9 planner = RunPlanner(levels, player, constants, timesystem, run_tutorial) fov_map = None ingredient_storage = IngredientStorage() if config.conf.pickupstartcount == "base": ingredient_storage.add_multiple({ Ingredient.FIRE: 2, Ingredient.WATER: 2, Ingredient.EARTH: 2, Ingredient.RANGE: 1, Ingredient.AREA: 1, }) if config.conf.trap: ingredient_storage.add_multiple({ Ingredient.TRAP: 2, }) else: for ing in Ingredient.all(): ingredient_storage.add_multiple( {ing: config.conf.pickupstartcount}) menu_data = AttrDict({"currchoice": 0}) inventory = Inventory(max_count=constants.num_consumables, num_quickslots=constants.num_quickslots) from components.consumable import Firebomb, Freezebomb, Teleporter, CooldownClear # for t in [Firebomb, Freezebomb, Teleporter, CooldownClear, Thingy, Thingmajig]: # inventory.add(t()) #inventory.add(Firebomb()) #inventory.add(Teleporter()) initial_state = GameStates.STORY_SCREEN logger = previous_data.logger if previous_data else BlobLogger() game_data = StateData( player=player, log=log, constants=constants, timesystem=timesystem, fov_map=fov_map, fov_recompute=True, story_data=story_data, run_planner=planner, formula_builder=formula_builder, menu_data=menu_data, ingredient_storage=ingredient_storage, inventory=inventory, logger=logger, initial_state=initial_state, initial_state_history=[GameStates.PLAY], ) camera = Camera(constants.camera_size.width, constants.camera_size.height, game_data) gfx_data = GfxState( main=main, assets=assets, camera=camera, fullscreen=False, visuals=visuals, fps_per_second=fps_per_second, clock=clock, windows=windows, ) if not run_tutorial: game_data.prev_state = [GameStates.FORMULA_SCREEN, GameStates.PLAY] windows.activate_wnd_for_state(game_data.state, game_data, gfx_data) story_data.next_story() # create default formulas Formula.EMPTY, _ = formula_builder.get_empty_formula(caster=player) initial_formulas = formula_builder.evaluate_entity(caster=player) player.caster.set_formulas(initial_formulas) return game_data, gfx_data, initial_state