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)
