def update(self): if self.score < 0: return else: self.throw += 1 self.movement() if self.throw == 30: self.create() self.throw = 0 for Cookie in self.Cookie: if arcade.check_for_collision(Cookie, self.Snoopy): self.Cookie.remove(Cookie) if self.score > 100: self.score += 2 else: self.score += 2 if Cookie.center_y < 0: self.Cookie.remove(Cookie) Cookie.update() for Bomb in self.Bomb: if arcade.check_for_collision(Bomb, self.Snoopy): self.Bomb.remove(Bomb) if self.score > 100: # self.score -= randint(35,115) self.score -= 5 else: # self.score -= randint(15,40) self.score -= 5 if Bomb.center_y < 0: self.Bomb.remove(Bomb) Bomb.update()
def on_update(self, delta_time): self.physics_engine1.update() self.physics_engine2.update() self.ball_Sprite.update() self.total_time += delta_time if arcade.check_for_collision_with_list(self.ball_Sprite, self.limite_list_L): self.Rscore += 1 # self.counter_time = self.total_time # self.message = str(int(self.counter_time)) self.ball_Sprite.center_y = 300 self.ball_Sprite.center_x = 500 self.ball_Sprite.change_x = random.randrange(1, 3) self.ball_Sprite.change_y = random.randrange(1, 3) if arcade.check_for_collision_with_list(self.ball_Sprite, self.limite_list_R): self.Lscore += 1 self.ball_Sprite.center_y = 300 self.ball_Sprite.center_x = 500 self.ball_Sprite.change_x = random.randrange(1, 3) self.ball_Sprite.change_y = random.randrange(1, 3) elif arcade.check_for_collision(self.ball_Sprite, self.barre1_Sprite): self.ball_Sprite.change_x *= -1.2 elif arcade.check_for_collision(self.ball_Sprite, self.barre2_Sprite): self.ball_Sprite.change_x *= -1.2 elif arcade.check_for_collision_with_list(self.ball_Sprite, self.wall_list): self.ball_Sprite.change_y *= -1
def on_draw(self): arcade.start_render() self.border = arcade.draw_rectangle_outline(165, 300, 310, 580, arcade.color.GRAY, border_width=3) self.center_line = arcade.draw_line(10, 300, 320, 300, arcade.color.GRAY) self.background_image.draw() self.shooting_circle1 = arcade.draw_circle_outline(165,10,55,arcade.color.BLUE,border_width=3) self.shooting_circle2 = arcade.draw_circle_outline(165,590,55,arcade.color.RED,border_width=3) self.shooting_circles_list.append(self.shooting_circle1) self.shooting_circles_list.append(self.shooting_circle2) self.hoops.draw() self.ball.draw() self.player_list.draw() player1_scored = arcade.check_for_collision(self.hoop1, self.ball) if not self.player_1_scoring: if player1_scored: self.player_1_scoring = True self.score1 += 1 arcade.draw_text("Player 1 Won!", 100, 400, arcade.color.BLUE, 20, font_name='comicsansms') player2_scored = arcade.check_for_collision(self.hoop2, self.ball) if not self.player_2_scoring: if player2_scored: self.player_2_scoring = True self.score1 += 1 arcade.draw_text("Player 2 Won!", 100, 200, arcade.color.RED, 20, font_name='comicsansms')
def update(self, delta_time): self.character.update() self.character_2.update() self.brick.update() if arcade.check_for_collision(self.character, self.brick): self.brick.left = self.character.right + 1 self.brick.change_x *= -1 self.brick.change_y = random.randint(-30, 30) if arcade.check_for_collision(self.character_2, self.brick): self.brick.right = self.character_2.left - 1 self.brick.change_x *= -1 self.brick.change_y = random.randint(-30, 30) if self.brick.bottom < 0: self.brick.bottom = 1 self.brick.change_y *= -1 if self.brick.top > SCREEN_HEIGHT: self.brick.top = SCREEN_HEIGHT - 1 self.brick.change_y *= -1 if self.brick.right < 0 or self.brick.left > SCREEN_WIDTH: self.brick.center_x = SCREEN_WIDTH / 2 self.brick.center_y = SCREEN_HEIGHT / 2 self.brick.change_x = 0 self.brick.change_y = 0
def update(self, delta_time): """Movement and game logic""" # Call update on all sprites # This moves the sprites based on each of their update functions (either the default or one you wrote) self.player_list.update() self.alien_list.update() self.wall_list.update() # Add any other game logic here # ----------COLLISIONS CODE----------- # Check for collisions with all walls if arcade.check_for_collision(self.player_sprite, self.leftWall): self.player_sprite.change_x *= -1 if arcade.check_for_collision(self.player_sprite, self.topWall): self.player_sprite.change_y *= -1 # check if any of the aliens have collided with a wall for alien in self.alien_list: if arcade.check_for_collision(alien, self.leftWall): alien.change_x *= -1 if arcade.check_for_collision(alien, self.topWall): alien.change_y *= -1 alien_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.alien_list) if len(alien_hit_list) > 0: self.level = GAME_OVER
def on_update(self, delta_time: float): self.player_list.update() self.ball_list.update() # Score if self.ball1_sprite.center_x < 0 or self.ball1_sprite.center_x > SCREEN_WIDTH: if self.ball1_sprite.center_x < 0: self.score2 += 1 if self.ball1_sprite.center_x > SCREEN_WIDTH: self.score1 += 1 self.set_default_ball_position() arcade.play_sound(self.sound_score) if self.score1 == GAME_WIN_SCORE or self.score2 == GAME_WIN_SCORE: self.set_game_state(GAME_STATE_END) else: self.set_game_state(GAME_STATE_WAIT) # If ball hits wall, bounce off if self.ball1_sprite.center_y < 0 or self.ball1_sprite.center_y > SCREEN_HEIGHT: self.ball1_sprite.change_y = -self.ball1_sprite.change_y arcade.play_sound(self.sound_bounce) # If ball hits a player kick it in opposite direction if arcade.check_for_collision(self.ball1_sprite, self.player1_sprite): rand_speed_x = random.randint(BALL_MOVEMENT_SPEED_MIN_X, BALL_MOVEMENT_SPEED_X) self.ball1_sprite.change_x = abs(rand_speed_x) arcade.play_sound(self.sound_hit_player1) if arcade.check_for_collision(self.ball1_sprite, self.player2_sprite): rand_speed_x = random.randint(BALL_MOVEMENT_SPEED_MIN_X, BALL_MOVEMENT_SPEED_X) self.ball1_sprite.change_x = -abs(rand_speed_x) arcade.play_sound(self.sound_hit_player2)
def on_key_press(self, key: int, modifiers: int): if key == arcade.key.LEFT: if self.sprite.center_x < 50: pass else: self.sprite.center_x = self.sprite.center_x - 50 for box in self.bottom_row: if self.sprite and arcade.check_for_collision( self.sprite, box): self.sprite.center_x = self.sprite.center_x + 50 if key == arcade.key.RIGHT: if self.sprite.center_x > SCREEN_WIDTH - 50: pass else: self.sprite.center_x = self.sprite.center_x + 50 for box in self.bottom_row: if self.sprite and arcade.check_for_collision( self.sprite, box): self.sprite.center_x = self.sprite.center_x - 50 if key == arcade.key.DOWN: self.sprite.change_y = -25 if key == arcade.key.M: # Toggle mute if not self.mute % 2 == 0: self.music.stop() self.mute = self.mute + 1 else: self.music.play(0.5) self.mute = self.mute + 1
def on_update(self, delta_time: float): if self.player_list[0].center_x > 320 or self.player_list[0].center_x < 10: self.player_list[0].center_x -= 10 if self.player_list[0].center_y > 295 or self.player_list[0].center_y < 10: self.player_list[0].center_y -= 10 if self.player_list[1].center_x > 320 or self.player_list[1].center_x < 10: self.player_list[1].center_x -= 10 if self.player_list[1].center_y > 590 or self.player_list[1].center_y < 295: self.player_list[1].center_y -= 10 self.player_list[0].update() self.player_list[1].update() # Keeps the ball moving self.ball.center_x += self.x_speed * delta_time self.ball.center_y += self.y_speed * delta_time if self.ball.center_x > 310 or self.ball.center_x < 20: self.x_speed *= -1 if self.ball.center_y > 580 or self.ball.center_y < 20: self.y_speed *= -1 first_player_collision = arcade.check_for_collision(self.player_list[0], self.ball) if first_player_collision: self.x_speed *= -1 self.y_speed *= -1 second_player_collision = arcade.check_for_collision(self.player_list[1], self.ball) if second_player_collision: self.x_speed *= -1 self.y_speed *= -1
def on_mouse_press(self, x: float, y: float, button: int, modifiers: int): if button == arcade.MOUSE_BUTTON_LEFT and arcade.check_for_collision(self.cursor, self.start_button): self.story_path += "1" self.level = "game in progress" elif button == arcade.MOUSE_BUTTON_LEFT and arcade.check_for_collision(self.cursor, self.left_box): self.story_path += "1" elif button == arcade.MOUSE_BUTTON_LEFT and arcade.check_for_collision(self.cursor, self.right_box): self.story_path += "2"
def HandleCollisions(self): #Alien and floor if len(self.aliens) > 0: if self.aliens[0].center_y < 30: self.aliens[0].remove_from_sprite_lists() self.levelCounter += 1 #Powerup and floor if len(self.powerups) > 0: if self.powerups[0].center_y < 30: self.powerups[0].remove_from_sprite_lists() #Powerups and toasty! for to in range(len(self.toasty)): for po in range(len(self.powerups)): if arcade.check_for_collision(self.powerups[po], self.toasty[to]): if self.powerups[po].alpha > 0: #Lightning: if self.powerups[po].name == "Lightning": self.powerups[po].alpha = 0 print("Pug time!") self.powerupTimer = 0 self.isInvincible = False self.isPugShooting = True #Coffee elif self.powerups[po].name == "Coffee": self.powerups[po].alpha = 0 print("Coffee time!") self.powerupTimer = 0 self.isPugShooting = False self.isInvincible = True self.coffee.append(Coffee(0, 0)) #Projectile and an alien for p in range(len(self.projectiles)): for a2 in range(len(self.aliens)): if arcade.check_for_collision(self.projectiles[p], self.aliens[a2]): if self.projectiles[p].alpha > 0 and self.aliens[ a2].alpha > 0: self.aliens[a2].alpha = 0 self.projectiles[p].alpha = 0 self.score += 50 self.levelCounter += 1 #Toasty and an alien for t in range(len(self.toasty)): for a3 in range(len(self.aliens)): if arcade.check_for_collision(self.toasty[0], self.aliens[a3]): if self.aliens[a3].alpha > 0: if not self.isInvincible: self.aliens[a3].alpha = 0 self.lives -= 1 else: self.aliens[a3].alpha = 0 self.score += 50
def update(self, delta_time): self.bullet_list.update() self.player.update() self.enemy_list.update() ''' if all enemies have been killed: restart ''' if (len(self.enemy_list) == 0): self.score += 1 self.setup() #increase enemy movement speed self.speed += 5 self.player.health = 10 ''' if player has been killed: restart ''' if self.player.health == 0: print("Game Over") print(self.score) sys.exit() ''' check for collison with player ''' for b in self.bullet_list: # check for collision collision = arcade.check_for_collision(self.player, b) # for every bullet that hits, decrease the hp and then see if it dies if collision and b.goodbullet == False: # e.kill() will remove the enemy sprite from the game self.player.health -= 1 b.kill() for e in self.enemy_list: if e.timesincebullet > random.randint(200, 400): x = e.center_x y = e.center_y - 15 bullet = Bullet((x,y),(0,-10),BULLET_DAMAGE, False) self.bullet_list.append(bullet) e.timesincebullet = 0 else: e.timesincebullet += 1 for b in self.bullet_list: if b.goodbullet == True: # check for collision collision = arcade.check_for_collision(e, b) # for every bullet that hits, decrease the hp and then see if it dies if collision: print("this was ran") # e.kill() will remove the enemy sprite from the game e.kill() b.kill()
def __check_collision(self): """ Verifica le collisioni :return: """ # ball vs paddle if arcade.check_for_collision(self.__paddle, self.__ball): # cambia direzione x, y # se la palla è sotto il bottom, setta la y di ball sopra self.__ball.change_y *= -1 self.__ball.change_x = ( self.__ball.center_x - self.__paddle.center_x) / self.__paddle.width if self.__ball.center_y <= Costanti.LEVEL_INFO['bottom']: self.__ball.center_y = Costanti.LEVEL_INFO[ 'bottom'] + Costanti.Ball_RADIUS + 1 # ball vs fine schermo if self.__ball.bottom < 0: # ferma la palla, scala una vita, se non ci sono più vite chiama game_over self.__ball.stop() self.__player['life'] -= 1 if self.__player['life'] == 0: self.__game_over() # ball vs brick for brick in self.__bricks: if arcade.check_for_collision(self.__ball, brick): # aggiorna il punteggio, se il brick è dead lo rimuove e aggiorna brick_count self.__player['score'] += brick.on_collide() if brick.dead: self.__bricks.remove(brick) self.__brick_count -= 1 # aggiusta le coordinate di ball a seconda di dove a colpito il brick if self.__ball.bottom - Costanti.Ball_RADIUS <= brick.top <= self.__ball.bottom + Costanti.Ball_RADIUS: # il brick è stato colpito da sopra self.__ball.change_y = (self.__ball.center_y - brick.center_y) / brick.height self.__ball.bottom = brick.top elif self.__ball.top - Costanti.Ball_RADIUS <= brick.bottom <= self.__ball.top + Costanti.Ball_RADIUS: # il brick è stato colpito da sotto self.__ball.change_y = (self.__ball.center_y - brick.center_y) / brick.height self.__ball.top = brick.bottom if self.__ball.right - Costanti.Ball_RADIUS <= brick.left <= self.__ball.right + Costanti.Ball_RADIUS: # il brick è stato colpito a sinistra self.__ball.change_x = (self.__ball.center_x - brick.center_x) / brick.width self.__ball.right = brick.left elif self.__ball.left - Costanti.Ball_RADIUS <= brick.right <= self.__ball.left + Costanti.Ball_RADIUS: # il brick è stato colpito a destra self.__ball.change_x = (self.__ball.center_x - brick.center_x) / brick.width self.__ball.left = brick.right
def update(self, delta_time): self.physics_engine.update() self.player.update_animation() self.player.update() self.enemy_list.update() #code dlya otskoka for enemy in self.enemy_list: if self.hp <= 0: return # collisia if ar.check_for_collision_with_list(enemy, self.collision_list): #code vupolnenie enemy.change_x *= -1 for coin in self.coin_list: if ar.check_for_collision(coin, self.player): self.coin += 1 coin.remove_from_sprite_lists() self.coin_sound.play(0.05) # if ar.check_for_collision(enemy,self.player): # self.hp -=1 # # self.player.center_x = 300 # # self.player.center_y = 300 # self.damage_sound.play(0.05) # for self.enemy_list in self.task: # if ar.check_for_collision(self.enemy_list,self.player): for vxod in self.vxod_list: if ar.check_for_collision(vxod, self.player) and self.map_number < 0: self.map_number *= -1 self.setup() for vxod in self.vxod_list: if ar.check_for_collision(vxod, self.player) and self.map_number > 0: self.map_number *= -1 self.comback = True self.setup() for finish in self.finish: if ar.check_for_collision(finish, self.player): game_over = GameOver() # присвоение основного класса игры self.window.show_view(game_over) # переход на другое окно for enemy_list in self.enemy_list: if ar.check_for_collision(self.player, enemy_list): self.question = True enemy_list.remove_from_sprite_lists() self.ran = random.randint(0, 2)
def on_update(self, delta_time): if self.escape == True: if arcade.check_for_collision(self.atrium_view.char5, self.atrium_view.opus): self.atrium_view.char5.update() self.atrium_view.char5.change_x = -1 self.atrium_view.char5.change_y = -1 elif arcade.check_for_collision(self.atrium_view.char5, self.atrium_view.opus) == False: self.escape = False atrium = self.atrium_view self.window.show_view(atrium) self.atrium_view.char5.change_x = 0 self.atrium_view.char5.change_y = 0
def add_ice(self): """ Adds ice to drinks. """ if self.drink != "Frappuccino": if arcade.check_for_collision(self.you, self.ice_station) and self.cup_empty == True: self.cup = arcade.Sprite("game1_images/ice_cup.png", scale=0.18, center_x=400, center_y=305) self.ice_done = True self.cup_empty = False elif self.drink == "Frappuccino": if arcade.check_for_collision(self.you, self.ice_station) and self.syrup_done == True: self.cup = arcade.Sprite("game1_images/syrup_ice.png", scale=0.18, center_x=400, center_y=305) self.ice_done = True self.syrup_done = False
def process_mouse_click(self) -> bool: """Processes the mouseclicks targeting the popup menu.""" if arcade.check_for_collision(self.cursor, self.bg): if arcade.check_for_collision(self.cursor, self.exit_button): while len(self.sprite_list) > 0: self.sprite_list.pop() del self return True self.dragged = True return True else: return False
def update(self, dt): if not self.is_on_ladder(): self.player.change_y -= self.gravity_constant * self.player.speed_multiplier * ( dt / (1 / 60)) _move_sprite(self.player, self.platforms, dt) for platform in self.platforms: if platform.change_x != 0 or platform.change_y != 0: platform.center_x += platform.change_x * self.player.speed_multiplier * ( dt / (1 / 60)) if platform.boundary_left is not None \ and platform.center_x <= platform.boundary_left: platform.center_x = platform.boundary_left if platform.change_x < 0: platform.change_x *= -1 if platform.boundary_right is not None \ and platform.center_x >= platform.boundary_right: platform.center_x = platform.boundary_right if platform.change_x > 0: platform.change_x *= -1 collision = arcade.check_for_collision(self.player, platform) if collision and not platform.change_y: if platform.change_x < 0: self.player.right = platform.left if platform.change_x > 0: self.player.left = platform.right platform.center_y += platform.change_y * self.player.speed_multiplier * ( dt / (1 / 60)) if platform.boundary_top is not None \ and platform.center_y >= platform.boundary_top: platform.center_y = platform.boundary_top if platform.change_y > 0: platform.change_y *= -1 if platform.boundary_bottom is not None \ and platform.center_y <= platform.boundary_bottom: platform.center_y = platform.boundary_bottom if platform.change_y < 0: platform.change_y *= -1 collision = arcade.check_for_collision(self.player, platform) if collision: if platform.change_y < 0 and self.player.change_y > 0: self.player.top = platform.bottom self.player.change_y = -3
def on_draw(self): arcade.start_render() #sprite lists self.tree_list.draw() self.chair_list.draw() self.table_list.draw() arcade.draw_rectangle_filled(745, 350, 95, 400, arcade.color.BANANA_MANIA) self.opus = arcade.Sprite("game1_images/opus.png",center_x=745,center_y=430,scale=0.1525) self.opus.draw() #characters self.char1.draw() self.char2.draw() self.char3.draw() self.char4.draw() self.char5.draw() #check collision -- THERE HAS TO BE A CLEANER WAY TO DO THIS?? if arcade.check_for_collision(self.char5,self.char1): self.speech1 = arcade.Sprite("game1_images/dialogue.png",scale=0.07, center_x=270,center_y=475) self.speech1.draw() arcade.draw_text("Have you\ntried Opus\ntoday?",272,477,arcade.color.BLACK,10, anchor_x="center",anchor_y="center",rotation=20) if arcade.check_for_collision(self.char5,self.char2): self.speech2 = arcade.Sprite("game1_images/dialogue270.png",scale=0.07, center_x=460,center_y=465) self.speech2.draw() arcade.draw_text("Aren't\nyou late\nfor\nwork??",461,465,arcade.color.BLACK,10, anchor_x="center",anchor_y="center",align="center",rotation=9) if arcade.check_for_collision(self.char5,self.char3): self.speech3 = arcade.Sprite("game1_images/dialogue90.png",scale=0.07, center_x=470,center_y=45) self.speech3.draw() arcade.draw_text("Have\nfun at\nwork!",467,49,arcade.color.BLACK,10, anchor_x="center",anchor_y="center",align="center",rotation=9) if arcade.check_for_collision(self.char5, self.char4): self.speech4 = arcade.Sprite("game1_images/dialogue270.png", scale=0.07, center_x=580, center_y=300) self.speech4.draw() arcade.draw_text("Have\nyou\ndone the\nhome-\nwork?", 580, 300, arcade.color.BLACK, 9, anchor_x="center",anchor_y="center",align="center",rotation=9) if arcade.check_for_collision(self.char5,self.opus): pause = PauseView(self) self.window.show_view(pause)
def update(self, delta_time): self.bottompipe_sprite.update() self.toppipe_sprite.update() self.all_sprites_list.update() thit = arcade.check_for_collision(self.player_sprite, self.toppipe_sprite) bhit = arcade.check_for_collision(self.player_sprite, self.bottompipe_sprite) if self.toppipe_sprite.center_x == 0: self.score += 1 if thit or bhit: self.player_sprite.kill() sys.exit()
def update(self, delta_time): """ Movement and game logic """ if self.game_over: return if arcade.check_for_collision(self.cactus, self.dino): arcade.play_sound(self.game_over_sound) self.game_over = True if self.going_up: self.dino.bottom += self.dino_up_speed if self.dino.bottom > 400: # This controls how high dino would jump self.going_up = False elif self.dino.bottom > 200: self.dino.bottom -= self.dino_down_speed if self.dino.bottom < 200: self.dino.bottom = 200 if self.cactus.right > 0: self.cactus.left -= self.cactus_speed else: self.score += 1 if self.score % 2 == 0 : self.dino_down_speed += 1 self.dino_up_speed += 5 self.cactus_speed += 1 arcade.play_sound(self.level_up_sound) self.cactus = random.choice(self.cactus_list) self.cactus.left = SCREEN_WIDTH
def on_update(self, delta_time): """ All the logic to move, and the game logic goes here. Normally, you'll call update() on the sprite lists that need it. """ # Calculate speed based on the keys pressed self.player_sprite.change_x = 0 self.player_sprite.change_y = 0 if self.W_pressed and not self.S_pressed: if self.player_sprite.center_y >= SCREEN_HEIGHT - 25: self.player_sprite.change_y = 0 else: self.player_sprite.change_y = MOVEMENT_SPEED elif self.S_pressed and not self.W_pressed: if self.player_sprite.center_y <= 105: self.player_sprite.change_y = 0 else: self.player_sprite.change_y = -MOVEMENT_SPEED if self.A_pressed and not self.D_pressed: if self.player_sprite.center_x <= 69: self.player_sprite.change_x = 0 else: self.player_sprite.change_x = -MOVEMENT_SPEED elif self.D_pressed and not self.A_pressed: if self.player_sprite.center_x >= SCREEN_WIDTH - 65: self.player_sprite.change_x = 0 else: self.player_sprite.change_x = MOVEMENT_SPEED # Check if zombie is hit by player attack for zombie in self.zombie_list: zombie.follow_sprite(self.player_sprite) if self.player_sprite.alpha == 254: if (self.player_sprite.center_y - 30 <= zombie.center_y <= self.player_sprite.center_y + 90) and \ (self.player_sprite.center_x - 80 <= zombie.center_x <= self.player_sprite.center_x + 80): if (self.player_sprite.right_facing() and not zombie.right_facing()) or \ (not self.player_sprite.right_facing() and zombie.right_facing()) or \ ((self.player_sprite.center_y - 30 <= zombie.center_y <= self.player_sprite.center_y + 90) and (self.player_sprite.center_x - 30 <= zombie.center_x <= self.player_sprite.center_x + 30)): zombie.alpha = 150 if arcade.check_for_collision(self.player_sprite, zombie) and zombie.alpha == 255: if self.health_bar.width > 0: self.health_bar.width -= ZOMBIE_DAMAGE self.health_bar.x -= ZOMBIE_DAMAGE/2 else: game_over = GameOverView() self.window.show_view(game_over) if not self.zombie_list: game_won = VictoryView() self.window.show_view(game_won) # Call update to move the sprite self.player_list.update() self.player_list.update_animation() self.zombie_list.update_animation()
def on_draw(self): arcade.start_render() arcade.draw_lrwh_rectangle_textured( 0, 0, constants.LEVEL_WIDTH, self.window.h, # 100 x 9 level self.background) self.platform_list.draw() self.enemy_list.draw() self.cashier.draw() self.player_list.draw() self.window.item_list.draw() tp_amount = arcade.load_texture( "assets/amounts/toilet_paper_amount.png") scale = 1 arcade.draw_scaled_texture_rectangle( max(120, self.view_left + 70), self.window.h - 35, tp_amount, scale, 0) score_text = f"{self.window.score}" arcade.draw_text(score_text, max(94, self.view_left + 44), self.window.h - 50, arcade.csscolor.BLACK, 18) if self.window.score < self.window.goal and arcade.check_for_collision(self.player, self.cashier): arcade.draw_text("Come back with 15 items", self.view_left + self.window.w / 2, self.window.h - 50, arcade.csscolor.CRIMSON, 24, anchor_x="center") elif self.window.score >= self.window.goal: arcade.draw_text("Find the cashier to checkout", self.view_left + self.window.w / 2, self.window.h - 50, arcade.csscolor.CRIMSON, 24, anchor_x="center")
def on_mouse_release(self, x: float, y: float, button: int, modifiers: int): """ Called when the user presses a mouse button. """ # If we don't have any cards, who cares if len(self.held_cards) == 0: return # Find the closest pile, in case we are in contact with more than one pile, distance = arcade.get_closest_sprite(self.held_cards[0], self.pile_mat_list) reset_position = True # See if we are in contact with the closest pile if arcade.check_for_collision(self.held_cards[0], pile): # For each held card, move it to the pile we dropped on for i, dropped_card in enumerate(self.held_cards): # Move cards to proper position dropped_card.position = pile.center_x, pile.center_y # Success, don't reset position of cards reset_position = False # Release on top play pile? And only one card held? if reset_position: # Where-ever we were dropped, it wasn't valid. Reset the each card's position # to its original spot. for pile_index, card in enumerate(self.held_cards): card.position = self.held_cards_original_position[pile_index] # We are no longer holding cards self.held_cards = []
def on_update(self, delta_time): # Check for WADS keys and perform movement dx, dy = 0, 0 if 'w' in self.keys_pressed: dy += self.movement if 's' in self.keys_pressed: dy -= self.movement if 'a' in self.keys_pressed: dx -= self.movement if 'd' in self.keys_pressed: dx += self.movement self.player_sprite.change_x = dx self.player_sprite.change_y = dy mouse_x, mouse_y = self.mouse_location angle_deg = angle_to_point(self.player_sprite, mouse_x, mouse_y) self.player_sprite.angle = angle_deg - 90 # Orient all enemies to player location for enemy in self.enemies_list: angle_deg = angle_to_sprite(enemy, self.player_sprite) enemy.angle = angle_deg + 90 if arcade.check_for_collision(enemy, self.player_sprite): enemy.change_x = 0 enemy.change_y = 0 else: dx, dy = vector_from_angle(enemy.angle - 90) enemy_speed = 1 enemy.change_x = dx * enemy_speed enemy.change_y = dy * enemy_speed # Update our sprites self.player_sprite.update() self.powerup_list.update() self.bullet_list.update() self.enemies_list.update() # Update the viewport self.reset_viewport() # Do collision detection powerup_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.powerup_list) for powerup in powerup_hit_list: powerup.remove_from_sprite_lists() self.score += 1 if powerup_hit_list: print(self.score) # Test for bullets leaving viewport v_min_x, v_max_x, v_min_y, v_max_y = self.viewport for bullet in self.bullet_list: bx, by = bullet.position if bx > v_max_x or bx < v_min_x or by < v_min_y or by > v_max_y: bullet.remove_from_sprite_lists()
def coffee_booster(self): image_source = "/Users/lutelillo/Desktop/DebugTheBug/lib/python3.8/" \ "site-packages/arcade/resources/images/createdSprites/coffee_boost.png" # Create the booster if self.actual_round == 1 and self.coffee_count < 1: self.coffee_sprite = arcade.Sprite(image_source, BOOSTER_SCALING) rand_center_x = random.randrange(SCREEN_WIDTH) rand_center_y = random.randrange(SCREEN_HEIGHT) self.coffee_sprite.center_x = rand_center_x self.coffee_sprite.center_y = rand_center_y self.coffee_list.append(self.coffee_sprite) self.coffee_count += 1 # Check if player picks it up for coffee in self.coffee_list: if arcade.check_for_collision(self.player1.player_sprite, coffee): arcade.play_sound(self.pick_booster_sound) self.coffee_list.pop().remove_from_sprite_lists() self.boosted = True # Create visual aid to indicate that the booster has been picked up boost_source = "/Users/lutelillo/Desktop/DebugTheBug/lib/python3.8/" \ "site-packages/arcade/resources/images/createdSprites/powerup.png" self.booster_sprite = arcade.Sprite(boost_source, BOOSTER_SCALING) self.booster_sprite.center_x = 50 self.booster_sprite.center_y = SCREEN_HEIGHT - 50 self.boost_list.append(self.booster_sprite)
def on_update(self, delta_time): """ Movement and game logic """ # Call update on all sprites (The sprites don't do much in this # example though.) self.coin_list.update() # Generate a list of all sprites that collided with the player. coins_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.coin_list) # Loop through each colliding sprite to set intensity=bright for coin in coins_hit_list: coin.intensity = 'bright' coin.alpha = 255 hit_trigger = arcade.check_for_collision(self.player_sprite, self.trigger_sprite) if hit_trigger: intense_sprites = [ sprite for sprite in self.coin_list if sprite.intensity == 'bright' ] for coin in intense_sprites: coin.remove_from_sprite_lists()
def update(self, delta_time): if self.running: self.player_sprite.update() for enemy in self.enemy_list: enemy.change_x = -ENEMY_MOVEMENT_SPEED * delta_time enemy.change_y = 0 enemy.update() for shot in self.shot_list: shot.change_x = SHOT_MOVEMENT_SPEED * delta_time shot.change_y = 0 shot.update() if random.random() < ENEMY_GENERATION_PROBABILITY: enemy_sprite = Enemy(os.path.join(IMG_FOLDER, "enemy.png"), SPRITE_SCALING_ENEMY) self.enemy_list.append(enemy_sprite) enemy_sprite.center_x = SCREEN_WIDTH enemy_sprite.center_y = random.randint( ENEMY_SCREEN_SPACING, SCREEN_HEIGHT - ENEMY_SCREEN_SPACING) for enemy in self.enemy_list: for shot in self.shot_list: if arcade.check_for_collision(enemy, shot): self.enemy_list.remove(enemy) self.shot_list.remove(shot) self.score += 1 if enemy.center_x - enemy.width / 2 < 0: self.stop_game() self.total_time += delta_time if self.total_time > GAME_TIME: self.win = True self.stop_game()
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ for monster in self.monster_list: monster.center_x += sign(self.player_sprite.center_x - monster.center_x) monster.center_y += sign(self.player_sprite.center_y - monster.center_y) caught = arcade.check_for_collision(self.player_sprite, self.rabbit_sprite) if caught: self.alive = False self.player_sprite.texture = arcade.load_texture( 'bloodsplats_0004.png') self.player_list.draw() self.monster_list.draw() self.physics_engine.update() if self.player_sprite.center_x > SCREEN_WIDTH: self.won = True self.score += 100 while not self.clap_queue.empty(): self.clap_queue.get() self.player_sprite.center_x += MOVEMENT_SPEED
def fly_carole_fly(): global jump_score carole = part_list[3] body = part_list[2] carole.change_x += 0.1 if jumping and 0 <= carole.change_y: carole.change_y += 4.5 if falling: carole.change_y -= 1 if carole.center_y > jump_score: jump_score = carole.center_y if carole.center_y <= body.center_y - 18: global carole_is_flying carole.change_x = 0 carole.change_y = 0 carole.center_y = body.center_y + 10 catch = arcade.check_for_collision(carole, part_list[2]) if catch: if carole.center_x <= body.center_x - 50 or carole.center_x >= body.center_x + 50: game_over() else: add_points(jump_score - GROUND) jump_score = 0 else: game_over() carole_is_flying = False
def on_update(self, delta_time): self.ball_sprite.center_x += self.dx self.ball_sprite.center_y += self.dy self.box_rec_list.update() if self.ball_sprite.center_x < 5 or self.ball_sprite.center_x > SCREEN_WIDTH - 5: self.dx *= -1 if self.ball_sprite.center_y > SCREEN_HEIGHT - 5: self.dy *= -1 if arcade.check_for_collision( self.player_sprite, self.ball_sprite ) and self.player_sprite.center_y < self.ball_sprite.center_y: self.dy *= -1 hit_list_blue = arcade.check_for_collision_with_list( self.ball_sprite, self.box_rec_list) for box_rec in hit_list_blue: if self.ball_sprite.center_y <= box_rec.center_y - 32 or self.ball_sprite.center_y >= box_rec.center_y + 32: self.dx *= 1 self.dy *= -1 else: self.dx *= -1 self.dy *= 1 box_rec.remove_from_sprite_lists() self.score += 1 if self.ball_sprite.center_y < 0: start = StartView() self.window.show_view(start)