I'm working on the Alien Invasion game from the Python Crash course book, but i can't run the game.
Here's my code:
# Alien Invasion game
import sys
from time import sleep
import pygame
from settings import Settings
from game_stats import GameStats
from button import Button
from ship import Ship
from bullet import Bullet
from alien import Alien
from scoreboard import Scoreboard
class AlienInvasion :
def __init__(self):
'''Initialize the game, and create game resources'''
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics and create a scoreboard
self.stats = GameStats(self)
self.sb = Scoreboard()
self.bg_color = (230, 230, 230)
self.settings = Settings()
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
# Make the Play button
self.play_button = Button(self, "Play")
# Make the difficulty level buttons.
self._make_difficulty_buttons()
def _make_difficulty_buttons(self):
"""Make buttons that allow player to select difficulty level."""
self.easy_button = Button(self, "Easy")
self.medium_button = Button(self, "Medium")
self.difficult_button = Button(self, "Difficult")
# Position buttons so they don't all overlap.
self.easy_button.rect.top = (
self.play_button.rect.top + 1.5*self.play_button.rect.height)
self.easy_button._update_msg_position()
self.medium_button.rect.top = (
self.easy_button.rect.top + 1.5*self.easy_button.rect.height)
self.medium_button._update_msg_position()
self.difficult_button.rect.top = (
self.medium_button.rect.top + 1.5*self.medium_button.rect.height)
self.difficult_button._update_msg_position()
def run_game(self):
'''Start the main loop for the game'''
while True :
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _update_bullets(self):
'''Update position of bullets and get rid of old bullets'''
# Update bullet positions
self.bullets.update()
# Get rid of bullets that have disappeared
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
'''Respond to bullet - alien collisions'''
# Remove any bullets and aliens that have collided
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, True, True)
if collisions :
for aliens in collisions.values():
self.stats.score += self.settings.alien_points
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens :
# Destroy existing bullets and create new fleet
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
# Increase level.
self.stats.level += 1
self.sb.prep_level()
def _update_aliens(self):
'''
Check if the fleet is at an edge,
then update the positions of all
aliens in the fleet
'''
self._check_fleet_edges()
self.aliens.update()
# Look for alien - ship collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
# Look for aliens hitting the bottom of the screen
self._check_aliens_bottom()
def _ship_hit(self):
'''Respond to the ship being hit by an alien'''
if self.stats.ships_left > 0 :
# Decrement ships_left, and update scoreboards
self.stats.ships_left -= 1
self.sb.prep_ships()
# Get rid of any remaining aliens and bullets
self.aliens.empty()
self.ship.center_ship()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Pause
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _check_events(self):
'''Respond to keypresses and mouse events'''
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
self._check_difficulty_buttons(mouse_pos)
def _check_play_button(self, mouse_pos):
'''Start a new game when the player clicks Play'''
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active :
# Reset the game statistics
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.ship.center_ship()
pygame.mouse.set_visible(False)
def _check_difficulty_buttons(self, mouse_pos):
"""Set the appropriate difficulty level."""
easy_button_clicked = self.easy_button.rect.collidepoint(mouse_pos)
medium_button_clicked = self.medium_button.rect.collidepoint(
mouse_pos)
diff_button_clicked = self.difficult_button.rect.collidepoint(
mouse_pos)
if easy_button_clicked:
self.settings.difficulty_level = 'easy'
elif medium_button_clicked:
self.settings.difficulty_level = 'medium'
elif diff_button_clicked:
self.settings.difficulty_level = 'difficult'
#def _start_game(self):
'''Start a new game'''
# Reset the game statistics
#self.stats.reset_stats()
#self.stats.game_active = True
#self.sb.prep_score()
#
# Get rid of any remaining aliens and bullets
#self.aliens.empty()
#self.bullets.empty()
# Create a new fleet and center the ship
#self.create_fleet()
#self.ship.center_ship()
# Hide the mouse cursor
#pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
'''Respond to keypresses'''
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
elif event.key == pygame.K_p and not self.stats.game_active:
self._start_game()
def check_keyup_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _fire_bullet(self):
'''Create a new bullet and add it to the bullets group'''
if len(self.bullets) < self.settings.bullets_allowed :
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _create_fleet(self):
'''Create the fleet of aliens'''
# Make an alien
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = settings.screen_width - (2 * alien_width)
number_aliens_x = available.space_x // (2 * alien_width)
# Determine the number of rows of aliens that fit on the screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height -
3 * (alien_height)- ship_height)
number_rows = available_space_y // 2 * (alien_height)
# Create the full fleet of aliens.
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number):
'''Create an alien and place it in the row'''
self._create_alien(alien_number)
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_wdith * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
'''Respond appropriately if any alien has reached an edge'''
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
'''Drop the entire fleet and change the fleet's direction'''
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _check_aliens_bottom(self):
'''Check if any aliens have reached the bottom of the screen'''
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.midbottom > screen_rect.bottom:
# Treat this the same as if the ship got hit
self._ship_hit()
break
def _update_screen(self):
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
# Draw the score information
self.sb.show_score()
# Draw the play button if the game is inactive
if not self.stats.game_active:
self.play_button.draw_button
self.easy_button.draw_button()
self.medium_button.draw_button()
self.difficult_button.draw_button()
pygame.display.flip()
if __name__ == "__main__":
ai = AlienInvasion()
ai.run_game()
# Ship
import pygame
from pygame.sprite import Sprite
class Ship(Sprite) :
shipimage = r'C:\Users\basti\OneDrive\Documents\Python\Images and sprites\Spaceships\Spaceshipt.png'
with open(shipimage) as f:
def __init__(self, ai_game):
'''Initialize the ship and set its starting position'''
super().__init__()
self.screen = ai_game.screen
self.screen_rect = ai_game.screen.get_rect()
self.settings = ai_game.settings
# Load the ship and get its rect
self.image = pygame.image.load
self.rect = self.image.get_rect()
# Start each new ship at the bottom center of the screen
self.rect.midbottom = self.screen_rect.midbottom
self.x = float(self.rect.x)
# Movement flag
self.moving_right = False
self.moving_left = False
# Ship settings
self.ship_speed = 1.5
def blitme(self):
'''Draw the ship at its current location.'''
self.screen.blit(self.image, self.rect)
def update(self):
'''Update the ship's position based on the movement flag'''
# Update the ship's x value, not the rect.
if self.moving_right and self.rect.right < self.screen_rect.right :
self.x += self.settings.ship_speed
if self.moving_left and self. rect.left > 0 :
self.x -= self.settings. ship_speed
# Update rect object from self.x
self.rect.x = self.x
def center_ship(self):
'''Center the ship on the screen'''
self.rect.midbottom = self.screen_rect.midbottom
self.x = float(self.rect.x)
# Scoreboard
import pygame.font
from pygame.sprite import Group
from Ship import Ship
class Scoreboard :
'''A class to represent scoring information'''
def __init__(self, ai_game):
'''Initialize scorekeeping attributes'''
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for scoring information
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score images
self.prep_score()
self.prep_high_score()
self.prep_level()
# High score should never be reset
self.high_score = 0
def prep_level(self):
'''Turn the level into a rendered image'''
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True,
self.text_color, self.settings.bg_color)
# Position the level below the score
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10
def prep_score(self):
'''Turn the score into a rendered image'''
rounded_score = round(self.stats.score, -1)
score_str = "{:,},".format(rounded_score)
score_str = str(self.stats.score)
self.score_image = self.font.render(score_str, True,
self.text_color, self.settings.bg_color)
# Display the score at the top right of the screen
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_ships(self):
'''Show how many ships are left'''
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
'''Draw scores, level, and ships to the screen'''
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
def prep_high_score(self):
'''Turn the high score into a rendered_image'''
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color, self.settings.bg_color)
# Center the high score at the top of the screen
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def check_high_score(self):
'''Check to see if there's a new high score'''
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
When i run alien_invasion, i get this error :
pygame 2.0.1 (SDL 2.0.14, Python 3.9.6)
Hello from the pygame community. https://www.pygame.org/contribute.html
Traceback (most recent call last):
File "C:\Users\basti\OneDrive\Documents\Python\Alien Invasion\Alien Invasion.py", line 321, in <module>
ai = AlienInvasion()
File "C:\Users\basti\OneDrive\Documents\Python\Alien Invasion\Alien Invasion.py", line 38, in __init__
self.sb = Scoreboard()
TypeError: __init__() missing 1 required positional argument: 'ai_game'
[Finished in 1.4s]
Could someone help me correct it ?
P.S. : Also, I don't understand why we use the self argument in self.ship = Ship(self) and self.alien = Alien(self)
Related
Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 1 year ago.
Improve this question
I am working on the Alien Invasion project at the end of Python Crash Course 2nd Edition and I am having a problem with my game ending after the user runs out of lives. The game is supposed to end after all 3 lives are lost but when that happens for mine the aliens continue to move off the bottom of the screen. There are no error messages and from my many checks through the code I have entered it word for word from the book. I have worked up to the section where the scoreboard is added but now I am resetting the scoreboard which requires the game to end properly. Below is a copy of all the necessary code files that would apply to this issue. Each separate file is indicated by #filename.py and the code for said file follows. If there is anything else needed to check through this please let me know.
# Project Qapla'
# Matthew Moore
# alien_invasion.py
import sys
from time import sleep
import pygame
from settings import Settings
from game_stats import GameStats
from scoreboard import Scoreboard
from button import Button
from ship import Ship
from bullet import Bullet
from alien import Alien
class AlienInvasion:
"""Overall class to manage assets and behaviour."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
#Partial screen play control
self.screen = pygame.display.set_mode(
(self.settings.screen_width,self.settings.screen_height))
#Full screen play control
#self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
#self.settings.screen_width = self.screen.get_rect().width
#self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
#Make the play button
self.play_button = Button(self, "Play")
def run_game(self):
"""Start the main loop for the game."""
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
#Make the most recently drawn screen visible.
pygame.display.flip()
def _check_events(self):
"""Respond to keypresses abd mouse events."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_keydown_events(self,event):
"""Respond to key presses."""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self,event):
"""Respond to key releases."""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _check_play_button(self, mouse_pos):
"""Starts new game when player clicks play button"""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
#Reset the game statistics
self.settings.initialize_dynamic_settings()
self.stats.game_active = True
#Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
#create a new fleet and center the ship
self._create_fleet()
self.ship.center_ship()
#Hide Mouse cursor
pygame.mouse.set_visible(False)
def _fire_bullet(self):
"""Create a new bullet and add it to the bullets group."""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
"""Update postiion of bullets and get rid of old bullets."""
#Update bullet positions
self.bullets.update()
#Get rid of bullets that have disappeared
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
#print(len(self.bullets))
self._check_bullet_alien_collision()
def _check_bullet_alien_collision(self):
"""Responds to bullet-alien collisions"""
#Check for any bullets that have hit aliens
#If so, get rid of alien and bullet
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, True, True)
if collisions:
self.stats.score += self.settings.alien_points
self.sb.prep_score()
if not self.aliens:
#Destroy existing bullets and create a new fleet
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
def _update_aliens(self):
"""Update the positions of all alliens in the fleet/Check if
fleet is on an edge"""
self._check_fleet_edges()
self.aliens.update()
#look for alien-ship collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
self._check_alien_bottom()
def _ship_hit(self):
"""Responds to a ship being hit by an alien"""
if self.stats.ships_left > 0:
self.stats.ships_left -= 1
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.ship.center_ship()
sleep(0.5)
else:
self.stats.game_active_ = False
pygame.mouse.set_visible(True)
def _create_fleet(self):
"""create the fleet of aliens"""
#create an alien and find the number of aliens in a row.
#Spacing between each alien is equal to one alien width.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
avaliable_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = avaliable_space_x // (2*alien_width)
#determine th enumber of rows of aliens that fit on the screen
ship_height = self.ship.rect.height
avaliable_space_y = (self.settings.screen_height-
(3*alien_height) - ship_height)
number_rows = avaliable_space_y // (2 * alien_height)
#Create the full fleet of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
#create an alien and [place it in the row
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2*alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien_height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
"""Respond approprietly if any aliens have touched an edge"""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _check_alien_bottom(self):
"""Checks if aliens have reached the bottom of the screen"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self._ship_hit()
break
#treats it the same as ship getting hit
def _change_fleet_direction(self):
"""Drop the fleet and change direction"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Update images on the screen, and flip to the new screen."""
# Redraw the screen during each pass
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
#Draw the score information
self.sb.show_score()
#draw the button if game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
if __name__ == '__main__':
# Make a game instance, and run the game.
ai = AlienInvasion()
ai.run_game()
#alien.py
import pygame
from pygame.sprite import Sprite
class Alien(Sprite):
"""A class to represent a single alien in the fleet"""
def __init__(self, ai_game):
"""Initialize the alien and its starting position"""
super().__init__()
self.screen = ai_game.screen
self.settings = ai_game.settings
#Load the alien image and set its rect attribute
self.image = pygame.image.load('images/alien.bmp')
self.rect = self.image.get_rect()
#Start each new alien near the top left of the screen
self.rect.x = self.rect.width
self.rect.y = self.rect.height
#store the aliens exact horizontal position
self.x = float(self.rect.x)
def update(self):
"""Move alien to the right or left"""
self.x += (self.settings.alien_speed * self.settings.fleet_direction)
self.rect.x = self.x
def check_edges(self):
"""Returns true if alien is at edge of the screen"""
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right or self.rect.left <= 0:
return True
# settings.py
class Settings:
"""A class to store all settings for Alien Invasion."""
def __init__(self):
"""Initialize the game's static settings."""
# Screen settings
self.screen_width = 1200
self.screen_height = 800
self.bg_color = (230, 230, 230)
#Ship settings
self.ship_speed = 3
self.ship_limit = 3
#Bullet settings
self.bullet_speed = 2.0
self.bullet_width = 3
self.bullet_height = 15
self.bullet_color = (60, 60, 60)
self.bullets_allowed = 3
#Alien settings
self.alien_speed = 1.0
self.fleet_drop_speed = 10
#fleet_direction of 1 represents right; -1 represents left
self.fleet_direction = 1
#How quickly the game speeds up
self.speedup_scale = 1.1
self.initialize_dynamic_settings()
def initialize_dynamic_settings(self):
"""Initialize settings that change throughout the game"""
self.ship_speed = 1.5
self.bullet_speed = 3.0
self.alien_speed = 1.0
self.fleet_direction = 1
#Scoring
self.alien_points = 50
def increase_speed(self):
"""Increases speed settings"""
self.ship_speed *= self.speedup_scale
self.bullet_speed *= self.speedup_scale
self.alien_speed *= self.speedup_scale
#game_stats.py
class GameStats:
"""Track statistics of alien invasion"""
def __init__(self, ai_game):
"""Initialize stats"""
self.settings = ai_game.settings
self.reset_stats()
self.game_active = False
def reset_stats(self):
"""Initialize stats that can change during the game"""
self.ships_left = self.settings.ship_limit
self.score = 0
#ship.py
import pygame
class Ship:
"""A class to manage the ship."""
def __init__(self, ai_game):
"""Initiatilize the ship and set its starting position."""
self.screen = ai_game.screen
self.settings = ai_game.settings
self.screen_rect = ai_game.screen.get_rect()
# Load the ship image and get its rect.
self.image = pygame.image.load('images/ship.bmp')
self.rect = self.image.get_rect()
#Start each new ship at the bottom center of the screen.
self.rect.midbottom = self.screen_rect.midbottom
#Store a decimal value for the ships horizontal position.
self.x = float(self.rect.x)
#Movement flag
self.moving_right = False
self.moving_left = False
def update(self):
"""Update the ship's position based on the movement flags."""
#Update the ships x value, not th erect.
if self.moving_right and self.rect.right < self.screen_rect.right:
self.x += self.settings.ship_speed
if self.moving_left and self.rect.left > 0:
self.x -= self.settings.ship_speed
#Update rect object from self.x.
self.rect.x = self.x
def blitme(self):
""""Draw the ship at its current location."""
self.screen.blit(self.image, self.rect)
def center_ship(self):
self.rect.midbottom = self.screen_rect.midbottom
self.x = float(self.rect.x)
**Converting my comment to an answer
original comment:
"This is just a guess, but in your _ship_hit function you have self.stats.game_active_= False
Should that be
self.stats.game_active = False?
it looks like you might have an extra underscore at the end"
I'm struggling with adjusting my game so that my fleet of aliens doesn't start out under my top UI. I know this has something to do with adjusting my first generation of my alien, before I create the fleet, but I'm pretty new to coding in general and am just not quite sure what I need to adjust.
This game as made while following along with Python Crash Course 2nd Edition.
As you can see, my fleet sits under my ship UI
Adjust some code to render Aliens ontop of UI
This suggestion, puts my aliens over top of my UI, which I guess is better, but I my opinion still does not look good.
alien_invasion.py
def __init__(self):
"""Initlize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((
self.settings.screen_width, self.settings.screen_height
))
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
#Set our background color
self.bg_color = (230, 230, 230)
self.play_button = Button(self, "Play")
def run_game(self):
"""Start main loop for our game."""
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _check_events(self):
"""Respond to kepresses and mouse events."""
#for each event in game capture that event
for event in pygame.event.get():
#if player preses close, quit game
if event.type == pygame.QUIT:
sys.exit()
# if event is a key press
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
"""start new game if player clicks play"""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
self.settings.initialize_dynamic_settings()
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.ship.center_ship()
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""respond to keydown events"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _fire_bullet(self):
"""create a new bullet and add it to the bullets group"""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
# add is simpler than append, but is only avaliable in pygame
self.bullets.add(new_bullet)
def _update_bullets(self):
"""update bullets position and get rid of old bullets"""
#update bullets position
self.bullets.update()
# get rid of bullets that leave the window
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
"""respond to bullet-alien collisions"""
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, False, True
)
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
self.bullets.empty()
self._create_fleet()
self.settings.increse_speed()
self.stats.level += 1
self.sb.prep_level()
def _update_aliens(self):
"""update the position of the aliens"""
self._check_fleet_edges()
self.aliens.update()
# look for alien ship collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
self._check_aliens_bottom()
def _ship_hit(self):
"""respond to the ship being hit by alien"""
if self.stats.ships_left > 0:
# decrese ships left
self.stats.ships_left -= 1
self.sb.prep_ships()
# get rid of any remaining aliens and bullets
self.aliens.empty()
self.bullets.empty()
# create new fleet and recenter ship
self._create_fleet()
self.ship.center_ship()
# small pause for reset
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _create_fleet(self):
"""create our fleet of aliens"""
# creat an alien and fine the number that fits in a row
# spacing between each alien is equal to one alien
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
# determine the number of rows that fit on the screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height -
(3 * alien_height) - ship_height)
number_rows = available_space_y // (2 * alien_height)
# create a full fleet of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien_height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
"""respond if any aliens reach the edge"""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _check_aliens_bottom(self):
"""check if any aliens have reached the bottom of the screen"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self._ship_hit()
break
def _change_fleet_direction(self):
"""drop entire fleet and change direction"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Update images on screen and flip to the new screen."""
#fill our background with our bg_color
self.screen.fill(self.settings.bg_color)
#draw ship to screen
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
# draw scoreboard to screen
self.sb.show_score()
self.aliens.draw(self.screen)
# draw play button if game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
#Make the most recently drawn screen visible.
#this clears our previous screen and updates it to a new one
#this gives our programe smooth movemnt
pygame.display.flip()
alien.py
def __init__(self, ai_game):
"""initlize alien and set its starting position"""
super().__init__()
self.screen = ai_game.screen
self.settings = ai_game.settings
self.screen_rect = ai_game.screen.get_rect()
# load alien image at set its rect
self.image = pygame.image.load('images/alien.bmp')
self.rect = self.image.get_rect()
# start each new alien at the top left of the screen
self.rect.x = self.rect.width
self.rect.y = self.rect.height
# store aliens exact position (decimal)
self.x = float(self.rect.x)
def check_edges(self):
"""return true if alien is at edge of screen"""
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right or self.rect.left <= 0:
return True
def update(self):
"""move the alien to the right or left"""
self.x += (self.settings.alien_speed *
self.settings.fleet_direction)
self.rect.x = self.x
I'm looking to draw my first alien to screen further down the screen so that it does not interfere with my UI at all.
To my understanding this is an issue with where the first alien is being drawn to screen.
self.rect.x = self.rect.width
self.rect.y = self.rect.height
This should be giving the first alien the space of one alien to the left and to the top of the alien, but when I adjust self.rect.y in any way, nothing actually changes in the way the aliens are drawn to screen.
Any help on understanding this concept more would be greatly appreciated.
You need to adapt the code in the _create_fleet and _create_alien methods of your first class to account for the space being taken up at the top of the screen by the UI. I don't know exactly what size you want there, but I'll point out where to put it in the code below:
def _create_fleet(self):
"""create our fleet of aliens"""
# creat an alien and fine the number that fits in a row
# spacing between each alien is equal to one alien
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
# determine the number of rows that fit on the screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - # substract UI height here
(3 * alien_height) - ship_height)
number_rows = available_space_y // (2 * alien_height)
# create a full fleet of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien_height + 2 * alien.rect.height * row_number # add UI height here
self.aliens.add(alien)
I managed the first part of this exercise, back in chapter 12, without any problems, but now that I'm trying to add aliens into the mix, I've run into trouble.
I can't get them to draw in at the top right of the screen, they keep starting at the top left; and they aren't moving at all.
Everything else seems to be working just fine, including ship movement and bullet collision.
So, how do I get the aliens to draw in starting at the top right, in columns, and have them move up and down?
sideways_shooter.py
import sys
from time import sleep
import pygame
from settings import Settings
from game_stats import GameStats
from ship import Ship
from bullet import Bullet
from alien import Alien
class SidewaysShooter:
"""Overall class to manage game assets and behavior"""
def __init__(self):
"""Initialize the game and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Sideways Shooter")
self.stats = GameStats(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
def run_game(self):
"""Start the main loop for the game"""
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
#self._update_aliens()
self._update_screen()
def _check_events(self):
#Respond to keypresses and mouse events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
def _check_keydown_events(self, event):
#Respond to keypresses
if event.key == pygame.K_UP:
self.ship.moving_up = True
elif event.key == pygame.K_DOWN:
self.ship.moving_down = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
#Respond to key releases
if event.key == pygame.K_UP:
self.ship.moving_up = False
elif event.key == pygame.K_DOWN:
self.ship.moving_down = False
def _update_aliens(self):
#Check if the fleet is at an edge, update the position of all the aliens
self._check_fleet_edges()
self.aliens.update()
#Check for alien-ship collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
#Look for aliens hitting the bottom
self._check_aliens_bottom()
def _fire_bullet(self):
#Create a new bullet and add it to the bullets group
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
#Update position of bullets and get rid of old bullets
#Update bullet positions
self.bullets.update()
#Get rid of bullets that have left the screen
for bullet in self.bullets.copy():
if bullet.rect.left >= self.settings.screen_width:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
#Respond to alien bullet collsions
#Remove any bullets and aliens that have collided
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, True, True)
if not self.aliens:
#Destroy existing bullets and create new fleet
self.bullets.empty()
self._create_fleet()
def _update_screen(self):
#Update images on the screen, and flip to the new screen
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
pygame.display.flip()
def _create_fleet(self):
#Create the fleet of aliens
#Make an alien and find the number of aliens in a column
#Spacing between each alien should be equal to one alien height
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_y = self.settings.screen_height - (2 * alien_height)
number_aliens_y = available_space_y // (2 * alien_height)
#Determine the number of columns that can fit on the screen
ship_width = self.ship.rect.width
available_space_x = (self.settings.screen_width -
(4 * alien_width) - ship_width)
number_rows = available_space_x // (2 * alien_width)
#Create the full fleet of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_y):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
#Create an alien and place it in the column
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.y = alien_height + 2 * alien_height * alien_number
alien.rect.y = alien.y
alien.rect.x = alien.rect.width + 2 * alien.rect.width * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
#Respond appropriately if any aliens have reached an edge
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
#Drop the entire fleet and change direction
for alien in self.aliens.sprites():
alien.rect.x += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _check_aliens_bottom(self):
#Check if any aliens have reached the left of the screen
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.left >= screen_rect.left:
#Treat this the same as if the ship was hit
self._ship_hit()
break
def _ship_hit(self):
#Respond to the ship being hit by an alien
if self.stats.ships_left > 0:
#Decrement ships_left
self.stats.ships_left -= 1
#Get rid of any remaining aliens and bullets
self.aliens.empty()
self.bullets.empty()
#Create a new fleet and center the ship
self._create_fleet()
self.ship.center_ship()
#Pause
sleep(0.5)
else:
self.stats.game_active = False
if __name__ == '__main__':
#Make a game instance, and run the game
ai = SidewaysShooter()
ai.run_game()
alien.py
import pygame
from pygame.sprite import Sprite
class Alien(Sprite):
#A class to represent an alien
def __init__(self, ai_game):
#Initialize the alien and set its starting position
super().__init__()
self.screen = ai_game.screen
self.settings = ai_game.settings
#Load the alien image and set its rect attribute
self.image = pygame.image.load('images/alien.bmp')
self.rect = self.image.get_rect()
#Start each new alien near the top right of the screen
self.rect.x = self.settings.screen_width - self.rect.width
self.rect.y = self.rect.height
#Store the alien's exact vertical position
self.y = float(self.rect.y)
def check_edges(self):
#Return True if alien is at the edge of screen
screen_rect = self.screen.get_rect()
if self.rect.bottom >= screen_rect.bottom or self.rect.top <= 0:
return True
def update(self):
#Move the alien up or down
self.y += (self.settings.alien_speed *
self.settings.fleet_direction)
self.rect.y = self.y
I believe your aliens are appearing on the left side of the screen because of this line:
alien.rect.x = alien.rect.width + 2 * alien.rect.width * row_number
When the row number is 0, the second term here is 0, and the alien's x position will be equal to its width.
If you want them to start appearing on the right side of the screen, you can make its initial position equal to the screen width minus a certain amount, like a multiple of the alien's width.
The code runs and it works then pops up error at line at the end. ai.run_game() is where it occurs. i can see the ship and aliens move then it pops up the error. I dont know what i am doing wrong I followed the book exactly. Does anybody have any ideas on what I should do to fix this. I am doing this in Visual Studios. Here is the code:
alien_invasion.py
import sys
import pygame
from settings import Settings
from ship import Ship
from bullet import Bullet
from alien import Alien
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Intitialize the game and create new resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
def run_game(self):
"""Start the main loop for the game."""
while True:
self._check_events()
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
# Watch for a keyboard and mouse events.
def _check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
def _check_keydown_events(self, event):
if event.key == pygame.K_RIGHT:
#move ship to the right
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
"""Respond to key releases"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _fire_bullet(self):
"""Create a new bullet and add it to the bullet group"""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
"""Update position of bullets and get rid of old bullets"""
#Update bullet positions
self.bullets.update()
#Get rid of old bullets
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
def _update_aliens(self):
"""update the positions of all aliens in the fleet"""
#check if alien is at an edge and then update positions.
self._check_fleet_edges()
self.aliens.update()
def _create_fleet(self):
"""Create a fleet of aliens."""
#make an alien and find the number of aliens in a row.
#spacing between one alien is equal to one alien width
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
#Determine the number of rows of aliens that fit on screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3 * alien_height) - ship_height)
number_rows = available_space_y // (2 * alien_height)
#create first row of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
#Create alien place in row
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
"""Respond appropriately if any aliens have reached an edge."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""Drop the entire fleet and change direction"""
for alien in self.aliens.sprite():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Update images on screen and flip to the new screen."""
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
#Make the most recently drawn screen visible
pygame.display.flip()
if __name__ == '__main__':
#Make a game instance, and run the game
ai = AlienInvasion()
ai.run_game()
settings.py
class Settings:
"""A class to store all the settings for Alien Invasion"""
def __init__(self):
"""Initialize the game's settings."""
#Screen settings
self.screen_width = 800
self.screen_height = 600
self.bg_color = (230, 230, 230)
#ship settings
self.ship_speed = 1.5
#bullet settings
self.bullet_speed = 1.0
self.bullet_width = 3
self.bullet_height = 15
self.bullet_color = (60, 60, 60)
self.bullets_allowed = 3
#alien settings
self.alien_speed = 1.0
self.fleet_drop_speed = 10
#Fleet direction of 1 represents right, -1 left.
self.fleet_direction = 1
bullet.py
import pygame
from pygame.sprite import Sprite
class Bullet(Sprite):
"""A class to manage bullets fired from the ship."""
def __init__(self, ai_game):
"""Create a bullet object at the ships current position"""
super().__init__()
self.screen = ai_game.screen
self.settings = ai_game.settings
self.color = self.settings.bullet_color
#Create a bullet rect at (0,0) and then set correct position
self.rect = pygame.Rect(0, 0, self.settings.bullet_width, self.settings.bullet_height)
self.rect.midtop = ai_game.ship.rect.midtop
#Store the bullets position as a decimal value
self.y = float(self.rect.y)
def update(self):
"""Move the bullet up the screen"""
#Update the decimal position of the bullet.
self.y -= self.settings.bullet_speed
#Update rect position.
self.rect.y = self.y
def draw_bullet(self):
"""Draw the bullet to the screen"""
pygame.draw.rect(self.screen, self.color, self.rect)
alien.py
import pygame
from pygame.sprite import Sprite
class Alien(Sprite):
"""A class to represent a single alien in the fleet."""
def __init__(self, ai_game):
"""Initialize the alien and set its starting position."""
super().__init__()
self.screen = ai_game.screen
self.settings = ai_game.settings
#Load the alien image and set is rect attribute.
self.image = pygame.image.load("Images/alien.bmp")
self.rect = self.image.get_rect()
#Starte each new alien near the top left of the screen
self.rect.x = self.rect.width
self.rect.y = self.rect.height
#Store the aliens exact horizontal position
self.x = float(self.rect.x)
def check_edges(self):
"""return true if alien is at edge of screen"""
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right or self.rect.left <= 0:
return True
def update(self):
"""Move the alien to the right"""
self.x += (self.settings.alien_speed * self.settings.fleet_direction)
self.rect.x = self.x
ship.py
import pygame
class Ship:
"""A class to manage the ship."""
def __init__(self, ai_game):
"""Initialize the ship and set its starting position."""
self.screen = ai_game.screen
self.settings = ai_game.settings
self.screen_rect = ai_game.screen.get_rect()
#load the ship image and get its rect
self.image = pygame.image.load('Images/ship.bmp')
self.rect = self.image.get_rect()
#Start each new ship at the bottom of the screen
self.rect.midbottom = self.screen_rect.midbottom
#Store a decimal value for the ships horizontal position
self.x = float(self.rect.x)
#Movement flag
self.moving_right = False
self.moving_left = False
def update(self):
"""Update the ships position based on the movement flag."""
#update the ships x value not the rect
if self.moving_right and self.rect.right < self.screen_rect.right:
self.x += self.settings.ship_speed
if self.moving_left and self.rect.left > 0:
self.x -= self.settings.ship_speed
#Update rect from self.x
self.rect.x = self.x
def blitme(self):
"""Draw the ship at its current location."""
self.screen.blit(self.image, self.rect)
You have two groups, bullets and aliens. The error message says that a group doesn't have a sprite attribute. So searching for bullets.sprite and aliens.sprite, I find this:
def _change_fleet_direction(self):
"""Drop the entire fleet and change direction"""
for alien in self.aliens.sprite():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
I believe the error is in the for line. You need to loop over self.aliens.sprites() with an s, not self.alien.sprite().
I'm making the Alien Invasion game project from the Python Crash Course book and got stuck with the part where the alien fleet should go right until they reach the right edge of the screen, change direction and go left, and so forth.
The problem is my aliens indeed change direction but only when the first alien in the block (the first one all the way on the left) hits the right edge of the screen. All the aliens right of him go past the right edge.
It seems that it doesn't recognize the rect from the aliens on the right which should hit the right edge first but only the rect from the first alien all the way on the left...
1. Starting Position Image
2. The Problem Image
I'm following closely the instructions from the book, and I checked 3 times now where the problem could be. Could you help me find the problem, please?
alien_invasion.py
import sys
import pygame
from settings import Settings
from ship import Ship
from bullet import Bullet
from alien import Alien
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Set the background color.
self.bg_color = (230, 230, 230)
def run_game(self):
"""Start the main loop for the game."""
while True:
self._check_events()
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _check_events(self):
"""Respond to keypresses and mouse events."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
def _check_keydown_events(self, event):
"""Respond to keypresses."""
if event.key == pygame.K_RIGHT:
# Move the ship to the right.
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
# Move the ship to the left.
self.ship.moving_left = True
elif event.key == pygame.K_q:
# Exit the game after pressing Q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
"""Respond to keypresses."""
if event.key == pygame.K_RIGHT:
# Stop moving the ship to the right.
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
# Stop moving the ship to the left.
self.ship.moving_left = False
def _fire_bullet(self):
"""Create a new bullet and add it to the bullets group."""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
"""Update position of bullets and get rid of old bullets."""
# Update bullets positions.
self.bullets.update()
# Get rid of bullets that have dissapeared.
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
def _update_aliens(self):
"""Check if the fleet is at an edge, then update the positions of all aliens in the fleet."""
self._check_fleet_edges()
"""Update the positios of all aliens in the fleet."""
self.aliens.update()
def _create_fleet(self):
"""Create a fleet of aliens."""
# Create an alien and find the number of aliens in a row.
# Spacing between each alien is equal to one alien width.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
# Determine the number of rows of aliens that fit on the screen.
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3 * alien_height) - ship_height)
number_rows = available_space_y // (4 * alien_height)
# Create the full fleet of aliens.
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
# Create an alien and place it in the row.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 4 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 3 * alien.rect.height * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
"""Respond appropriately if any aliens have reached an edge."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""Drop the entire fleet and change the fleet's direction."""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Update images on the screen, and flip to the new screen."""
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
pygame.display.flip()
if __name__ == '__main__':
# Make a game instance, and run the game.
ai = AlienInvasion()
ai.run_game()
settings.py
class Settings:
"""A class to store all settings for Alien Invasion."""
def __init__(self):
"""Initialize the game's settings."""
# Screen settings
self.screen_width = 1200
self.screen_height = 800
self.bg_color = (230, 230, 230)
self.ship_speed = 1.5
# Bullet settings
self.bullet_speed = 1.0
self.bullet_width = 3
self.bullet_height = 15
self.bullet_color = (60, 60, 60)
self.bullets_allowed = 3
# Alien settings
self.alien_speed = 1.0
self.fleet_drop_speed = 10
# fleet_direction of 1 represents right; -1 represents left.
self.fleet_direction = 1
alien.py
import pygame
from pygame.sprite import Sprite
class Alien(Sprite):
"""A class to represent a single alien in the fleet."""
def __init__(self, ai_game):
"""Initialize the alien and set its starting postion."""
super().__init__()
self.screen = ai_game.screen
self.settings = ai_game.settings
# Load the alien image and set its rect attribute.
self.image = pygame.image.load('images/alien.bmp')
self.rect = self.image.get_rect()
# Start each new alien near the top left of the screen.
self.rect.x = self.rect.width
self.rect.y = self.rect.height
# Store the alien's exact horizontal position.
self.x = float(self.rect.x)
def check_edges(self):
"""Return True if an alien is at edge of screen."""
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right or self.rect.left <= 0:
return True
def update(self):
"""Move the alien right or left."""
self.x += self.settings.alien_speed * self.settings.fleet_direction
self.rect.x = self.x
It's a matter of Indentation. You need to find the first alien that hits an edge and then break the loop. Actually, you always break the loop after the first enemy in the list:
class AlienInvasion:
# [...]
def _check_fleet_edges(self):
"""Respond appropriately if any aliens have reached an edge."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
#-->| INDENTATION
break
# break <-- DELETE