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
