def fire(self, mouse):
spell = Projectile(mouse=mouse, position=self.surface.position)
self.surface.parent.add_projectile(spell)
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0:
cball.update(time)
print("\nDistance Traveled: {0:0.1f}meters.".format(cball.getX()))
def launch_projectile(self):
self.all_projectiles.add(Projectile(self))
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0:
cball.update(time)
print("\nDistance traveled: %0.1f meters." % (cball.getX()))
def start_of_game(self):
#this is the start of the game
#this creates the player object
self.player = ship(self.canvas, self.width, self.height, master=self)
#this starts the creation of all asteroids
self.make_asteroids()
#get random number which decides which 6 asteroids to start with
#loop through a list of different sized asteroids
for i in range(6):
x = self.get_random_size()
if x == 1:
for i in self.small_asteroids:
#if it is frozen then unfreeze it and break from the loop for the next asteroid
if i.freeze == True:
i.freeze = False
break
elif x == 2:
for i in self.medium_asteroids:
if i.freeze == True:
#if it is frozen then unfreeze it and break from the loop for the next asteroid
i.freeze = False
break
else:
for i in self.large_asteroids:
if i.freeze == True:
#if it is frozen then unfreeze it and break from the loop for the next asteroid
i.freeze = False
break
#this creates all the projectiles
self.pro1 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro2 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro3 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro4 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro5 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro6 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro7 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro8 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro9 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
self.pro10 = Projectile(self.player, self.canvas, self.width,
self.height, self.asteroids, self)
#this creates a list of all the projectiles
self.projectiles = []
self.projectiles.append(self.pro1)
self.projectiles.append(self.pro2)
self.projectiles.append(self.pro3)
self.projectiles.append(self.pro4)
self.projectiles.append(self.pro5)
self.projectiles.append(self.pro6)
self.projectiles.append(self.pro7)
self.projectiles.append(self.pro8)
self.projectiles.append(self.pro9)
self.projectiles.append(self.pro10)
#this calls the setup_bindings() method
self.setup_bindings()
#this starts the asteroids movement loop
for i in self.asteroids:
i.hold()
def projectile_attack(self):
self.all_projectiles.add(Projectile(self))
def launch_projectile(self):
#creer une nouvelle instance de la classe projectile
self.all_projectiles.add(Projectile(self))
self.game.sound_manager.play('tir')
def main():
def create_particles(number, x, y, image):
for count in range(number):
for particle_count in range(MAX_PARTICLES):
if particles[particle_count].active == False:
particles[particle_count].active = True
particles[particle_count].rect.left = x
particles[particle_count].rect.top = y
particles[particle_count].image = image
if number > 15:
particles[particle_count].move_count = random.randint(20, 30)
else:
particles[particle_count].move_count = random.randint(10, 17)
if random.randint(0, 10) > 5:
particles[particle_count].vector_x = 0 - random.randint(0, 4)
particles[particle_count].vector_y = 0 - random.randint(0, 4)
else:
particles[particle_count].vector_x = random.randint(0, 4)
particles[particle_count].vector_y = random.randint(0, 4)
break
# Game Constants..
SCREEN_HEIGHT = 468
SCREEN_WIDTH = 640
high_score = 750000
TITLE_SCREEN_MODE = 1
GAME_MODE = 2
FPS = 60
NUMBER_OF_LIVES = 6
MAX_ENEMIES = 15
PLAYER_BULLETS = 40
MAX_ENEMY_BULLETS = 30
MAX_UFOS = 1
MAX_PARTICLES = 200
# Counters..
attack_timer = 0
attack_max = 70
ufo_attack_timer = 0
ufo_attack_max = 500
max_enemy_speed = 2
max_ufo_speed = 2
game_wave = 1
enemy_killed = 0
wave_break = 100
wave_target_kills = 50
game_over = False
game_over_timer = 500
game_victory = False
game_victory_particle_timer = 0
player_score = 0
player_lives = 7
player_flash_timer = 0
player_flash_on = False
# Game control stuff..
game_mode = TITLE_SCREEN_MODE
title_menu_choice = 0
title_lit_message = True
beaten_high_score = False
enemy_fire_timer = 0
enemy_fire_max = 50
title_freeplay_timer = 0
title_freeplay_on = False
# Init the game and creating the display surface..
pygame.init()
screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])
#SCREEN_WIDTH, SCREEN_HEIGHT = screen.get_size()
pygame.display.set_caption("Squadron: Yet Another Arcade Game!")
clock = pygame.time.Clock()
# Creating game fonts..
pygame.font.init()
game_font = pygame.font.Font(os.path.join("gfx", "04b_25__.ttf"), 18)
game_font_large = pygame.font.Font(os.path.join("gfx", "04b_25__.ttf"), 36)
game_font_xl = pygame.font.Font(os.path.join("gfx", "04b_25__.ttf"), 46)
# Show loading message...
screen.fill((0,0,0))
screen.blit(game_font.render("Loading....", 0, ((176, 0, 0))), (270, SCREEN_HEIGHT / 2 - 36))
pygame.display.flip()
# Loading game gfx..
player_bullet_image = pygame.image.load(os.path.join("gfx", "bullet1.png")).convert()
enemy_bullet_image = pygame.image.load(os.path.join("gfx", "bullet2.png")).convert()
invader_image = pygame.image.load(os.path.join("gfx", "invader.png")).convert()
shooter_image = pygame.image.load(os.path.join("gfx", "shooter_invaders.png")).convert()
transient_image = pygame.image.load(os.path.join("gfx", "Transient.png")).convert()
ufo_image = pygame.image.load(os.path.join("gfx", "ufo.png")).convert()
player_health_image = pygame.Surface((8, 16))
player_health_image.fill((176, 0, 0))
# Sort the sound driver
pygame.mixer.quit()
sound = pygame.mixer.init()
# Loading all game sounds..
damage_sound = pygame.mixer.Sound(os.path.join("sound", "damage.wav"))
exit_sound = pygame.mixer.Sound(os.path.join("sound", "exit.wav"))
expolde_sound = pygame.mixer.Sound(os.path.join("sound", "explode1.wav"))
lazer_sound = pygame.mixer.Sound(os.path.join("sound", "lazer.wav"))
menu_mov_sound = pygame.mixer.Sound(os.path.join("sound", "menu_move.wav"))
menu_select_sound = pygame.mixer.Sound(os.path.join("sound", "menu_select.wav"))
wave_sound = pygame.mixer.Sound(os.path.join("sound", "newwave.wav"))
player_dead_sound = pygame.mixer.Sound(os.path.join("sound", "player_dead.wav"))
shoot2_sound = pygame.mixer.Sound(os.path.join("sound", "shoot2.wav"))
start_sound = pygame.mixer.Sound(os.path.join("sound", "start.wav"))
ufo_sound = pygame.mixer.Sound(os.path.join("sound", "ufo.wav"))
ufo_sound.set_volume(0.35)
win_sound = pygame.mixer.Sound(os.path.join("sound", "win.wav"))
# Create some particle images..
red_particle_image = pygame.Surface((8, 8))
red_particle_image.fill((176, 0, 0))
green_particle_image = pygame.Surface((8, 8))
green_particle_image.fill((31, 92, 14))
blue_particle_image = pygame.Surface((8, 8))
blue_particle_image.fill((46, 102, 187))
yellow_particle_image = pygame.Surface((8, 8))
yellow_particle_image.fill((255, 206, 0))
gray_particle_image = pygame.Surface((8, 8))
gray_particle_image.fill((88, 88, 88))
# Create the players... TODO: Clean this!
#player_side = Player(SCREEN_WIDTH, SCREEN_HEIGHT, side= True)
#player_bottom = Player(SCREEN_WIDTH, SCREEN_HEIGHT, bottom= True)
player_bottom = PlayerBottom(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH / 2, SCREEN_HEIGHT - 35)
player_side = PlayerSide(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH -35, SCREEN_HEIGHT / 2)
player_score = 0
player_fire_rate = 5
player_fire_delay_right = 0
player_fire_delay_left = 0
player_shield = 9
player_lives = 10
player_flash_on = False
player_flash_timer = 0
# Prepare the player pointed projectiles!
player_bullets = []
for count in range(PLAYER_BULLETS):
player_bullets.append(Projectile(SCREEN_WIDTH, SCREEN_HEIGHT, player_bullet_image))
player_bullets[count].active = False
# Enemy bullets..
enemy_bullets = []
for count in range(MAX_ENEMY_BULLETS):
enemy_bullets.append(Projectile(SCREEN_WIDTH, SCREEN_HEIGHT, enemy_bullet_image))
enemy_bullets[count].active = False
# Prepare enemies..
invaders = []
shooter_invaders = []
transient_invaders = []
for count in range (MAX_ENEMIES):
# invaders
invaders.append(Enemy(SCREEN_WIDTH, SCREEN_HEIGHT, invader_image))
invaders[count].rect.top = 0
invaders[count].rect.left = 0
invaders[count].vector_x = 0
invaders[count].vector_y = 0
invaders[count].active = False
invaders[count].anim_max_frame = 3
invaders[count].movement_type = 0
# shooter invaders
shooter_invaders.append(Enemy(SCREEN_WIDTH, SCREEN_HEIGHT, shooter_image))
shooter_invaders[count].rect.top = 0
shooter_invaders[count].rect.left = 0
shooter_invaders[count].vector_x = 0
shooter_invaders[count].vector_y = 0
shooter_invaders[count].active = False
shooter_invaders[count].anim_max_frame = 3
shooter_invaders[count].movement_type = 0
# transient invaders
transient_invaders.append(Enemy(SCREEN_WIDTH, SCREEN_HEIGHT, transient_image))
transient_invaders[count].rect.top = 0
transient_invaders[count].rect.left = 0
transient_invaders[count].vector_x = 0
transient_invaders[count].vector_y = 0
transient_invaders[count].active = False
transient_invaders[count].anim_max_frame = 3
transient_invaders[count].movement_type = 1
ufos = []
for count in range(MAX_UFOS):
ufos.append(Enemy(SCREEN_WIDTH, SCREEN_HEIGHT, ufo_image))
ufos[count].anim_max_frame = 9
particles = []
for count in range(MAX_PARTICLES):
particles.append(Particle(SCREEN_WIDTH, SCREEN_HEIGHT, red_particle_image))
particles[count].active = False
#<<<><><><><><>||MAIN LOOP||<><><><><><><><>>>#
#<<<><><><><><><><><><><><><><><><><><><><>>>>#
main_loop = True
enemies_onscreen = False
while main_loop:
# Clear the screen (NOTE: This is not particularly efficient, but deadline is looming!)
screen.fill((0,0,0))
# Check the game mode if TITLE_SCREEN_MODE
if game_mode == TITLE_SCREEN_MODE:
#-----------------------#
#----||TITLE SCREEN||---#
#-----------------------#
# Render the game title..
screen.blit(game_font_xl.render("Squadron", 0, ((255, 206, 0))), (230, 100))
title_freeplay_timer += 1
if title_freeplay_timer > 30:
title_freeplay_timer = 0
if title_freeplay_on == True:
title_freeplay_on = False
else:
title_freeplay_on = True
if title_freeplay_on == True:
screen.blit(game_font.render("Insert Coin", 0, ((175, 175, 175))), (280, 380))
if title_menu_choice == 1:
screen.blit(game_font.render("Start", 0, ((255, 206, 0))), (300, 225))
else:
screen.blit(game_font.render("Start", 0, ((176, 0, 0))), (300, 225))
if title_menu_choice == 0:
screen.blit(game_font.render("Exit", 0, ((255, 206, 0))), (308, 250))
else:
screen.blit(game_font.render("Exit", 0, ((176, 0, 0))), (308, 250))
screen.blit(game_font.render("Z and X to fire, cursor keys control both ships", 0, ((176, 0, 0))), (120, 450))
# Screen Events...
for event in pygame.event.get():
if event.type == pygame.QUIT:
main_loop = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
menu_mov_sound.play()
title_menu_choice -= 1
if title_menu_choice < 0:
title_menu_choice = 0
if event.key == pygame.K_DOWN:
title_menu_choice += 1
menu_mov_sound.play()
if title_menu_choice > 1:
title_menu_choice = 1
if event.key == pygame.K_ESCAPE:
main_loop = False
if event.key == pygame.K_z or event.key == pygame.K_x or event.key == pygame.K_SPACE or event.key == pygame.K_RETURN:
if title_menu_choice == 0:
# Start the games
start_sound.play()
game_mode = GAME_MODE # Switch to the game play mode
attack_timer = 0
attack_max = 70
ufo_attack_timer = 0
ufo_attack_max = 500
max_enemy_speed = 2
max_ufo_speed = 2
beaten_high_score = False
game_wave = 1
enemy_killed = 0
wave_break = 100
wave_target_kills = 50
game_over = False
game_over_timer = 500
game_victory = False
game_victory_particle_timer = 0
enemy_fire_timer = 0
enemy_fire_max = 50
player_fire_delay_left = 0
player_fire_delay_right = 0
player_score = 0
player_shield = 9
player_lives = 7
player_flash_timer = 0
player_flash_on = False
# Deactivate all enemies, particles, bullets
for count in range(MAX_ENEMIES):
invaders[count].active = False
shooter_invaders[count].active = False
transient_invaders[count].active = False
for count in range(MAX_PARTICLES):
particles[count].active = False
for count in range(PLAYER_BULLETS):
player_bullets[count].active = False
for count in range(MAX_ENEMY_BULLETS):
enemy_bullets[count].active = False
for count in range(MAX_UFOS):
ufos[count].active = False
if title_menu_choice == 1:
exit_sound.play()
main_loop = False
else:
#-----------------------#
#-----||GAME MODE||-----#
#-----------------------#
# Game Events...
for event in pygame.event.get():
if event.type == pygame.QUIT:
main_loop = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
game_mode = TITLE_SCREEN_MODE # Switch back to the title screen
if event.key == pygame.K_z and player_fire_delay_left > player_fire_rate and game_over == False:
# Pop off a few projectiles...
for count in range(PLAYER_BULLETS):
if (player_bullets[count].active == False): # Find a 'free' bullet for the bottom ship
player_bullets[count].active = True
player_bullets[count].rect.top = player_bottom.rect.top
player_bullets[count].rect.left = player_bottom.rect.left + 12
player_bullets[count].vector_x = 0
player_bullets[count].vector_y = -9
player_fire_delay_left = 0
lazer_sound.play()
break
# Has side player fired
if event.key == pygame.K_x and player_fire_delay_left > player_fire_rate and game_over == False:
for count in range(PLAYER_BULLETS):
if (player_bullets[count].active == False):
player_bullets[count].active = True
player_bullets[count].rect.top = player_side.rect.top + 12
player_bullets[count].rect.left = player_side.rect.left
player_bullets[count].vector_x = -9
player_bullets[count].vector_y = 0
player_fire_delay_right = 0
lazer_sound.play()
break
attack_timer += 1
ufo_attack_timer += 1
if attack_timer > attack_max and wave_break < 1 and enemy_killed < wave_target_kills and game_over == False:
attack_timer = 0
if game_wave > 2:
enemy_type = random.randint(0, 2)
else:
enemy_type = random.randint(0, 1)
direction = random.randint(0, 1)
if enemy_type == 0:
for count in range(MAX_ENEMIES):
if invaders[count].active == False:
if direction == 0: # if enemies come from left
invaders[count].rect.left = -32
invaders[count].rect.top = random.randint(0, (SCREEN_HEIGHT - 64) / 32) * 32
invaders[count].vector_x = max_enemy_speed
invaders[count].vector_y = 0
invaders[count].active = True
break
else: # if enemies come from top
invaders[count].rect.left = random.randint(0, (SCREEN_WIDTH - 64) / 32) * 32
invaders[count].rect.top = -32
invaders[count].vector_x = 0
invaders[count].vector_y = max_enemy_speed
invaders[count].active = True
break
elif enemy_type == 1:
for count in range(MAX_ENEMIES):
if shooter_invaders[count].active == False:
if direction == 0: # if enemies come from left
shooter_invaders[count].rect.left = -32 # 32 is the icon size
shooter_invaders[count].rect.top = random.randint(0, (SCREEN_HEIGHT - 64) / 32) * 32
shooter_invaders[count].vector_x = max_enemy_speed
shooter_invaders[count].vector_y = 0
shooter_invaders[count].active = True
shooter_invaders[count].movement_type = 2
break
else: # if enemies come from top
shooter_invaders[count].rect.left = random.randint(0, (SCREEN_WIDTH - 64) / 32) * 32
shooter_invaders[count].rect.top = -32
shooter_invaders[count].vector_x = 0
shooter_invaders[count].vector_y = max_enemy_speed
shooter_invaders[count].active = True
shooter_invaders[count].movement_type = 1
break
elif enemy_type == 2:
for count in range(MAX_ENEMIES):
if shooter_invaders[count].active == False:
if direction == 0: # if enemies come from left
transient_invaders[count].rect.left = -32
transient_invaders[count].rect.top = random.randint(0, (SCREEN_HEIGHT - 64) / 32) * 32
transient_invaders[count].vector_x = max_enemy_speed
transient_invaders[count].vector_y = random.randint(0, 1) - random.randint(0, 1)
transient_invaders[count].active = True
break
else: # if enemies come from top
transient_invaders[count].rect.left = random.randint(0, (SCREEN_WIDTH - 64) / 32) * 32
transient_invaders[count].rect.top = -32
transient_invaders[count].vector_x = random.randint(0, 1) - random.randint(0, 1)
transient_invaders[count].vector_y = max_enemy_speed
transient_invaders[count].active = True
break
# ufo attacks..
for count in range(MAX_UFOS):
if ufos[count].active == False and ufo_attack_timer > ufo_attack_max and wave_break < 1 and game_over == False:
ufo_attack_timer = 0
ufo_sound.play()
if random.randint(0, 10) > 4: # Attacking the side player
if random.randint(0, 10) > 4:
ufos[count].rect.left = SCREEN_WIDTH - 32
ufos[count].rect.top = -32
ufos[count].vector_x = 0
ufos[count].vector_y = max_ufo_speed
ufos[count].active = True
else:
ufos[count].rect.left = SCREEN_WIDTH -32
ufos[count].rect.top = SCREEN_HEIGHT + 32
ufos[count].vector_x = - max_ufo_speed
ufos[count].vector_y = 0
ufos[count].active = True
else: # Attacking the bottom player
if random.randint(0, 10) > 4:
ufos[count].rect.top = SCREEN_HEIGHT - 32
ufos[count].rect.left = - 32
ufos[count].vector_x = max_ufo_speed
ufos[count].vector_y = 0
ufos[count].rect.active = True
else:
ufos[count].rect.top = SCREEN_HEIGHT -32
ufos[count].rect.left = SCREEN_WIDTH + 32
ufos[count].vector_x = 0 - max_ufo_speed
ufos[count].vector_y = 0
ufos[count].active = True
# Render the particles..
for count in range(MAX_PARTICLES):
if particles[count].active == True:
particles[count].update()
screen.blit(particles[count].image, particles[count].rect)
# Update the players due to their key events..
player_bottom.update()
player_side.update()
# If player recovers from damage..
if player_flash_timer > 0:
player_flash_on -= 1
if player_flash_on == True:
player_flash_on = False
else:
player_flash_on = True
else:
player_flash_on = False
# Render all the player projectiles..
for count in range(PLAYER_BULLETS):
if (player_bullets[count].active):
player_bullets[count].update()
screen.blit(player_bullets[count].image, player_bullets[count].rect)
# Render all the enemies projectiles..
for count in range(MAX_ENEMY_BULLETS):
if (enemy_bullets[count].active):
enemy_bullets[count].update
screen.blit(enemy_bullets[count].image, enemy_bullets[count].rect)
# Increase the delay for the players fire..
player_fire_delay_left += 1
player_fire_delay_right += 1
# Update the invaders (move and draw)..
for count in range(MAX_ENEMIES):
if invaders[count].active:
invaders[count].update()
screen.blit(invaders[count].image, invaders[count].rect, (32 * invaders[count].anim_frame, 0, 32, 32))
# Check the invader collision with any player_bullets
for collision_count in range(PLAYER_BULLETS):
if player_bullets[collision_count].active:
if player_bullets[collision_count].rect.colliderect((invaders[count].rect.left, invaders[count].rect.top, 32, 32)):
invaders[count].active = False
player_bullets[collision_count].active = False
enemy_killed += 1
expolde_sound.play()
player_score += 2000
create_particles(15, invaders[count].rect.left + 8, invaders[count].rect.top + 8, green_particle_image)
# Update the shooter_invaders (move and draw)..
for count in range(MAX_ENEMIES):
if shooter_invaders[count].active:
shooter_invaders[count].update()
screen.blit(shooter_invaders[count].image, shooter_invaders[count].rect, (32* shooter_invaders[count].anim_frame, 0, 32, 32))
for collision_count in range(PLAYER_BULLETS):
if player_bullets[collision_count].active == True:
if player_bullets[collision_count].rect.colliderect((shooter_invaders[count].rect.left, shooter_invaders[count].rect.top, 32, 32)):
shooter_invaders[count].active = False
player_bullets[collision_count].active = False
expolde_sound.play()
player_score += 4750
enemy_killed += 1
create_particles(15, shooter_invaders[count].rect.left + 8, shooter_invaders[count].rect.top + 8, red_particle_image)
# How nmuch the shooter_invaders take to shoot?
enemy_fire_timer += 1
if enemy_fire_timer > enemy_fire_max and game_over == False:
enemy_fire_timer = 0
for count in range(MAX_ENEMIES):
if shooter_invaders[count].active == True and shooter_invaders[count].rect.top < SCREEN_HEIGHT - 50 and shooter_invaders[count].rect.top > 50:
shoot2_sound.play()
bullets = 0
for bullet_count in range(MAX_ENEMY_BULLETS):
if enemy_bullets[bullet_count].active == False:
if random.randint(0, 10) > 4:
enemy_bullets[bullet_count].active = True
enemy_bullets[bullet_count].vector_x = 7
enemy_bullets[bullet_count].vector_y = 0
enemy_bullets[bullet_count].rect.top = shooter_invaders[count].rect.top + 8
enemy_bullets[bullet_count].rect.left = shooter_invaders[count].rect.left + 12
break
else:
enemy_bullets[bullet_count].active = True
enemy_bullets[bullet_count].vector_x = 0
enemy_bullets[bullet_count].vector_y = 7
enemy_bullets[bullet_count].rect.top = shooter_invaders[count].rect.top + 16
enemy_bullets[bullet_count].rect.left = shooter_invaders[count].rect.left + 8
break
# Update the ufos (move and draw)..
for count in range(MAX_UFOS):
if ufos[count].active:
ufos[count].update()
screen.blit(ufos[count].image, ufos[count].rect, (32 * ufos[count].anim_frame, 0, 32, 32))
for collision_count in range(PLAYER_BULLETS):
if player_bullets[collision_count].rect.colliderect((ufos[count].rect.left, ufos[count].rect.top, 32, 32)):
ufos[count].active = False
create_particles
player_bullets[collision_count].active = False
expolde_sound.play()
player_score += 3250
create_particles(15, ufos[count].rect.left + 8, ufos[count].rect.top + 8, gray_particle_image)
# Update the transient invaders (move and draw)..
for count in range(MAX_ENEMIES):
if transient_invaders[count].active:
transient_invaders[count].update()
screen.blit(transient_invaders[count].image, transient_invaders[count].rect, (32* transient_invaders[count].anim_frame, 0, 32, 32))
for collision_count in range(PLAYER_BULLETS):
if player_bullets[collision_count].active == True:
if player_bullets[collision_count].rect.colliderect(transient_invaders[count], player_bullets[count]):
transient_invaders[count].active = False
player_bullets[collision_count].active = False
expolde_sound.play()
player_score += 2500
enemy_killed += 1
create_particles(15, transient_invaders[count].rect.left + 8, transient_invaders[count].top + 8, blue_particle_image)
# Check for player and invaders collisions..
if player_flash_timer < 1 and game_over == False:
player_hit = False
for collision_count in range(MAX_ENEMIES):
# Have any invaders collided with player?
if invaders[collision_count].active == True:
if player_side.rect.colliderect((invaders[collision_count].rect.left + 5, invaders[collision_count].rect.top + 5, 24, 24)):
invaders[collision_count].active = False
create_particles(15, invaders[collision_count].rect.left + 8, invaders[collision_count].rect.top + 8, green_particle_image)
player_hit = True
if player_bottom.rect.colliderect((invaders[collision_count].rect.left + 5, invaders[collision_count].rect.top + 5, 24, 24)):
invaders[collision_count].active = False
create_particles(15, invaders[collision_count].rect.left + 8, invaders[collision_count].rect.top + 8, green_particle_image)
player_hit = True
# Have any transient_invaders collided with player?
if shooter_invaders[collision_count].active == True:
if player_side.rect.colliderect((shooter_invaders[collision_count].rect.left + 5, shooter_invaders[collision_count].rect.top + 5, 24, 24)):
shooter_invaders[collision_count].active = False
create_particles(15, shooter_invaders[collision_count].rect.left + 8, shooter_invaders[collision_count].rect.top + 8, red_particle_image)
player_hit = True
if player_bottom.rect.colliderect((shooter_invaders[collision_count].rect.left + 5, shooter_invaders[collision_count].rect.top + 5, 24, 24)):
shooter_invaders[collision_count].active = False
create_particles(15, shooter_invaders[collision_count].rect.left + 8, shooter_invaders[collision_count].rect.top + 8, red_particle_image)
player_hit = True
# Have any transient_invaders collided with player?
if transient_invaders[collision_count].active == True:
if player_side.rect.colliderect((transient_invaders[collision_count].rect.left + 5, transient_invaders[collision_count].rect.top + 5, 24, 24)):
transient_invaders[collision_count].active = False
create_particles(15, transient_invaders[collision_count].rect.left + 8, transient_invaders[collision_count].rect.top + 8, blue_particle_image)
player_hit = True
if player_bottom.rect.colliderect((transient_invaders[collision_count].rect.left + 5, transient_invaders[collision_count].rect.top + 5, 24, 24)):
transient_invaders[collision_count].active = False
create_particles(15, transient_invaders[collision_count].rect.left + 8, transient_invaders[collision_count].rect.top + 8, blue_particle_image)
player_hit = True
# Have any ufos collided with player?
for collision_count in range (MAX_UFOS):
if ufos[collision_count].active == True:
if player_side.rect.colliderect((ufos[collision_count].rect.left + 5, ufos[collision_count].rect.top + 5, 24, 24)):
ufos[collision_count].active = 0
create_particles(15, ufos[collision_count].rect.left + 8, ufos[collision_count].rect.top + 8, gray_particle_image)
player_hit = True
if player_bottom.rect.colliderect((ufos[collision_count].rect.left + 5, ufos[collision_count].rect.top + 5, 24, 24)):
ufos[collision_count].active = 0
create_particles(15, ufos[collision_count].rect.left + 8, ufos[collision_count].rect.top + 8, gray_particle_image)
player_hit = True
# Have any enemy bullets collided with player?
for collision_count in range (MAX_ENEMY_BULLETS):
if player_bullets[collision_count].active == True:
if player_side.rect.colliderect((player_bullets[collision_count].rect.left, player_bullets[collision_count].rect.top, 8, 8)):
player_bullets[collision_count].active = 0
player_hit = True
if player_bottom.rect.colliderect((player_bullets[collision_count].rect.left, player_bullets[collision_count].rect.top, 8, 8)):
player_bullets[collision_count].active = 0
player_hit = True
# Has player been hit by anything nasty?
if player_hit == True and game_over == False:
player_shield -= 1
create_particles(5, 85 + ((player_shield) * 11), 32, red_particle_image)
player_flash_timer = 50
damage_sound.play()
if player_shield == 0:
player_dead_sound.play()
create_particles(20, player_bottom.rect.left + 8, player_bottom.rect.top + 8, red_particle_image)
create_particles(20, player_bottom.rect.left + 8, player_bottom.rect.top + 8, yellow_particle_image)
create_particles(20, player_side.rect.left + 8, player_side.rect.top + 8, red_particle_image)
create_particles(20, player_side.rect.left + 8, player_side.rect.top + 8, yellow_particle_image)
game_over = True
# Display hud stuff
screen.blit(game_font.render("Score: " + str(player_score), 0, ((255, 206, 0))), (10, 10))
screen.blit(game_font.render("High Score: " + str(high_score), 0, ((255, 206, 0))), (460, 10))
#NOTE: BOOKMARK HERE!
# Beaten high score?
if player_score > high_score:
high_score = player_score
# Make a little fuss of the player :)
if BEATEN_HIGH_SCORE == False:
BEATEN_HIGH_SCORE = True
for count in range(5):
create_particles(5, 460 + (count * 15), 15, yellow_particle_image)
if wave_break > 0:
wave_break -= 1
if game_over == False:
screen.blit(game_font_large.render("Wave " + str(game_wave) + " of 9", 0, ((255, 206, 0))), (240, SCREEN_HEIGHT / 2 - 36))
for count in range(player_shield):
screen.blit(game_font.render("Shields:", 0, ((255, 206, 0))), (10, 30))
screen.blit(player_health_image, (85 + (count * 11), 32))
if game_over == True:
# Loss or victory?
if game_victory == False:
screen.blit(game_font_large.render("GAME OVER", 0, ((176, 0, 0))), (260, SCREEN_HEIGHT / 2 - 36))
else:
screen.blit(game_font_large.render("YOU ARE AWESOME!!!", 0, ((255, 206, 0))), (160, SCREEN_HEIGHT / 2 - 36))
game_victory_particle_timer += 1
if game_victory_particle_timer > 10:
create_particles(30, random.randint(160, 450), random.randint(160, 300), red_particle_image)
game_over_timer -= 1
if game_over_timer == 0:
game_mode = TITLE_SCREEN_MODE
# Time for a new wave? Only start new wave display when all enemies are dead
enemies_onscreen = False
for count in range(MAX_ENEMIES):
if invaders[count].active == True:
enemies_onscreen = True
break
if shooter_invaders[count].active == True:
enemies_onscreen = True
break
if transient_invaders[count].active == True:
enemies_onscreen = True
break
for count in range(MAX_UFOS):
if ufos[count].active == True:
enemies_onscreen = True
if enemy_killed > wave_target_kills and enemies_onscreen == False and game_over == False:
wave_break = 300
wave_target_kills += 10
game_wave += 1
if game_wave == 10:
game_over = True
game_victory = True
game_over_timer = 700
win_sound.play()
enemy_killed = 0
# Make the next round a bit harder :)
if attack_max > 30:
attack_max -= 10
if ufo_attack_max > 0:
ufo_attack_max -= 50
if game_wave > 6:
player_fire_rate = 10
wave_sound.play()
pygame.display.flip()
clock.tick(FPS)
# # Game Hack..
# if event.key == pygame.K_t:
# player_flash_on = True
# player_flash_timer = 50000
pygame.quit()
def fire(self, angle_degrees):
if self.cooldown_timer <= 0:
p = Projectile(angle_degrees, self.source)
self.projectile_cb(p)
self.cooldown_timer = self.cooldown
def launch_projectile(self):
#creation d'une nouvelle instance
self.all_projectiles.add(Projectile(self))
pygame.quit()
sys.exit(0)
pygame.draw.rect(screen, black, ((0, 0), (640, 600)))
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
if n > -250:
n -= 1
if keys[pygame.K_RIGHT]:
if n < 250:
n += 1
if keys[pygame.K_SPACE] and clc() - now > 0.3:
projectiles.append(Projectile(screen, n))
now = clc()
for bubble in bubbles:
bubble.move()
for bullet in projectiles:
bubble.collision(bullet)
bubbles = list(filter(lambda x: x.state(), bubbles))
while len(bubbles) < 10:
bubbles.append(Bubble(screen))
for bullet in projectiles:
bullet.move()
projectiles = list(filter(lambda x: x.state(), projectiles))
def fire(self):
"""fires a projectile"""
print("fired: " + self.mode)
self.world.projectiles.append(
Projectile(self.mode, self.pos.copy(), 30.0, self.world))
def updoot(self, number_of_hits, keys):
"""
Updates everything but movement (pretty much)
:param number_of_hits:
:param keys:
:return: None
"""
self.number_of_hits = number_of_hits # new hits will add to number of hits before this frame
if self.team == "BLUE":
if self.x < 0: # BLUE stay inbounds x
self.x = 0
if self.x > self.res[0] / 2:
self.x = self.res[0] / 2
elif self.team == "RED":
if self.x < self.res[0] / 2: # RED stay inbounds x
self.x = self.res[0] / 2
if self.x > self.res[0]:
self.x = self.res[0]
if self.y < 0: # BOTH stay inbounds y
self.y = 0
elif self.y > self.res[1]:
self.y = self.res[1]
# ABILITIES and SHOOTING
if self.team == "BLUE":
if keys[pygame.K_q]:
if self.mana >= 1:
bullet = Projectile(self.x, self.y, 5, 10, self.team, "assets/bullet.png")
self.allprojectiles.add(bullet)
self.bullets.add(bullet)
self.sprites.add(bullet)
self.mana -= 1
self.manaspent += 1
self.number_of_shots += 1
if keys[pygame.K_e]:
if self.spec == "spec1":
didShoot = self.specialAbility1() # returns true or false cause checking for mana
if didShoot:
self.number_of_shots += 1 # shoots if true, same for all
elif self.spec == "spec2":
didShoot = self.specialAbility2()
if didShoot:
self.number_of_shots += 1
elif self.spec == "spec3":
didShoot = self.specialAbility3()
if didShoot:
self.number_of_shots += 1
elif self.team == "RED":
if keys[pygame.K_u]: # Pressing U
if self.mana >= 1:
bullet = Projectile(self.x, self.y, 5, 10, self.team, "assets/bullet.png")
self.allprojectiles.add(bullet)
self.bullets.add(bullet)
self.sprites.add(bullet)
self.mana -= 1
self.number_of_shots += 1
if keys[pygame.K_o]: # Pressing O
if self.spec == "spec1":
didShoot = self.specialAbility1()
if didShoot:
self.number_of_shots += 1
elif self.spec == "spec2":
didShoot = self.specialAbility2()
if didShoot:
self.number_of_shots += 1
elif self.spec == "spec3":
didShoot = self.specialAbility3()
if didShoot:
self.number_of_shots += 1
self.update_accuracy() # Not much to say
self.rect.center = self.x, self.y # move rect to x,y location stored
def fire_projectile(screen, projectiles, ship, settings):
if len(projectiles) < settings.magazine:
new_projectile = Projectile(settings, screen, ship)
projectiles.add(new_projectile)
if randint(1, 800) == 1:
monster = Monster(screen_rect, drawing_group)
drawing_group.add(monster)
monsters.add(monster)
keystate = pygame.key.get_pressed()
mods = pygame.key.get_mods()
shift = mods & KMOD_SHIFT
if keystate[K_SPACE]:
time_now = time()
time_since_fire = time_now - time_last_fire
if time_since_fire > (.2 if shift else .5):
time_last_fire = time()
projectile = Projectile(
player_bee.rect.x + player_bee.rect.width / 2,
player_bee.rect.y)
drawing_group.add(projectile)
projectiles.add(projectile)
xdir = keystate[K_RIGHT] - keystate[K_LEFT] # -1, 0, or 1
ydir = keystate[K_DOWN] - keystate[K_UP]
player_bee.setAngle(angles[ydir + 1][xdir + 1])
player_bee.rect = player_bee.rect.move(
(xdir * 8, ydir * 8)).clamp(screen_rect)
pygame.sprite.groupcollide(projectiles, invaders, True, True)
pygame.sprite.groupcollide(projectiles, monsters, True, True)
drawing_group.clear(screen, background)
def game_loop(self):
""" This is the main game loop """
clock = pygame.time.Clock()
bullet_sound = pygame.mixer.Sound('Sound/bullet.wav')
score_font = pygame.font.SysFont('arial', 30, True)
shoot_loop = 0
bullets = []
dino = Player(self.level.get_player_start_position())
while True:
clock.tick(40)
dino.gun = self.level.dino_gun
if dino.pos.x + 350 > self.screen_width:
self.level.shift_world(-5, 0)
dino.slide(-5, 0)
if dino.pos.x - 350 <= 0 and self.level.world_shift_x < 0:
self.level.shift_world(5, 0)
dino.slide(5, 0)
if self.level.world_shift_x <= self.level.level_limit:
print(self.levels.index(self.level) + 1)
try:
self.level = self.levels[self.levels.index(self.level) + 1]
except IndexError:
self.end_screen(dino)
return False
dino.reset()
if shoot_loop > 0:
shoot_loop += 1
if shoot_loop > 4:
shoot_loop = 0
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
dino.jump()
if event.key == pygame.K_BACKQUOTE:
for enemy in self.level.enemys:
enemy.debug_draw(draw_bounds=not enemy.draw_bounds,
draw_hitbox=not enemy.draw_hitbox)
dino.debug_draw(draw_hitbox=not dino.draw_hitbox)
if not self.jump_button.get_state():
jump_flag = True
if self.jump_button.get_state():
if jump_flag:
dino.jump()
jump_flag = False
for bullet in bullets:
remove = False
hits = pygame.sprite.spritecollide(bullet,
self.level.platforms, False)
if hits:
remove = True
if (bullet.pos.x < self.screen_width) and (bullet.pos.x > 0):
bullet.update_location()
else:
remove = True
hits = pygame.sprite.spritecollide(bullet, self.level.enemys,
False)
for hit in hits:
self.score += 5
hit.hit()
remove = True
if remove:
bullets.pop(bullets.index(bullet))
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] or self.left_button.get_state():
dino.move_left()
elif keys[pygame.K_RIGHT] or self.right_button.get_state():
dino.move_right()
else:
dino.stop()
if keys[pygame.K_ESCAPE]:
return
if keys[pygame.K_a]:
print(dino.pos.x - self.level.world_shift_x)
if (keys[pygame.K_SPACE]
or self.shoot_button.get_state()) and (shoot_loop
== 0) and dino.gun:
if dino.facing_left:
facing = -1
else:
facing = 1
if len(bullets) < 5:
bullets.append(
Projectile(int(dino.rect.centerx),
int(dino.rect.centery), 6, (0, 0, 0),
facing))
bullet_sound.play()
shoot_loop = 1
dino.update_location(self.screen_height)
self.win.blit(self.level.background, (0, 0))
text = score_font.render('Score:' + str(self.score), 1, (0, 0, 0))
self.win.blit(text, (0, 10))
text = score_font.render(
'Speed:' + str(self.ellip.get_speed()) + " RPM", 1, (0, 0, 0))
self.win.blit(text, (0, 40))
heart_rate = 132
text = score_font.render('Heart Rate:' + str(heart_rate), 1,
(0, 0, 0))
self.win.blit(text, (0, 70))
hits = pygame.sprite.spritecollide(dino, self.level.platforms,
False)
for hit in hits:
dino.touch_down(hit.rect, hit.friction)
hits = pygame.sprite.spritecollide(dino, self.level.enemys, False)
for hit in hits:
dino.hit(hit)
if dino.rect.bottom <= (hit.rect.centery -
(hit.rect.height // 4)
) and dino.rect.bottom >= hit.rect.top:
self.score += 20
if dino.dead:
self.level.shift_world(0 - self.level.world_shift_x,
0 - self.level.world_shift_y)
dino.reset()
self.level.draw(self.win)
dino.draw(self.win)
for bullet in bullets:
bullet.draw(self.win)
pygame.display.update()
50,
25,
"enter the velocity of the initial projectile in m/s:",
20,
(220, 220, 220),
)
angleInput = InputBox(
windowInfo.width / 2 + 20,
50,
50,
25,
"enter the degree of the initial projectile in degrees above the horizon: ",
20,
(220, 220, 220),
)
projectile = Projectile(5)
location = Grid()
accumulatedTime = 0
win = pygame.display.set_mode((windowInfo.width, windowInfo.height))
pygame.display.set_caption("kinematics simulation")
# main lopp
run = True
while run:
# event loop
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if (event.type == pygame.MOUSEBUTTONDOWN
and pygame.mouse.get_pos()[1] > windowInfo.inputHeight):
def DoSkillSpell(mob, skillname):
from projectile import Projectile
from spell import SpawnSpell
player = mob.player
mobSkill = mob.mobSkillProfiles[skillname]
classSkill = mobSkill.classSkill
# Assert that mob knows the skill.
skillLevel = mob.skillLevels.get(skillname, 0)
if not skillLevel:
return False
# Modify skill spells strength by skill level.
mod = float(skillLevel) / float(classSkill.maxValue)
# Clamp mod to produce at least 10% of maximum effect.
if mod < .1:
mod = .1
proto = classSkill.spellProto
# Get the appropriate target for this skill spell.
tgt = mob.target
if proto.target == RPG_TARGET_SELF:
tgt = mob
elif proto.target == RPG_TARGET_PARTY:
tgt = mob
elif proto.target == RPG_TARGET_ALLIANCE:
tgt = mob
elif proto.target == RPG_TARGET_PET:
tgt = mob.pet
elif player and proto.spellType & RPG_SPELL_HEALING and proto.target == RPG_TARGET_OTHER:
tgt = GetPlayerHealingTarget(mob, tgt, proto)
# If no valid target could be found, return in failure.
# Here's one last chance to still acquire one.
if not tgt:
if player:
if proto.spellType & RPG_SPELL_HARMFUL:
from command import CmdTargetNearest
CmdTargetNearest(mob, None, False, True)
tgt = mob.target
if not tgt:
player.sendGameText(
RPG_MSG_GAME_DENIED,
"$src's <a:Skill%s>%s</a> skill failed, no target.\\n"
% (GetTWikiName(skillname), skillname), mob)
else:
tgt = mob
# Still no target, now definitely abort skill.
# If the mob is a player mob, message has already be sent.
if not tgt:
return False
# For harmful skill spells, check if target may
# be harmed at all. Abort if not.
if proto.spellType & RPG_SPELL_HARMFUL:
if not AllowHarmful(mob, tgt) and not proto.aoeRange:
if player:
player.sendGameText(
RPG_MSG_GAME_DENIED,
"$src's <a:Skill%s>%s</a> skill failed, no valid target.\\n"
% (GetTWikiName(skillname), skillname), mob)
return False
if not player and not (mob.master and mob.master.player) and not IsKOS(
mob, tgt):
return False
# If the skill spell isn't harmful and the target is hostile,
# retarget self.
if not proto.spellType & RPG_SPELL_HARMFUL and mob.target == tgt:
if tgt and IsKOS(tgt, mob):
tgt = mob
# Check for a skill raise.
if mob.character:
c = 10
if mobSkill.reuseTime > 180:
c = 5
if mobSkill.reuseTime > 180 * 2:
c = 3
mob.character.checkSkillRaise(skillname, c)
# Play animation and trigger particles if available.
if proto.animOverride:
mob.zone.simAvatar.mind.callRemote("playAnimation", mob.simObject.id,
proto.animOverride)
if len(proto.particleNodes):
mob.zone.simAvatar.mind.callRemote("triggerParticleNodes",
mob.simObject.id,
proto.particleNodes)
# Launch a projectile if necessary, otherwise spawn skill spell.
if proto.projectile:
p = Projectile(mob, mob.target)
p.spellProto = proto
p.launch()
else:
SpawnSpell(proto, mob, tgt, tgt.simObject.position, mod, skillname)
# Return True, so skill was used.
return True
def attack_p(self):
self.all_projectiles.add(Projectile(self, self.velocity, 'assets/projectile.png'))
def main():
'''main program'''
pygame.init()
#setting up font
#set height and width of the screen'''
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
pygame.display.set_caption('Side-Scrollin Platformer')
BackGround = Background('background_test.jpeg', [0, 0])
#create the player'''
player = Player()
#crate levels'''
level_list = []
level_list.append(Level_01(player))
level_list.append(Level_02(player))
#set current level'''
current_level_no = 0
current_level = level_list[current_level_no]
active_sprite_list = pygame.sprite.Group()
player.level = current_level
player.rect.x = 340
player.rect.y = SCREEN_HEIGHT - player.rect.height
active_sprite_list.add(player)
#loop until the user clicks close button'''
done = False
#used to manage how fast the screen updates'''
clock = pygame.time.Clock()
projectile_list = pygame.sprite.Group()
bullet_list = pygame.sprite.Group()
#MAIN GAME LOOP'''
while not done:
screen.fill(WHITE)
screen.blit(BackGround.image, BackGround.rect)
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_a:
player.go_left()
if event.key == pygame.K_d:
player.go_right()
if event.key == pygame.K_w:
player.jump()
#player.subtract_health(3)
#message_display(player.health)
#text(player.health)
#print (player.health)
if event.key == pygame.K_SPACE:
bullet = Projectile(player.rect.x, player.rect.y, 12, 0)
active_sprite_list.add(bullet)
bullet_list.add(bullet)
if event.type == pygame.KEYUP:
if event.key == pygame.K_a and player.change_x < 0:
player.stop()
if event.key == pygame.K_d and player.change_x > 0:
player.stop()
#dropping projectiles
odds_of_drop = random.randint(1, 100)
if odds_of_drop < 10:
projectile = Projectile(random.randrange(SCREEN_WIDTH),
random.randrange(1, 5), 0,
random.randrange(5, 8))
active_sprite_list.add(projectile)
projectile_list.add(projectile)
hits = pygame.sprite.spritecollide(player, projectile_list, True)
if hits:
player.subtract_health(1)
#projectile_list.remove(projectile)
print("hit")
print(player.health)
#projectile.kill()
#update player'''op
active_sprite_list.update()
#update items in the level'''
current_level.update()
#if player gets near the right side, shift the world left (-x)'''
if player.rect.right >= 500:
diff = player.rect.right - 500
player.rect.right = 500
current_level.shift_world(-diff)
#if player gets near the left side, shift the world right(+x)'''
if player.rect.left <= 120:
diff = 120 - player.rect.left
player.rect.left = 120
current_level.shift_world(diff)
#if the player gets to the end of the level, go to next level'''
current_position = player.rect.x + current_level.world_shift
if current_position < current_level.level_limit:
player.rect.x = 120
if current_level_no < len(level_list) - 1:
current_level_no += 1
current_level = level_list[current_level_no]
player.level = current_level
#all code to draw should go below this comment'''
current_level.draw(screen)
active_sprite_list.draw(screen)
#all code to draw should go above this comment'''
#limt to 6o fps'''
clock.tick(60)
#go ahead and update the screen with what weve drawn'''
pygame.display.flip()
#be IDLE friendly. if you foget this line program will hang on exit'''
pygame.quit()
shot_sound = pygame.mixer.Sound('data2/shot_sound.ogg')
clock = pygame.time.Clock()
tick_timer = 0
game_over = False
game_loop = True
while game_loop:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_loop = False
elif event.type == pygame.MOUSEBUTTONDOWN:
shot_sound.play()
new_shot = Projectile(shots_group)
new_shot.rect.center = player.rect.center
# Logic
if not game_over:
tick_timer += 1
if tick_timer > 30:
tick_timer = 0
if random.random() < 0.4:
new_asteroid = Asteroid(asteroid_group)
x, y = SCREEN_RES[0], random.randint(0, SCREEN_RES[1] - 100)
new_asteroid.rect.move_ip(x, y)
bg_group.update()
asteroid_group.update()
player_group.update()
def lauch_projectile(self):
#creation d'une nouvelle instance de la class projectile
if self.isFiring:
self.all_projectiles.add(Projectile(self, self.direction))
def launch_projectile(self):
self.all_projectiles.add(Projectile(self))
self.start_animation()
self.game.soundManager.play('tir')
from ramp import Ramp
from target import Target
from angleMath import AngleMath
from projectile import Projectile
from learn import Learn
import math
from scipy.misc import derivative
import graphics
from myConstants import myConstants
myRamp = Ramp(700, AngleMath.toRad(15))
myProjectile = Projectile(60, AngleMath.toRad(20), 100, myRamp)
graphics.initialGraphics(myProjectile)
print("initial x0:" + str(myProjectile.x0))
print("initial y0:" + str(myProjectile.y0))
myRamp.printStats()
myProjectile.calcxtFall(0.000001)
t = 0.0
# for i in range(1, len(myProjectile.tFallList)):
for i in range(0, len(myProjectile.tList)):
if (myProjectile.tList[i] >= t):
myProjectile.x = myProjectile.xList[i]
myProjectile.y = myProjectile.yList[i]
graphics.move(graphics.player, myProjectile, t)
t += myConstants.myRate
def renderSelf(self, time, renderer, xMin, yMin, bossTextures):
if (self.xPos + self.width - xMin <
0) or (self.yPos + self.height - yMin < 0):
return
elif (self.xPos > xMin + 800) or (self.yPos > yMin + 600):
return
frameTime = ((int(time / 125)) % 4)
spriteFrame = sdl.Rect((frameTime * 300, 0, 300, 400))
if self.dead:
return
if self.dying:
frameTime = ((int(time / 500)) % 4)
if self.currentTime is not frameTime:
self.currentFrame += 1
self.currentTime = frameTime
spriteFrame = sdl.Rect((self.currentFrame * 300, 0, 300, 400))
sdl.renderCopy(renderer, bossTextures[9], spriteFrame,
self.getRect(xMin, yMin))
# once the animation for attacking runs through, set him back to not attacking
# and reset the current frame to -1 (so it starts at frame 0 next run)
if self.currentFrame is 10:
self.currentFrame = -1
self.attacking = 0
self.currentTime = -1
self.dead = True
self.dying = False
else:
self.currentTime = frameTime
spriteFrame = sdl.Rect((self.currentFrame * 300, 0, 300, 400))
sdl.renderCopy(renderer, bossTextures[9], spriteFrame,
self.getRect(xMin, yMin))
elif not self.hurt: # if not hurt
if self.attacking is 0: # if not attacking
if self.direction == 'e':
sdl.renderCopy(renderer, bossTextures[1], spriteFrame,
self.getRect(xMin, yMin)) #right
elif self.direction == 'w':
sdl.renderCopy(renderer, bossTextures[2], spriteFrame,
self.getRect(xMin, yMin)) #left
elif self.direction == 's':
sdl.renderCopy(renderer, bossTextures[8], spriteFrame,
self.getRect(xMin, yMin)) #idle
else: # if attacking
if self.attacking == 1: # GREEN ATTACK
frameTime = ((int(time / 125)) % 4)
if self.currentTime is not frameTime:
self.currentFrame += 1
self.currentTime = frameTime
spriteFrame = sdl.Rect(
(self.currentFrame * 300, 0, 300, 400))
sdl.renderCopy(renderer, bossTextures[3], spriteFrame,
self.getRect(xMin, yMin))
if self.currentFrame is 4:
self.projectiles.append(
Projectile(
int(self.xPos) + 100,
int(self.yPos) + 400, 60, 60, 'green',
bossTextures[4], renderer, 0, 0, 0))
# once the animation for attacking runs through, set him back to not attacking
# and reset the current frame to -1 (so it starts at frame 0 next run)
if self.currentFrame >= 6:
self.currentFrame = -1
self.attacking = 0
self.currentTime = -1
else:
self.currentTime = frameTime
spriteFrame = sdl.Rect(
(self.currentFrame * 300, 0, 300, 400))
sdl.renderCopy(renderer, bossTextures[3], spriteFrame,
self.getRect(xMin, yMin))
elif self.attacking == 2: # ORANGE ATTACK
frameTime = ((int(time / 125)) % 4)
if self.currentTime is not frameTime:
self.currentFrame += 1
self.currentTime = frameTime
spriteFrame = sdl.Rect(
(self.currentFrame * 700, 0, 700, 800))
sdl.renderCopy(renderer, bossTextures[5], spriteFrame,
self.getRect(xMin, yMin))
# once the animation for attacking runs through, set him back to not attacking
# and reset the current frame to -1 (so it starts at frame 0 next run)
if self.currentFrame >= 8:
self.currentFrame = -1
self.attacking = 0
self.currentTime = -1
self.endOfOrange = True
else:
self.currentTime = frameTime
spriteFrame = sdl.Rect(
(self.currentFrame * 700, 0, 700, 800))
sdl.renderCopy(renderer, bossTextures[5], spriteFrame,
self.getRect(xMin, yMin))
elif self.attacking == 3: # PURPLE ATTACK
frameTime = ((int(time / 125)) % 4)
if self.currentTime is not frameTime:
self.currentFrame += 1
self.currentTime = frameTime
spriteFrame = sdl.Rect(
(self.currentFrame * 300, 0, 300, 400))
sdl.renderCopy(renderer, bossTextures[6], spriteFrame,
self.getRect(xMin, yMin))
if self.currentFrame is 4:
self.projectiles.append(
Projectile(
int(self.xPos) - 100,
int(self.yPos) + 400, 400, 200, 'purple',
bossTextures[7], renderer, 0, 0, 0))
# once the animation for attacking runs through, set him back to not attacking
# and reset the current frame to -1 (so it starts at frame 0 next run)
if self.currentFrame >= 6:
self.currentFrame = -1
self.attacking = 0
self.currentTime = -1
else:
self.currentTime = frameTime
spriteFrame = sdl.Rect(
(self.currentFrame * 300, 0, 300, 400))
sdl.renderCopy(renderer, bossTextures[6], spriteFrame,
self.getRect(xMin, yMin))
if self.attacking == 4:
sdl.renderCopy(renderer, bossTextures[8], spriteFrame,
self.getRect(xMin, yMin))
elif self.hurt: # if hurt
sdl.renderCopy(renderer, bossTextures[0], spriteFrame,
self.getRect(xMin, yMin))
self.renderHealth(renderer, xMin, yMin, bossTextures[10])
def launch_proj(self):
# cree une nouvelle instance du projectile
self.all_projectiles.add(Projectile(self))
def update(self, players, projectiles):
if self.respawn > 0:
self.respawn -= 1
if self.respawn == 0:
self.spawn()
return
if self.health <= 0:
self.game.score(self.name, -1)
self.respawn = RESPAWN_TICKS
return
# Handle shooting
if self.primary_reload > 0:
self.primary_reload -= 1
if self.secondary_reload > 0:
self.secondary_reload -= 1
if self.shootstate == 1 and self.primary_reload <= 0:
berr = random.random() * self.bloom * 2 - self.bloom
projectiles.append(
Projectile(
self.raycaster, 1, {
"x": self.pose["x"],
"y": self.pose["y"],
"theta": self.pose["aim"] + berr
}, self.name))
self.primary_reload = PRIMARY_RELOAD
self.bloom += BLOOM_PRIMARY
if self.shootstate == 2 and self.secondary_reload <= 0:
berr = random.random() * self.bloom * 2 - self.bloom
projectiles.append(
Projectile(
self.raycaster, 2, {
"x": self.pose["x"],
"y": self.pose["y"],
"theta": self.pose["aim"] + berr
}, self.name))
self.secondary_reload = SECONDARY_RELOAD
self.bloom += BLOOM_SECONDARY
self.bloom = min(BLOOM_MAX, self.bloom)
self.bloom -= BLOOM_DECAY * (1.0 - abs(self.movespeed))
self.bloom = max(0, self.bloom)
self.shootstate = 0
# Move robot
dx = math.cos(self.pose["theta"]) * self.movespeed * MOVESPEED_PER_TICK
dy = math.sin(self.pose["theta"]) * self.movespeed * MOVESPEED_PER_TICK
# Check how far the robot can move.
if self.movespeed >= 0:
tx, ty, obj = self.raycaster.cast(
{
"x": self.pose["x"],
"y": self.pose["y"],
"theta": self.pose["theta"]
},
self.name,
collision_mode=True)
else:
tx, ty, obj = self.raycaster.cast(
{
"x": self.pose["x"],
"y": self.pose["y"],
"theta": self.pose["theta"] - math.pi
},
self.name,
collision_mode=True)
# Only if there is an obstacle do something about it...
if tx is not None and ty is not None and obj is not None:
dtx = tx - self.pose["x"]
dty = ty - self.pose["y"]
dlen = dtx * dtx + dty * dty
# Crop movement if nescesarry
if dlen <= dx * dx + dy * dy * 1.01:
dx = 0
dy = 0
# Apply motion
self.pose["x"] += dx
self.pose["y"] += dy
self.pose["theta"] += self.turnspeed * TURNSPEED_PER_TICK
self.pose[
"aim"] += self.aimspeed * AIMSPEED_PER_TICK + self.turnspeed * TURNSPEED_PER_TICK
while self.pose["theta"] <= -math.pi:
self.pose["theta"] += 2 * math.pi
while self.pose["theta"] > math.pi:
self.pose["theta"] -= 2 * math.pi
while self.pose["aim"] <= -math.pi:
self.pose["aim"] += 2 * math.pi
while self.pose["aim"] > math.pi:
self.pose["aim"] -= 2 * math.pi
def shoot_projectile(projectiles_group, screen_width, screen_height):
y = random.randint(0, screen_height)
max_speed = 8
speed = random.randint(1, max_speed)
projectile = Projectile(screen_width, y, speed)
projectiles_group.add(projectile)
def launch_projectile(self):
#creer une nouvelle instance de la classe Projectile
self.all_projectiles.add(Projectile(self))
def launch_projectile(self):
#creer une nouvelle instance de la classe projectile
self.all_projectiles.add(Projectile(self))
# demarer l'animation du lancer
self.start_animation()
