def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ # print (delta_time) self.ball.center_x += self.direction_x * self.speed * delta_time # move to the right self.ball.center_y += self.direction_y * self.speed * delta_time # move up and down # next make ball start from random spot move in random direction # bounce off walls and paddle. if check_for_collision(self.ball, self.player_paddle) == True: self.score += 10 arcade.play_sound(self.paddle_sound) # keeps ball from bouncing back and forth when it hits paddle end #self.ball.center_x = SCREEN_WIDTH - SCREEN_WIDTH / 10 self.direction_x *= -1 elif self.ball.center_x > SCREEN_WIDTH: # player misses ball arcade.play_sound(self.lose_sound) arcade.pause(2) self.score -= 1 self.start_ball() elif self.ball.center_x < 10: self.direction_x *= -1 arcade.play_sound(self.ball_sound) elif self.ball.center_y > SCREEN_HEIGHT or self.ball.center_y < 10: self.direction_y *= -1 arcade.play_sound(self.ball_sound) elif self.score > 10: print('Winner') arcade.draw_text('You Win! ', 100, 100, arcade.color.RED, 36) arcade.start_render() arcade.pause(5) exit()
def on_turn_end(self): """ Handles switching player states at the end of a turn :return: None :post: Switches current player and toggles self.turn_over """ if self.current_player == self.player1: self.current_player = self.player2 else: self.current_player = self.player1 arcade.pause(1.5) y = self.player1.x z = self.player2.x print( f" ScoreBoard " ) print(f"Player 1's Score: ") print(z) print(f"") print(f"") print(f"") print(f"Player 2's Score: ") print(y) self.turn_over = True
def _manageLasers(self): for laser in self.lasers: points = (laser.center_x, laser.center_y), (laser.center_x + laser.change_x, laser.center_y + laser.change_y) for wall in self.levels[self.currentLevel].noWalk: if arcade.geometry.are_polygons_intersecting(points, wall.points): try: self.lasers.remove(laser) laser.owner.lasers.remove(laser) except: pass continue for char in self.characterList: if arcade.geometry.are_polygons_intersecting(points, char.points) and char != laser.owner: try: self.lasers.remove(laser) laser.owner.lasers.remove(laser) except: pass try: self.characterList.remove(char) if char is self.playerSprite: arcade.draw_text('game over', 720, 450, arcade.color.WHITE, font_size=50) arcade.pause(2) self.close() self.score += 1 except: pass
def update(self, delta_time): """ Movement and game logic """ self.frame_count += 1 self.score += 0.1 if self.player_sprite.right > SCREEN_WIDTH and self.limiti == 0 or self.player_sprite.left < 0 and self.limiti ==1 : self.player_sprite.change_x = 0 if self.score < 100: if self.frame_count % 150 == 0: self.enemy() else: if self.frame_count % 100 == 0: self.vel=1 self.enemy() self.enemy_list.update() bad_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.enemy_list) if len(bad_hit_list) > 0 : arcade.pause(2) self.setup() self.nave_list.update() if self.caso == 3: for i in self.nave_list : self.spara(i) else: for i in self.nave_list: i.kill() # Update the player based on the physics engine if not self.game_over: self.physics_engine.update()
def on_key_press(self, symbol: int, modifiers: int): print(symbol, modifiers) if symbol == 112: # p arcade.pause(2) elif symbol == 109: # m self.click_flag = False self.mirror_creation_flag = True self.ray_creation_flag = False self.win_click_flag = False self.mirror_delete_flag = False elif symbol == 100: # d self.mirror_delete_flag = True self.mirror_creation_flag = False self.win_click_flag = False self.ray_creation_flag = False self.click_flag = False elif symbol == 101: # e pass elif symbol == 114: # r self.ray_creation_flag = True self.click_flag = False self.continious_flag = False self.mirror_creation_flag = False self.win_click_flag = False self.mirror_delete_flag = False elif symbol == 111: # o - непрерывное создание зеркал self.continious_flag = not self.continious_flag print('Continious flag current value:', self.continious_flag) elif symbol == 97: # a - delete all self.mirror_list = [] self.ray = None self.ray_creation_flag = False self.click_flag = False self.continious_flag = False self.mirror_creation_flag = False self.win_click_flag = False self.mirror_delete_flag = False elif symbol == 115: # s - save to json json_content = self.serialize() self.save_to_file(str(self.filename) + '.json', json_content) elif symbol == 108: # l - load from json. rewrite current room self.load_from_file(self.filename + '.json') elif symbol == 113: # q - exit print('bye') sys.exit(0) elif symbol == 117: # u self.win_flag = True elif symbol == 110: # n if self.ray: self.win_flag = self.ray.calc_ray_step(self.get_mirrors()) elif symbol == 102: # f if self.ray: arcade.draw_circle_filled(self.ray.x_0, self.ray.y_0, 5, arcade.color.RED) elif symbol == 119: # w # создать круг победы self.win_click_flag = True self.ray_creation_flag = False self.mirror_creation_flag = False self.click_flag = False
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ self.ball.center_x += self.direction_x * self.speed # move to the right self.ball.center_y += self.direction_y * self.speed # move up and down # next make ball start from random spot move in random direction # bounce off walls and paddle. if check_for_collision(self.ball, self.player_paddle) == True: self.score += 10 arcade.play_sound(self.paddle_sound) # keeps ball from bouncing back and forth when it hits paddle end #self.ball.center_x = WIDTH - WIDTH / 10 self.direction_x *= -1 elif self.ball.center_x > WIDTH: # player misses ball arcade.play_sound(self.lose_sound) arcade.pause(2) self.score -= 1 self.start_ball() elif self.ball.center_x < 10: self.direction_x *= -1 arcade.play_sound(self.ball_sound) elif self.ball.center_y > HEIGHT or self.ball.center_y < 10: self.direction_y *= -1 arcade.play_sound(self.ball_sound) elif self.score > 15: print('Winner') game_over_view = GameOverView(self.score) self.window.show_view(game_over_view)
def on_turn_end(self): """ Handles switching player states at the end of a turn :return: None :pre scoreboard function runs successfully :post: Switches current player and toggles self.turn_over. Also announce the score for each player on scoreboard. """ AI_window(WINDOW_WIDTH, WINDOW_HEIGHT, "Your Board", self.player1, self.on_turn_end, True) arcade.pause(1.5) y = self.player1.x z = self.player2.x self.count += 1 print( f" ScoreBoard " ) print(' Round', self.count, ' ') print(f"Player 1's Score: ") print(z) print(f"") print(f"") print(f"") print(f"AI's Score: ") print(y) self.turn_over = True
def test_window(twm): import arcade width = 800 height = 600 title = "My Title" resizable = True arcade.open_window(width, height, title, resizable) arcade.set_background_color(arcade.color.AMAZON) w = arcade.get_window() assert w is not None # Make sure the arguments get passed to the window if not twm: assert w.width == width assert w.height == height assert w.caption == title assert w.resizeable is resizable assert w.current_view is None arcade.set_window(w) w.background_color = 255, 255, 255, 255 assert w.background_color == (255, 255, 255, 255) w.set_mouse_visible(True) w.set_size(width, height) p = arcade.get_projection() assert isinstance(p, np.ndarray) v = arcade.get_viewport() if not twm: assert v[0] == 0 # The lines below fail. Why? assert v[1] == width - 1 assert v[2] == 0 assert v[3] == height - 1 factor = arcade.get_scaling_factor() assert factor > 0 factor = arcade.get_scaling_factor(w) assert factor > 0 arcade.start_render() arcade.finish_render() def f(): pass arcade.schedule(f, 1 / 60) arcade.pause(0.01) arcade.close_window() arcade.open_window(width, height, title, resizable) arcade.quick_run(0.01)
def main(): arcade.open_window(800, 600, "Drawing Example") arcade.set_background_color(arcade.color.WHITE) arcade.start_render() arcade.draw_arc_filled(150, 144, 15, 36, arcade.color.BOTTLE_GREEN, 90, 360, 45) color = (255, 0, 0, 50) arcade.draw_arc_filled(150, 154, 15, 36, color, 90, 360, 45) arcade.finish_render() arcade.pause(4)
def on_draw(self): arcade.start_render() self.ship.location.draw() self.ship.draw() self.draw_commands() if self.message: print_message(self.message) arcade.finish_render() arcade.pause(0.5)
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ """Logic for scrolling background to the left""" if self.currentGameState == 'GAME_RUNNING': """Calls background method speed""" self.run_background(1) """Calls to move player""" self.player_sprite.move() self.player_weapon_list.update() self.enemy_list.update() self.enemy_weapon_list.update() """Logic method for collisons and keeping score""" self.update_collision_check() """Randomly spawns an enemy couple of seconds""" if random.randrange(250) == 0: self.spawn_enemy(1) """Calls method to preform probability of enemies shooting""" self.enemy_shoot() """Check's if player meets min score for escalate mode""" if self.gameScore >= 1000: self.currentGameState = 'GAME_ELEVATE' elif self.currentGameState == 'GAME_ELEVATE': """Calls background method speed""" self.run_background(2) """Calls to move player""" self.player_sprite.move() self.player_weapon_list.update() self.enemy_list.update() self.enemy_weapon_list.update() """Logic method for collisons and keeping score""" self.update_collision_check() """Randomly spawns an enemy couple of seconds""" if random.randrange(200) == 0: self.spawn_enemy(2) elif random.randrange(500) == 1: self.spawn_enemy(1) """Calls method to preform probability of enemies shooting""" self.enemy_shoot() """Check's if player meets min score for escalate mode""" if self.gameScore >= 6800: self.currentGameState = 'GAME_WIN' arcade.pause(2) arcade.play_sound(self.win_ending_sound) pass elif self.currentGameState == 'GAME_OVER': pass elif self.currentGameState == 'GAME_WIN': pass else: self.currentGameState = 'GAME_OVER'
def on_turn_end(self): ''' Handles switching player states at the end of a turn :return: None :post: Switches current player and toggles self.turn_over ''' if self.current_player == self.player1: self.current_player = self.player2 else: self.current_player = self.player1 arcade.pause(1.5) self.turn_over = True
def on_draw(self): arcade.start_render() # Draw points for point in self.input_points: arcade.draw_ellipse_filled(point.x, point.y, POINT_RADIUS, POINT_RADIUS, point.color) # Draw means if self.k_means: for mean in self.k_means: arcade.draw_rectangle_filled(mean.x, mean.y, POINT_RADIUS * 1.5, POINT_RADIUS * 1.5, mean.color + [MEAN_ALPHA]) arcade.pause(2)
def on_update(self, delta_time: float = 2): self.physics_engine.update() hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.obstacle_list) completionStat = arcade.check_for_collision_with_list( self.player_sprite, self.reward_coord) # Animate character on the generated path if self.position < len(self.path): self.animatePath(self.path, self.position) self.position = self.position + 1 # Remove obstacle sprites on collision for obj in hit_list or completionStat: obj.remove_from_sprite_lists() arcade.pause(0.2)
def on_update(self,delta_time): arcade.pause(self.speed) self.Snake.head.center_x += self.change_x self.Snake.head.center_y += self.change_y ########################################### if self.stop == False: self.Snake.location.append([self.Snake.head.center_x,self.Snake.head.center_y]) self.lenght = len(self.Snake.location) self.Snake.head1[0].center_x = self.Snake.location[self.lenght - 2][0] self.Snake.head1[0].center_y = self.Snake.location[self.lenght - 2][1] for i in range(self.n,len(self.Snake.snake_body)): self.Snake.snake_body[i].center_x = self.Snake.location[self.lenght - (i+2)][0] self.Snake.snake_body[i].center_y = self.Snake.location[self.lenght - (i+2)][1] #check for collision in food if(arcade.check_for_collision_with_list(self.Snake.head,self.Snake.food_list)): self.Snake.food_list[0].kill() self.Snake.score += 1 self.Snake.set_food() #Adding the body of the snake if(self.Snake.score % 2 == 0): self.Snake.add_snake_body() if self.choose == False: if self.Snake.score == 10: self.l = 1 self.speed = level["Medium"] if self.Snake.score == 20: self.l = 2 self.speed = level["Hard"] #check for collision if Game over if(arcade.check_for_collision_with_list(self.Snake.head,self.Snake.wall) or arcade.check_for_collision_with_list(self.Snake.head,self.Snake.snake_body)): arcade.pause(0.5) self.Snake.food_list = arcade.SpriteList() self.Snake.snake_body = arcade.SpriteList() self.Snake.score = 0 self.Snake.head1[0].kill() self.Return = GameOver() self.window.show_view(self.Return)
def on_key_press(self, key, modifiers): # 키가 눌렸을 때 # 키가 눌리면 호출됨 #눌렸으면 상태롤 True 로 변경 if self.check_game == True: if key == arcade.key.UP or key == arcade.key.W: self.up_pressed = True elif key == arcade.key.DOWN or key == arcade.key.S: self.down_pressed = True elif key == arcade.key.LEFT or key == arcade.key.A: self.left_pressed = True elif key == arcade.key.RIGHT or key == arcade.key.D: self.right_pressed = True elif key == arcade.key.O: arcade.pause(1) elif key == arcade.key.P: arcade.quick_run(5) self.process_keychange()
def test_window(): import arcade width = 800 height = 600 title = "My Title" resizable = True arcade.open_window(width, height, title, resizable) arcade.set_background_color(arcade.color.AMAZON) w = arcade.get_window() assert w is not None # Make sure the arguments get passed to the window assert w.width == width assert w.height == height assert w.caption == title assert w.resizeable is resizable arcade.set_window(w) p = arcade.get_projection() assert p is not None v = arcade.get_viewport() assert v[0] == 0 # The lines below fail. Why? # assert v[1] == width - 1 assert v[2] == 0 # assert v[3] == height - 1 arcade.start_render() arcade.finish_render() def f(): pass arcade.schedule(f, 1 / 60) arcade.pause(0.01) arcade.close_window() arcade.open_window(width, height, title, resizable) arcade.quick_run(0.01)
def display_rest(self): self.inISI = True """ Displays a fixation cross for a predetermined amount of time for rest (inter-trial interval; ITI)""" center_x = (WIDTH + MARGIN) * (COLUMN_COUNT / 2) + MARGIN / 2 center_y = (HEIGHT + MARGIN) * (ROW_COUNT / 2) + MARGIN / 2 self.ITI_item = arcade.Sprite('Images/empty.png', image_height=SCREEN_HEIGHT, image_width=SCREEN_WIDTH, center_x=center_x, center_y=center_y) self.ITI_list.append(self.ITI_item) self.ITI_item = arcade.Sprite('Images/cross.png', center_x=center_x, center_y=center_y) self.ITI_list.append(self.ITI_item) # Cover whole window with a black box and add white fixation cross arcade.start_render() self.ITI_list.draw() arcade.finish_render() # Wait x number of seconds, then destroy the box and fixation cross rest_time = uniform(1, 2) arcade.pause(rest_time) for item in self.ITI_list: item.kill() self.inISI = False # Reset cursor to center self.player_sprite.center_x = center_x self.player_sprite.center_y = center_y self.player_list.append(self.player_sprite) # Reset trial time-out timer self.trialTime = time.time()
def test_window(): import arcade width = 800 height = 600 title = "My Title" resizable = True arcade.open_window(width, height, title, resizable) arcade.set_background_color(arcade.color.AMAZON) w = arcade.get_window() assert w is not None arcade.set_window(w) p = arcade.get_projection() assert p is not None v = arcade.get_viewport() assert v[0] == 0 assert v[1] == width - 1 assert v[2] == 0 assert v[3] == height - 1 arcade.start_render() arcade.finish_render() def f(): pass arcade.schedule(f, 1 / 60) arcade.pause(0.01) arcade.close_window() arcade.open_window(width, height, title, resizable) arcade.quick_run(0.01)
def on_update(self, delta_time): # This will repeatedly update if not self.game_over: self.enemy_list.update() self.projectile_list.update() for enemy in self.enemy_list: if enemy.center_x > 0: enemy.change_x = -2 elif enemy.center_x < 0: enemy.change_x = 2 if enemy.center_y < 1150: if enemy.physics_engine.is_on_ladder(): enemy.change_y = PLAYER_JUMP_SPEED / 4 if not enemy.physics_engine.is_on_ladder(): enemy.change_y = 0 # update player(s) self.player_list.update() for i in self.player_list: if i != self.active_sprite: if i.position[0] > self.active_sprite.position[ 0] + SOCIAL_DISTANCE: i.change_x = random.randint(-7, -1) elif i.position[0] < self.active_sprite.position[ 0] - SOCIAL_DISTANCE: i.change_x = random.randint(1, 7) elif i.position[0] < self.active_sprite.position[ 0] + SOCIAL_DISTANCE or i.position[ 0] > self.active_sprite.position[ 0] - SOCIAL_DISTANCE: i.change_x = 0 if i.position[1] < self.active_sprite.position[1]: if i.physics_engine.is_on_ladder(): i.change_y = PLAYER_JUMP_SPEED / 2 elif i.position[1] > self.active_sprite.position[1]: i.change_y = -PLAYER_JUMP_SPEED / 2 self.warrior_physics_engine.update() self.archer_physics_engine.update() self.wizard_physics_engine.update() # See if an enemy has been hit. for enemy in self.enemy_list: hit_list = arcade.check_for_collision_with_list( enemy, self.projectile_list) if len(hit_list) > 0: enemy.health -= 100 for projectile in hit_list: projectile.remove_from_sprite_lists() # See if enemy or play died. for sprite in self.enemy_list: if sprite.health <= 0: sprite.remove_from_sprite_lists() self.score += 1 for sprite in self.player_list: if sprite.health <= 0: sprite.remove_from_sprite_lists() # See if the player hit a enemy. If so, lose heath for i in self.player_list: hit_list = arcade.check_for_collision_with_list( i, self.enemy_list) for i in hit_list: if hit_list[0].attack_cooldown > 3: i.health -= random.randint(1, 5) hit_list[0].attack_cooldown = 0.0 #update timers self.cooldown += delta_time self.enemy_spawn_cooldown += delta_time for i in self.enemy_list: i.attack_cooldown += delta_time for i in self.player_list: i.attack_cooldown += delta_time # enemy spawning # Zombie if self.enemy_spawn_cooldown > 5: zombie = Player( ":resources:images/animated_characters/zombie/zombie_idle.png", self.wall_list, self.ladder_list) if random.randint(0, 1) == 0: zombie.center_x = ENEMY_SPAWN_LOCATION_LEFT[0] zombie.center_y = ENEMY_SPAWN_LOCATION_LEFT[1] else: zombie.center_x = ENEMY_SPAWN_LOCATION_RIGHT[0] zombie.center_y = ENEMY_SPAWN_LOCATION_RIGHT[1] # Set boundaries on the left/right the enemy can't cross zombie.change_x = 2 self.enemy_list.append(zombie) self.enemy_spawn_cooldown = 0.0 for enemy in self.enemy_list: if enemy.collides_with_point((0, 1050)): end_game = f"Score: {self.score} \n You Died \n Wait 10 Seconds To Play Again" arcade.draw_text(end_game, 10 + self.view_left, 10 + self.view_bottom, arcade.csscolor.WHITE, 18) arcade.pause(10) MyGame.setup() # --- Manage Scrolling --- # Track if we need to change the viewpoint changed_viewport = False # Did the player fall off the map? for i in self.player_list: if i.center_y < -100: i.center_x = PLAYER_START_X i.center_y = PLAYER_START_Y # set the camera to the start self.view_left = 0 self.view_bottom = 0 changed_viewport = True #arcade.play_sound(self.game_over) # scroll left left_boundary = self.view_left + LEFT_VIEWPORT_MARGIN if self.active_sprite.left < left_boundary: self.view_left -= left_boundary - self.active_sprite.left changed_viewport = True # Scroll right right_boundary = self.view_left + SCREEN_WIDTH - RIGHT_VIEWPORT_MARGIN if self.active_sprite.right > right_boundary: self.view_left += self.active_sprite.right - right_boundary changed_viewport = True # Scroll up top_boundary = self.view_bottom + SCREEN_HEIGHT - TOP_VIEWPORT_MARGIN if self.active_sprite.top > top_boundary: self.view_bottom += self.active_sprite.top - top_boundary changed_viewport = True # Scroll down bottom_boundary = self.view_bottom + BOTTOM_VIEWPORT_MARGIN if self.active_sprite.bottom < bottom_boundary: self.view_bottom -= bottom_boundary - self.active_sprite.bottom changed_viewport = True if changed_viewport: # Only scroll to integers. Otherwise we end up with pixels that # don't line up on the screen self.view_bottom = int(self.view_bottom) self.view_left = int(self.view_left) # Do the scrolling arcade.set_viewport(self.view_left, SCREEN_WIDTH + self.view_left, self.view_bottom, SCREEN_HEIGHT + self.view_bottom)
def update(self, delta_time): """ Movement and game logic """ # Animate the player on the start screen if self.current_state == START_SCREEN: self.player_sprite.update() self.player_sprite.update_animation() # Only move and do things if the game is running. if self.current_state == GAME_RUNNING: # Update coordinates, etc. #print(self.background2.bottom - self.background1.top) distance = self.background2.bottom - self.background1.top if distance < 0 and distance > -80: # Fissure remedy self.background2.bottom = self.background1.top self.enemy_list.move(0, -5) self.red_list.move(1, -2) self.cloud_list.move(0, -2) self.player_sprite.update_animation() self.enemy_sprite.update_animation() self.power_sprite.update_animation() self.all_sprites_list.update() if self.player_sprite.health > 0: # Collision detection between players and all enemy aircraft. for enemy_list in [self.enemy_list, self.red_list]: hit_list = arcade.check_for_collision_with_list( self.player_sprite, enemy_list) # Traverse the list of enemy aircraft encountered for enemy in hit_list: enemy.kill() self.player_sprite.health -= 1 if self.player_sprite.health < 0: e = Explosion(self.enemy_explosion_images) e.center_x = self.player_sprite.center_x e.center_y = self.player_sprite.center_y e.update() self.player_sprite.kill() e = Explosion(self.enemy_explosion_images, enemy.center_x, enemy.center_y) e.center_x = enemy.center_x e.center_y = enemy.center_y e.update() arcade.sound.play_sound(self.explode_sound) self.enemy_explosion_list.append(e) self.all_sprites_list.append(e) # Is Powerup dropped? if self.powerup: self.power_sprite.top = self.power_sprite.top - 2 self.power_sprite.update() # pickup power up power_col = arcade.check_for_collision(self.power_sprite, self.player_sprite) if power_col: arcade.sound.play_sound(self.powerup_sound) self.powerup = 0 self.power_sprite.kill() if not self.enemy_shot: enemy_hit = arcade.check_for_collision(self.enemy_sprite, self.player_sprite) if enemy_hit: self.enemy_shot = True self.enemy_sprite.kill() self.enemy_sprite.update() es = Explosion(self.enemy_explosion_images, self.enemy_sprite.center_x, self.enemy_sprite.center_y) es.center_x = self.enemy_sprite.center_x es.center_y = self.enemy_sprite.center_y es.update() self.enemy_explosion_list.append(es) self.all_sprites_list.append(es) if self.power_sprite.top < 0: self.power_sprite.kill() self.powerup = 0 # Did we shoot the powerup enemy? if not self.enemy_shot: self.enemy_sprite.right = self.enemy_sprite.right - 1 self.enemy_sprite.top = self.enemy_sprite.top - 1 shot_enemy = arcade.check_for_collision_with_list( self.enemy_sprite, self.bullet_list) if len(shot_enemy) > 0: arcade.sound.play_sound(self.explode_sound) self.enemy_sprite.remove_from_sprite_lists() self.enemy_sprite.kill() es = Explosion(self.enemy_explosion_images, self.enemy_sprite.center_x, self.enemy_sprite.center_y) es.center_x = self.enemy_sprite.center_x es.center_y = self.enemy_sprite.center_y es.update() self.enemy_explosion_list.append(es) self.all_sprites_list.append(es) self.enemy_shot = 1 self.power_sprite.top = self.enemy_sprite.top self.power_sprite.center_x = self.enemy_sprite.center_x self.power_sprite.center_y = self.enemy_sprite.center_y self.power_sprite.update_animation() self.power_sprite.update() # Did each enemy hit the bullet for enemy_bullet in [self.enemy_list, self.red_list]: for enemy in enemy_bullet: hit_list = arcade.check_for_collision_with_list( enemy, self.bullet_list) if len(hit_list) > 0: enemy.kill() arcade.sound.play_sound(self.explode_sound) [b.kill() for b in hit_list] # Delete every bullet encountered self.score += len(hit_list) e = Explosion(self.enemy_explosion_images, enemy.center_x, enemy.center_y) e.center_x = enemy.center_x e.center_y = enemy.center_y e.update() self.enemy_explosion_list.append(e) self.all_sprites_list.append(e) # If we've collected all the games, then move to a "GAME_OVER" state. if self.player_sprite.health <= 0: e = Explosion(self.enemy_explosion_images, self.player_sprite.center_x, self.player_sprite.center_y) e.center_x = self.player_sprite.center_x e.center_y = self.player_sprite.center_y e.update() self.enemy_explosion_list.append(e) self.all_sprites_list.append(e) self.power_sprite.update() self.current_state = GAME_OVER self.background_music.stop() arcade.sound.play_sound(self.gameover_sound) arcade.pause(3) self.set_mouse_visible(True) if self.player_sprite.left < 0: self.player_sprite.left = 0 elif self.player_sprite.right > SCREEN_WIDTH - 1: self.player_sprite.right = SCREEN_WIDTH - 1 if self.player_sprite.bottom < 60: self.player_sprite.bottom = 60 elif self.player_sprite.top > SCREEN_HEIGHT - 1: self.player_sprite.top = SCREEN_HEIGHT - 1
def animate(self, delta): if self.state == 1: #gen star arcade.pause(0.1) if self.count % 6 == 0 and len(self.star_cell) > 0: self.random = randint(0, len(self.star_cell) - 1) self.lock_x = self.star_cell[self.random] % self.n self.lock_y = math.floor(self.star_cell[self.random] / self.n) self.star[self.lock_y][self.lock_x].lock = True elif self.star[self.lock_y][self.lock_x] != 0: self.star[self.lock_y][self.lock_x].lock = False if self.count % 10 == 0 and self.count != 0: self.black_hole.appear = True self.black_hole.type1 = randint(0, 1) self.black_hole.type2 = randint(0, 1) if self.black_hole.type1 == 0: self.black_hole.x1 = randint(0, 4) self.black_hole.y1 = randint(0, 3) else: self.black_hole.x1 = randint(0, 3) self.black_hole.y1 = randint(0, 4) if self.black_hole.type2 == self.black_hole.type1: self.black_hole_range1 = [0, 1, 2, 3] self.black_hole_range2 = [0, 1, 2, 3, 4] if self.black_hole.type2 == 0: self.black_hole_range1.remove(self.black_hole.y1) self.black_hole_range2.remove(self.black_hole.x1) self.black_hole.x2 = self.black_hole_range2[randint( 0, 3)] self.black_hole.y2 = self.black_hole_range1[randint( 0, 2)] else: self.black_hole_range1.remove(self.black_hole.x1) self.black_hole_range2.remove(self.black_hole.y1) self.black_hole.x2 = self.black_hole_range1[randint( 0, 2)] self.black_hole.y2 = self.black_hole_range2[randint( 0, 3)] else: if self.black_hole.type2 == 0: self.black_hole.x2 = randint(0, 4) self.black_hole.y2 = randint(0, 3) else: self.black_hole.x2 = randint(0, 3) self.black_hole.y2 = randint(0, 4) self.black_hole.set_position() else: self.black_hole.appear = False self.random = randint(0, len(self.blank_cell) - 1) self.star[math.floor( self.blank_cell[self.random] / self.n)][self.blank_cell[self.random] % self.n] = Star( 105 + 150 * (self.blank_cell[self.random] % self.n), 555 - 150 * math.floor(self.blank_cell[self.random] / self.n), self.sun) self.sun = False for i in range(self.n): for j in range(self.n): if self.star[i][j] != 0 and self.star[i][j].value == -1: arcade.pause(0.5) self.for_del = self.star[i][j] self.star[i][j] = 0 del self.for_del for k in range(self.n): if self.star[i][k] != 0 and self.star[i][ k].value > 0: if self.star[i][k].value < 131072: self.star[i][k].value *= 2 self.score += (int)(math.log2(self.max) * self.star[i][k].value / 4) if self.star[k][j] != 0 and self.star[k][ j].value > 0: if self.star[k][j].value < 131072: self.star[k][j].value *= 2 self.score += (int)(math.log2(self.max) * self.star[k][j].value / 4) self.check_max() self.check_blank_cell() if self.is_end(): self.state = 0 elif (not self.is_finish) and self.max == 2048: self.is_finish = True self.state = 7 elif self.score > 100000: self.state = 8 else: self.state = 2 elif self.state == 3: #animate move up for i in range(self.n): for j in range(self.n): if self.star[i][j] != 0: if self.star[i][j].y < self.star[i][j].target: self.star[i][j].y += self.star[i][j].v if self.star[i][j].y > self.star[i][j].target: self.star[i][j].y = self.star[i][j].target if self.is_all_y_stable(): self.recalculate() elif self.state == 4: #animate move down for i in range(self.n): for j in range(self.n): if self.star[i][j] != 0: if self.star[i][j].y > self.star[i][j].target: self.star[i][j].y += self.star[i][j].v if self.star[i][j].y < self.star[i][j].target: self.star[i][j].y = self.star[i][j].target if self.is_all_y_stable(): self.recalculate() elif self.state == 5: #animate move left for i in range(self.n): for j in range(self.n): if self.star[i][j] != 0: if self.star[i][j].x > self.star[i][j].target: self.star[i][j].x += self.star[i][j].v if self.star[i][j].x < self.star[i][j].target: self.star[i][j].x = self.star[i][j].target if self.is_all_x_stable(): self.recalculate() elif self.state == 6: #animate move right for i in range(self.n): for j in range(self.n): if self.star[i][j] != 0: if self.star[i][j].x < self.star[i][j].target: self.star[i][j].x += self.star[i][j].v if self.star[i][j].x > self.star[i][j].target: self.star[i][j].x = self.star[i][j].target if self.is_all_x_stable(): self.recalculate()
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ # Start task with rest trial if self.firstTrial is True: self.display_rest() self.firstTrial = False # Calculate where to move the player sprite self.player_sprite.change_x = 0 self.player_sprite.change_y = 0 # Buffer data for 750 ms and process to determine which direction to go step_time = time.time() # want to take 1 second for step to update step_length = 1.750 # amount of time we want to use for calculation buffer = int(self.fs * step_length) data = np.zeros((buffer, self.channels)) if self.EEGdevice == 7: self.streamer.clear_out_buffer() for idx in range(buffer): if self.EEGdevice == 7: # code to read in EEG from DSI-7 here tmp = 1 # just put something here to prevent indentation issues data[idx, :] = self.streamer.out_buffer_queue.get()[:-1] elif self.EEGdevice == 8: sample, timestamp = inlet.pull_sample() data[idx, :] = sample self.eeg_data = data self.classify_epoch() # TO DO # Move the player sprite while time.time() - step_time < 2: tmp = 1 # just do something until time is up pulseValue = 0 if self.move_left is True: # Left (eyes closed) self.player_sprite.set_position( self.player_sprite.center_x - (WIDTH + MARGIN), self.player_sprite.center_y) direction_moved = 'left' pulseValue = 1 elif self.move_right is True: # Right (eyes open) self.player_sprite.set_position( self.player_sprite.center_x + WIDTH + MARGIN, self.player_sprite.center_y) direction_moved = 'right' pulseValue = 2 # Call update on all sprites self.player_list.update() self.target_list.update() self.ITI_list.update() # Send pulses move_time = clock.getTime() # previous code - # if self.EEGdevice == 7: # # Audio beep to send pulse to sync box # if self.move_left is True: # play_sound('C') # elif self.move_right is True: # play_sound('E') # elif self.EEGdevice == 8: # # Send pulse through LSL, 1 if left, 2 if right # self.outlet.push_sample([pulseValue]) # if self.move_left is True: # play_sound('C') # elif self.move_right is True: # play_sound('E') # modified - does it still work? if self.EEGdevice == 8: # Send pulse through LSL, 1 if left, 2 if right self.outlet.push_sample([pulseValue]) if self.move_left is True: play_sound('C') elif self.move_right is True: play_sound('E') # Store task data taskData.loc[moveCount] = pd.Series([move_time, \ self.player_sprite.center_x, self.player_sprite.center_y, \ self.target_sprite.center_x, self.target_sprite.center_y, \ direction_moved, self.score], \ index=self.taskData_col_names) increment() # End trial if time is up if time.time() - self.trialTime >= self.trialLength: arcade.start_render() arcade.draw_rectangle_filled(center_x=self.player_sprite.center_x, center_y=self.player_sprite.center_y, width=WIDTH, height=HEIGHT, color=arcade.color.RED) arcade.finish_render() arcade.pause(1) # Play minor arpeggio downward play_sound(value='A', sec=0.1, octave=4) arcade.pause(0.1) play_sound(value='E', sec=0.1, octave=4) arcade.pause(0.1) play_sound(value='C', sec=0.1, octave=4) arcade.pause(0.1) play_sound(value='A', sec=0.1, octave=3) for target in self.target_list: target.kill() self.display_rest() self.create_target() # Generate list of all targets that collided with the player target_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.target_list) # Change color of cursor on top of target hitTarget = False for target in target_hit_list: hitTarget = True if hitTarget is True: arcade.start_render() arcade.draw_rectangle_filled(center_x=self.player_sprite.center_x, center_y=self.player_sprite.center_y, width=WIDTH, height=HEIGHT, color=arcade.color.GREEN) arcade.finish_render() arcade.pause(1) # Play major arpeggio upward play_sound(value='C', sec=0.1, octave=4) arcade.pause(0.1) play_sound(value='E', sec=0.1, octave=4) arcade.pause(0.1) play_sound(value='G', sec=0.1, octave=4) arcade.pause(0.1) play_sound(value='C', sec=0.1, octave=5) # Loop through each colliding sprite, removing it, and adding to the score for target in target_hit_list: target.kill() self.display_rest() self.score += 1 self.create_target()
def on_update(self, delta_time): # We're calling physics engine # Enemy if not self.health == 0: self.enemy_list.update() self.physics_engine.update() self.total_time -= delta_time # Update animations if self.physics_engine.can_jump(): self.player_sprite.can_jump = False else: self.player_sprite.can_jump = True if self.physics_engine.is_on_ladder( ) and not self.physics_engine.can_jump(): self.player_sprite.is_on_ladder = True self.process_keychange() else: self.player_sprite.is_on_ladder = False self.process_keychange() self.coin_list.update_animation(delta_time) self.background_list.update_animation(delta_time) self.player_list.update_animation(delta_time) self.wall_list.update() # See if the moving wall hit a boundary and needs to reverse direction. for wall in self.wall_list: if wall.boundary_right and wall.right > wall.boundary_right and wall.change_x > 0: wall.change_x *= -1 if wall.boundary_left and wall.left < wall.boundary_left and wall.change_x < 0: wall.change_x *= -1 if wall.boundary_top and wall.top > wall.boundary_top and wall.change_y > 0: wall.change_y *= -1 if wall.boundary_bottom and wall.bottom < wall.boundary_bottom and wall.change_y < 0: wall.change_y *= -1 # if you hit any coins coin_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.coin_list) for coin in coin_hit_list: self.game_score += 1 # Remove the coin coin.remove_from_sprite_lists() # Play sound arcade.play_sound(self.collect_coin_sound) # enemy for enemy in self.enemy_list: if len(arcade.check_for_collision_with_list(enemy, self.wall_list)) > 0: enemy.change_x *= -1 elif enemy.boundary_left is not None and enemy.left < enemy.boundary_left: enemy.change_x *= -1 elif enemy.boundary_right is not None and enemy.right > enemy.boundary_right: enemy.change_x *= -1 changed_viewport = False if self.player_sprite.center_x >= self.end_of_map: self.level += 1 self.setup(self.level) self.view_left = 0 self.view_bottom = 0 arcade.stop_sound(self.game_sound) arcade.play_sound(self.level_update_sound) # arcade.play_sound(self.game_sound) changed_viewport = True # Manage Scrolling if len( arcade.check_for_collision_with_list(self.player_sprite, self.enemy_list)) > 0: self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y self.view_left = 0 self.view_bottom = 0 changed_viewport = True arcade.play_sound(self.game_over) self.health -= 1 # if player falls if self.player_sprite.center_y < -100: self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y # Set the camera self.view_left = 0 self.view_bottom = 0 changed_viewport = True arcade.play_sound(self.game_over) self.health -= 1 if self.health == 0: arcade.stop_sound(self.game_sound) arcade.pause(3) arcade.play_sound(self.game_sound) self.total_time = 303.0 self.view_left = 0 self.view_bottom = 0 changed_viewport = True self.health = 3 self.game_score = self.game_score - 20 # end of the game if self.level > 3: game_over_view = GameOverView() self.window.show_view(game_over_view) # if character hits don't touch if arcade.check_for_collision_with_list(self.player_sprite, self.dont_touch_list): self.player_sprite.change_x = 0 self.player_sprite.change_y = 0 self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y # Set the camera to the start self.view_left = 0 self.view_bottom = 0 changed_viewport = True arcade.play_sound(self.game_over) self.health -= 1 # Scroll left left_boundary = self.view_left + LEFT_VIEWPORT_MARGIN if self.player_sprite.left < left_boundary: self.view_left -= left_boundary - self.player_sprite.left changed_viewport = True # Scroll right right_boundary = self.view_left + SCREEN_WIDTH - RIGHT_VIEWPORT_MARGIN if self.player_sprite.right > right_boundary: self.view_left += self.player_sprite.right - right_boundary changed_viewport = True # Scroll up top_boundary = self.view_bottom + SCREEN_HEIGHT - TOP_VIEWPORT_MARGIN if self.player_sprite.top > top_boundary: self.view_bottom += self.player_sprite.top - top_boundary changed_viewport = True # Scroll down bottom_boundary = self.view_bottom + BOTTOM_VIEWPORT_MARGIN if self.player_sprite.bottom < bottom_boundary: self.view_bottom -= bottom_boundary - self.player_sprite.bottom changed_viewport = True if changed_viewport: self.view_bottom = int(self.view_bottom) self.view_left = int(self.view_left) # Done the Scrolling arcade.set_viewport(self.view_left, SCREEN_WIDTH + self.view_left, self.view_bottom, SCREEN_HEIGHT + self.view_bottom)
def update(self, delta_time): self.crosshair_list.update() self.health_list.update() self.player_health() self.slime_list.update() self.spider_list.update() self.rogue_list.update() self.door_list.update() self.fireball_list.update() self.fireball_list.update_animation() self.bolt_list.update() self.bolt_list.update_animation() self.player_list.update() self.player_list.update_animation() self.slime_spawn_timer += delta_time self.spider_spawn_timer += delta_time self.rogue_spawn_timer += delta_time if self.fireball_timer > 0: self.fireball_timer -= delta_time if self.bolt_timer > 0: self.bolt_timer -= delta_time if self.stage_timer > 0: self.stage_timer -= delta_time if self.loading_screen_timer > 0: self.loading_screen_timer -= delta_time #animation_clocks self.animation_timer_2 -= delta_time if self.animation_timer_2 < 0.75 and self.animation_timer_2 > 0.5: self.animation_clock_2 = 1 self.animation_timer_2 = 1.5 if self.animation_timer_2 < 1.25 and self.animation_timer_2 > 1: self.animation_clock_2 = 2 self.animation_timer_2 = 1 self.animation_timer_3 -= delta_time if self.animation_timer_3 < 0.75 and self.animation_timer_3 > 0.5: self.animation_clock_3 = 1 self.animation_timer_3 = 1.5 if self.animation_timer_3 < 1.25 and self.animation_timer_3 > 1: self.animation_clock_3 = 2 self.animation_timer_3 = 2 if self.animation_timer_3 < 1.75 and self.animation_timer_3 > 1.5: self.animation_clock_3 = 3 self.animation_timer_3 = 1 #fireball_cast_animation if self.fireball_cast_timer > 0: self.fireball_cast_timer -= delta_time if self.fireball_cast_timer < 0.1 and self.player_move == False and self.shoot_cd == True: self.player.stand_right_textures.clear() self.player.stand_right_textures.append( arcade.load_texture("images/Mage_3.png", scale=self.player_scale)) self.player.stand_left_textures.clear() self.player.stand_left_textures.append( arcade.load_texture("images/Mage_3.png", scale=self.player_scale, mirrored=True)) self.fireball_cast_timer = 1 if self.fireball_cast_timer < 0.87 and self.fireball_cast_timer > 0.5 and self.player_move == False and self.shoot_cd == True: self.player.stand_right_textures.clear() self.player.stand_right_textures.append( arcade.load_texture("images/Mage_4.png", scale=self.player_scale)) self.player.stand_left_textures.clear() self.player.stand_left_textures.append( arcade.load_texture("images/Mage_4.png", scale=self.player_scale, mirrored=True)) self.fireball_cast_timer = 1.5 if self.fireball_cast_timer < 1.37 and self.fireball_cast_timer > 1 and self.player_move == False and self.shoot_cd == True: self.player.stand_right_textures.clear() self.player.stand_right_textures.append( arcade.load_texture("images/Mage_5.png", scale=self.player_scale)) self.player.stand_left_textures.clear() self.player.stand_left_textures.append( arcade.load_texture("images/Mage_5.png", scale=self.player_scale, mirrored=True)) self.fireball_cast_timer = 2 if self.fireball_cast_timer < 1.87 and self.fireball_cast_timer > 1.5 and self.player_move == False and self.shoot_cd == True: self.fireball() self.player.stand_right_textures.clear() self.player.stand_right_textures.append( arcade.load_texture("images/Mage_1.png", scale=self.player_scale)) self.player.stand_left_textures.clear() self.player.stand_left_textures.append( arcade.load_texture("images/Mage_1.png", scale=self.player_scale, mirrored=True)) self.fireball_cast_timer = 0 self.shoot_cd = False #animations for slime in self.slime_list: self.animation(slime, "slime", 2, self.slime_scale) for fireball in self.fireball_list: self.animation(fireball, "fireball", 3, self.fireball_scale) for spider in self.spider_list: if spider.center_x > self.player.center_x: self.animation(spider, "spider", 3, self.spider_scale, True) else: self.animation(spider, "spider", 3, self.spider_scale, False) #slime_movement + spawn if self.slime_spawn_timer > 2: self.slime_enemy() self.slime_spawn_timer = 0 for slime in self.slime_list: if self.player.center_x > slime.center_x: slime.change_x = 1 else: slime.change_x = -1 if self.player.center_y > slime.center_y: slime.change_y = 1 else: slime.change_y = -1 #spider movement & spawn if self.spider_spawn_timer > 5: self.spider_enemy() self.spider_spawn_timer = 0 try: ab = abs(x2) / x2 except ZeroDivisionError: ab = 0 x1 = x2 - self.evasion_cooldown * ab y1 = y2 - self.evasion_cooldown * ab for spider in self.spider_list: d1 = self.player.center_x - spider.center_x d2 = self.player.center_y - spider.center_y if d1 > 0: spider.change_x = 2 + x1 elif d1 == 0: spider.change_x = 2 + x1 else: spider.change_x = -2 + x1 if d2 > 0: spider.change_y = 2 + y1 elif d2 == 0: spider.change_y = 2 + y1 else: spider.change_y = -2 + y1 if x2 == 0: self.evasion_cooldown = 0 else: self.evasion_cooldown += 2 * delta_time if self.evasion_cooldown >= 4: self.evasion_cooldown = 4 if self.rogue_spawn_timer > 8: self.rogue_enemy() self.rogue_spawn_timer = 0 try: ab = abs(x4) / x4 except ZeroDivisionError: ab = 0 x3 = x4 - self.evasion_cooldown2 * ab y3 = y4 - self.evasion_cooldown2 * ab for rogue in self.rogue_list: if self.bolt_timer <= 0: self.bolt(rogue.center_x, rogue.center_y) d1 = self.player.center_x - rogue.center_x d2 = self.player.center_y - rogue.center_y d3 = (d1**2 + d2**2)**(1 / 2) f = 0 if d3 > 400: f = 0 if d3 > 350 and f == 0: if d1 > 0: rogue.change_x = 1 + x3 elif d1 == 0: rogue.change_x = 1 + x3 else: rogue.change_x = -1 + x3 if d2 > 0: rogue.change_y = 1 + y3 elif d2 == 0: rogue.change_y = 1 + y3 else: rogue.change_y = -1 + y3 else: f = 1 xc = self.player.center_x yc = self.player.center_y xr = rogue.center_x yr = rogue.center_y ac = math.atan2(yc - yr, xc - xr) rogue.change_x = math.sin(ac) * (-2) * (1 + x3) rogue.change_y = math.cos(ac) * 2 * (1 + y3) if x4 == 0: self.evasion_cooldown2 = 0 else: self.evasion_cooldown2 += 2 * delta_time if self.evasion_cooldown2 >= 2: self.evasion_cooldown2 = 2 #door if self.stage_timer < 0.01: if self.onetime_door == True: self.door() self.onetime_door = False door_hit_with_player = arcade.check_for_collision_with_list( self.player, self.door_list) for door in door_hit_with_player: self.stage += 1 self.player.center_x = screen_resolution_int(200) self.player.center_y = SCREEN_HEIGHT // 2 door.kill() self.stage_timer = 13 self.onetime_door = True self.slime_list = arcade.SpriteList() self.fireball_list = arcade.SpriteList() self.spider_list = arcade.SpriteList() self.loading_screen_on = 1 self.loading_screen_timer = 3 if self.loading_screen_timer > 2.8 and self.loading_screen_timer < 2.9: arcade.pause(2) self.loading_screen_on = 0 self.background = arcade.load_texture( file_name="images/background.png") self.animation_timer_2 = 4 self.animation_timer_3 = 4 #game_over if self.player_life < 1: arcade.close_window() print("Noob, you lost.") #hitboxes enemy_hit_with_player = arcade.check_for_collision_with_list( self.player, self.enemy_list) for enemy in enemy_hit_with_player: self.player_life -= 1 self.enemy_life -= 1 for enemy in self.enemy_list: enemy_hit_with_projectile = arcade.check_for_collision_with_list( enemy, self.fireball_list) for enemy_hit in enemy_hit_with_projectile: self.enemy_life -= 1 for enemy in self.enemy_list: if enemy.bottom > SCREEN_HEIGHT - screen_resolution_int( 150) or enemy.top < screen_resolution_int( 150) or enemy.right < screen_resolution_int( 150 ) or slime.left > SCREEN_WIDTH - screen_resolution_int( 150): self.enemy_life -= 1 #slime hitbox slime_hit_with_player = arcade.check_for_collision_with_list( self.player, self.slime_list) for slime in slime_hit_with_player: self.player_life -= 1 slime.kill() for slime in self.slime_list: slime_hit_with_projectile = arcade.check_for_collision_with_list( slime, self.fireball_list) for slime_hit in slime_hit_with_projectile: slime.kill() for slime in self.slime_list: if slime.bottom > SCREEN_HEIGHT - screen_resolution_int( 150) or slime.top < screen_resolution_int( 150) or slime.right < screen_resolution_int( 150 ) or slime.left > SCREEN_WIDTH - screen_resolution_int( 150): slime.kill() #spider hitbox spider_hit_with_player = arcade.check_for_collision_with_list( self.player, self.spider_list) for spider in spider_hit_with_player: self.player_life -= 1 spider.kill() for spider in self.spider_list: spider_hit_with_projectile = arcade.check_for_collision_with_list( spider, self.fireball_list) for spider_hit in spider_hit_with_projectile: spider.kill() for spider in self.spider_list: if spider.bottom > SCREEN_HEIGHT - screen_resolution_int( 150) or spider.top < screen_resolution_int( 150 ) or spider.right < screen_resolution_int( 150 ) or spider.left > SCREEN_WIDTH - screen_resolution_int( 150): spider.kill() #rogue hitbox rogue_hit_with_player = arcade.check_for_collision_with_list( self.player, self.rogue_list) for rogue in rogue_hit_with_player: self.player_life -= 1 rogue.kill() for rogue in self.rogue_list: rogue_hit_with_projectile = arcade.check_for_collision_with_list( rogue, self.fireball_list) for rogue_hit in rogue_hit_with_projectile: rogue.kill() for rogue in self.rogue_list: if rogue.bottom > SCREEN_HEIGHT - 150 or rogue.top < 150 or rogue.right < 150 or rogue.left > SCREEN_WIDTH - 150: rogue.kill() #wall_hitbox wall_down_hit_list = arcade.check_for_collision_with_list( self.player, self.wall_down_list) for wall in wall_down_hit_list: self.player.center_y += screen_resolution_int(5) wall_up_hit_list = arcade.check_for_collision_with_list( self.player, self.wall_up_list) for wall in wall_up_hit_list: self.player.center_y -= screen_resolution_int(5) wall_left_hit_list = arcade.check_for_collision_with_list( self.player, self.wall_left_list) for wall in wall_left_hit_list: self.player.center_x += screen_resolution_int(5) wall_right_hit_list = arcade.check_for_collision_with_list( self.player, self.wall_right_list) for wall in wall_right_hit_list: self.player.center_x -= screen_resolution_int(5) #fireball_hitbox for fireball in self.fireball_list: if fireball.bottom > SCREEN_HEIGHT - screen_resolution_int( 150) or fireball.top < screen_resolution_int( 150 ) or fireball.right < screen_resolution_int( 150 ) or fireball.left > SCREEN_WIDTH - screen_resolution_int( 150): fireball.kill() for bolt in self.bolt_list: if bolt.bottom > SCREEN_HEIGHT - 200 or bolt.top < 200 or bolt.right < 200 or bolt.left > SCREEN_WIDTH - 200: bolt.kill() #bolt_hitbox bolt_hit_with_player = arcade.check_for_collision_with_list( self.player, self.bolt_list) for bolt in bolt_hit_with_player: self.player_life -= 1 bolt.kill() for bolt in self.bolt_list: bolt_hit_with_projectile = arcade.check_for_collision_with_list( bolt, self.fireball_list) for bolt_hit in bolt_hit_with_projectile: bolt.kill()
if sprite_y == 550: arcade.sound.play_sound(fart_sound) y_dir = -10 if sprite_y == 50: arcade.sound.play_sound(fart_sound) #subprocess.Popen(["aplay", "raspberry.wav"]) y_dir = 10 sprite_x += x_dir sprite_y += y_dir # move the background if line_start < 49: line_start += 1 else: line_start = 0 # rotation if rot < 359: rot += 1 else: rot = 0 # draw render(sprite_x, sprite_y, line_start, rot) # wait a little bit arcade.pause(0.05)
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ # Start task with rest trial if self.firstTrial is True: self.display_rest() self.firstTrial = False # Calculate where to move the player sprite self.player_sprite.change_x = 0 self.player_sprite.change_y = 0 # Buffer data for 750 ms and process to determine which direction to go step_time = time.time() # want to take 1 second for step to update step_length = 1.750 # amount of time we want to use for calculation buffer = int(self.fs * step_length) data = np.zeros((buffer, self.channels)) #print(time.time()) #print('Buffering data') for idx in range(buffer): if self.EEGdevice == 7: # code to read in EEG from DSI-7 here tmp = 1 # just put something here to prevent indentation issues elif self.EEGdevice == 8: sample, timestamp = inlet.pull_sample() data[idx, :] = sample self.eeg_data = data #print(time.time()) #print('Processing data') self.classify_epoch() # TO DO #print(time.time()) #print('Data processed, decision made') """ print('#data#') print(data) print(data.shape) print('#filtered data#') print(filtered) print(filtered.shape) """ # Move the player sprite while time.time() - step_time < 2: #print('Waiting for step length') tmp = 1 # just do something until time is up pulseValue = 0 if self.move_left is True: # Left (right hemi power high = left hand) self.player_sprite.set_position( self.player_sprite.center_x - (WIDTH + MARGIN), self.player_sprite.center_y) direction_moved = 'left' pulseValue = 1 elif self.move_right is True: # Right self.player_sprite.set_position( self.player_sprite.center_x + WIDTH + MARGIN, self.player_sprite.center_y) direction_moved = 'right' pulseValue = 2 # Call update on all sprites self.player_list.update() self.target_list.update() self.ITI_list.update() # Send pulses move_time = clock.getTime() if self.EEGdevice == 7: # Audio beep to send pulse to sync box play_sound('C') elif self.EEGdevice == 8: # Send pulse through LSL, 1 if left, 2 if right self.outlet.push_sample([pulseValue]) # Store task data taskData.loc[moveCount] = pd.Series([move_time, \ self.player_sprite.center_x, self.player_sprite.center_y, \ self.target_sprite.center_x, self.target_sprite.center_y, \ direction_moved, self.score], \ index=self.taskData_col_names) increment() # End trial if time is up if time.time() - self.trialTime >= self.trialLength: arcade.start_render() arcade.draw_rectangle_filled(center_x=self.player_sprite.center_x, center_y=self.player_sprite.center_y, width=WIDTH, height=HEIGHT, color=arcade.color.RED) arcade.finish_render() arcade.pause(1) for target in self.target_list: target.kill() self.display_rest() self.create_target() # Generate list of all targets that collided with the player target_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.target_list) # Change color of cursor on top of target hitTarget = False for target in target_hit_list: hitTarget = True if hitTarget is True: arcade.start_render() arcade.draw_rectangle_filled(center_x=self.player_sprite.center_x, center_y=self.player_sprite.center_y, width=WIDTH, height=HEIGHT, color=arcade.color.GREEN) arcade.finish_render() arcade.pause(1) # Loop through each colliding sprite, removing it, and adding to the score for target in target_hit_list: target.kill() self.display_rest() self.score += 1 self.create_target()
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ # Calculate where to move the player sprite self.player_sprite.change_x = 0 self.player_sprite.change_y = 0 if self.can_move is True: if self.left_pressed and not self.right_pressed: self.player_sprite.set_position( self.player_sprite.center_x - (WIDTH + MARGIN), self.player_sprite.center_y) self.can_move = False elif self.right_pressed and not self.left_pressed: self.player_sprite.set_position( self.player_sprite.center_x + WIDTH + MARGIN, self.player_sprite.center_y) self.can_move = False # Call update on all sprites self.player_list.update() self.target_list.update() self.ITI_list.update() # End trial if time is up if time.time() - self.trialTime >= self.trialLength: arcade.start_render() arcade.draw_rectangle_filled(center_x=self.player_sprite.center_x, center_y=self.player_sprite.center_y, width=WIDTH, height=HEIGHT, color=arcade.color.RED) arcade.finish_render() arcade.pause(1) for target in self.target_list: target.kill() self.display_rest() self.create_target() # Generate list of all targets that collided with the player target_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.target_list) # Change color of cursor on top of target hitTarget = False for target in target_hit_list: hitTarget = True if hitTarget is True: arcade.start_render() arcade.draw_rectangle_filled(center_x=self.player_sprite.center_x, center_y=self.player_sprite.center_y, width=WIDTH, height=HEIGHT, color=arcade.color.GREEN) arcade.finish_render() arcade.pause(1) # Loop through each colliding sprite, removing it, and adding to the score for target in target_hit_list: target.kill() self.display_rest() self.score += 1 self.create_target()
def game_over(self): arcade.pause(1) arcade.close_window()
def perform_game_over(self): arcade.play_sound(self.player_death_sound) arcade.pause(2) arcade.play_sound(self.losing_ending_sound)