ai@quaat.com
Are you familiar with the game "space invaders"?
Yes, I'm familiar with Space Invaders. It is a classic arcade video game developed by Tomohiro Nishikado and released by Taito in 1978. In the game, players control a small spaceship at the bottom of the screen, and their goal is to defend the Earth from waves of descending alien invaders. The aliens move from side to side and gradually advance towards the bottom of the screen. Players must shoot down the invaders while avoiding their projectiles and the occasional flying saucer that passes by overhead.
Space Invaders was a major commercial success and had a significant impact on the video game industry. It helped to popularize the shoot 'em up genre and pave the way for future arcade and home console games. Its iconic pixelated characters, sound effects, and gameplay have made it a beloved classic and an important piece of video game history.
ai@quaat.com
Great! Today we will be making our own version of the game with PyGame. We have all the necessary sprites in .png files. Set up the main game field, by populating the alien invaders in 11 columns and 5 rows at the top of the page. We have 4 different types of alien invaders, so the bottom 2 rows will consist of the same type. The player will control a spaceship at the bottom of the screen. Movement will be controlled by pressing the arrow buttons left and right. In addition, our spaceship will shoot upwards by pressing "space". The bullets will also be a loaded from a .png file. If the bullet hits an alien, the alien ship will disappear and 10 points are granted. The alien ships from the bottom row will also shoot bullets downward. If a bullet hits our spaceship, it is game over.
To create your own Space Invaders game using Pygame, follow the steps below. Make sure you have Pygame installed. If not, you can install it using pip install pygame.
Import the necessary modules:
import pygame
import sys
import random
from pygame.locals import *Initialize the Pygame module, define constants, and load the sprites:
pygame.init()
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
WHITE = (255, 255, 255)
FPS = 60
ALIEN_COLUMNS = 11
ALIEN_ROWS = 5
ALIEN_SPACING = 40
SCORE = 0
player_img = pygame.image.load("player.png")
bullet_img = pygame.image.load("bullet.png")
alien1_img = pygame.image.load("alien1.png")
alien2_img = pygame.image.load("alien2.png")
alien3_img = pygame.image.load("alien3.png")
alien4_img = pygame.image.load("alien4.png")
alien_imgs = [alien1_img, alien2_img, alien2_img, alien3_img, alien4_img]Define the classes for the game objects:
class Player(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.image = player_img
self.rect = self.image.get_rect()
self.rect.midbottom = (SCREEN_WIDTH // 2, SCREEN_HEIGHT - 30)
def update(self, keys):
if keys[K_LEFT]:
self.rect.move_ip(-5, 0)
if keys[K_RIGHT]:
self.rect.move_ip(5, 0)
class Bullet(pygame.sprite.Sprite):
def __init__(self, x, y, direction):
super().__init__()
self.image = bullet_img
self.rect = self.image.get_rect()
self.rect.center = (x, y)
self.direction = direction
def update(self):
self.rect.move_ip(0, self.direction * 10)
if self.rect.bottom < 0 or self.rect.top > SCREEN_HEIGHT:
self.kill()
class Alien(pygame.sprite.Sprite):
def __init__(self, alien_type, x, y):
super().__init__()
self.image = alien_imgs[alien_type]
self.rect = self.image.get_rect()
self.rect.topleft = (x, y)Initialize the game objects, and create the main game loop:
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
clock = pygame.time.Clock()
pygame.display.set_caption("Space Invaders")
player = Player()
aliens = pygame.sprite.Group()
bullets = pygame.sprite.Group()
for row in range(ALIEN_ROWS):
for col in range(ALIEN_COLUMNS):
x = col * (alien_imgs[row].get_width() + ALIEN_SPACING)
y = row * (alien_imgs[row].get_height() + ALIEN_SPACING)
alien = Alien(row, x, y)
aliens.add(alien)
while True:
screen.fill(WHITE)
keys = pygame.key.get_pressed()
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN and event.key == K_SPACE:
bullet = Bullet(player.rect.centerx, player.rect.top, -1)
bullets.add(bullet)
player.update(keys)
bullets.update()
aliens_hit = pygame.sprite.groupcollide(bullets, aliens, True, True)
SCORE += len(aliens_hit) * 10
if random.random() < 0.01:
alien_shooter = random.choice(aliens.sprites())
alien_bullet = Bullet(alien_shooter.rect.centerx, alien_shooter.rect.bottom, 1)
bullets.add(alien_bullet)
if pygame.sprite.spritecollide(player, bullets, False):
pygame.quit()
sys.exit()
aliens.draw(screen)
bullets.draw(screen)
screen.blit(player.image, player.rect)
pygame.display.flip()
clock.tick(FPS)Now you have a basic Space Invaders game using Pygame. The alien ships are arranged in rows and columns, and the player can move left and right using the arrow keys while shooting using the spacebar. The aliens at the bottom row will randomly shoot bullets downward. When a bullet hits an alien ship, the ship disappears, and the player earns 10 points. If a bullet hits the player's spaceship, the game ends.
You can further enhance the game by adding more features, such as a scoring system, lives, different levels, or sound effects.
ai@quaat.com
the image sprites are a bit too large, please scale all images to an appropriate size
To scale the images to a more appropriate size, you can use the pygame.transform.scale() function. For example, if you want to scale the images down to 50% of their original size, you can do the following:
Scale the images after loading them:
scale_factor = 0.5
player_img = pygame.transform.scale(player_img, (int(player_img.get_width() * scale_factor), int(player_img.get_height() * scale_factor)))
bullet_img = pygame.transform.scale(bullet_img, (int(bullet_img.get_width() * scale_factor), int(bullet_img.get_height() * scale_factor)))
alien1_img = pygame.transform.scale(alien1_img, (int(alien1_img.get_width() * scale_factor), int(alien1_img.get_height() * scale_factor)))
alien2_img = pygame.transform.scale(alien2_img, (int(alien2_img.get_width() * scale_factor), int(alien2_img.get_height() * scale_factor)))
alien3_img = pygame.transform.scale(alien3_img, (int(alien3_img.get_width() * scale_factor), int(alien3_img.get_height() * scale_factor)))
alien4_img = pygame.transform.scale(alien4_img, (int(alien4_img.get_width() * scale_factor), int(alien4_img.get_height() * scale_factor)))
alien_imgs = [alien1_img, alien2_img, alien2_img, alien3_img, alien4_img]Adjust the ALIEN_SPACING constant to maintain a proper distance between the smaller alien sprites:
ALIEN_SPACING = int(ALIEN_SPACING * scale_factor)Now, the images will be scaled down to 50% of their original size. You can adjust the scale_factor variable to any desired value between 0 and 1 to scale the images accordingly. Make sure to keep it as a float (e.g., 0.5) to avoid integer division issues.
ai@quaat.com
change the game logic such that the alien ships will move from back and forth horizontally, and gradually come down and closer to the player ship. If the the alien ships reach the player ship, the game ends. If the player is able to shoot down all alien ships, the game is reset with new aliens, but this time they will move increasingly faster for each re-spawn. In addition, the shooting frequency of the alien ships will increase.
To implement the requested changes, follow these steps:
Add new constants to control alien movement and shooting frequency:
ALIEN_SPEED = 2
ALIEN_DROP = 30
ALIEN_SHOOT_PROB = 0.01
SPEED_INCREASE_FACTOR = 1.25
SHOOT_PROB_INCREASE_FACTOR = 1.25Modify the Alien class to include a speed attribute:
class Alien(pygame.sprite.Sprite):
def __init__(self, alien_type, x, y, speed):
super().__init__()
self.image = alien_imgs[alien_type]
self.rect = self.image.get_rect()
self.rect.topleft = (x, y)
self.speed = speed
def update(self):
self.rect.x += self.speedUpdate the alien creation loop to include the speed attribute:
for row in range(ALIEN_ROWS):
for col in range(ALIEN_COLUMNS):
x = col * (alien_imgs[row].get_width() + ALIEN_SPACING)
y = row * (alien_imgs[row].get_height() + ALIEN_SPACING)
alien = Alien(row, x, y, ALIEN_SPEED)
aliens.add(alien)Update the main game loop to handle the new alien movement and game logic:
alien_shoot_prob = ALIEN_SHOOT_PROB
while True:
screen.fill(WHITE)
keys = pygame.key.get_pressed()
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN and event.key == K_SPACE:
bullet = Bullet(player.rect.centerx, player.rect.top, -1)
bullets.add(bullet)
player.update(keys)
aliens.update()
bullets.update()
for alien in aliens:
if alien.rect.right >= SCREEN_WIDTH or alien.rect.left <= 0:
for a in aliens:
a.speed = -a.speed
a.rect.y += ALIEN_DROP
break
aliens_hit = pygame.sprite.groupcollide(bullets, aliens, True, True)
SCORE += len(aliens_hit) * 10
if random.random() < alien_shoot_prob:
alien_shooter = random.choice(aliens.sprites())
alien_bullet = Bullet(alien_shooter.rect.centerx, alien_shooter.rect.bottom, 1)
bullets.add(alien_bullet)
if pygame.sprite.spritecollide(player, bullets, False) or any(alien.rect.colliderect(player.rect) for alien in aliens):
pygame.quit()
sys.exit()
if not aliens:
ALIEN_SPEED *= SPEED_INCREASE_FACTOR
alien_shoot_prob *= SHOOT_PROB_INCREASE_FACTOR
for row in range(ALIEN_ROWS):
for col in range(ALIEN_COLUMNS):
x = col * (alien_imgs[row].get_width() + ALIEN_SPACING)
y = row * (alien_imgs[row].get_height() + ALIEN_SPACING)
alien = Alien(row, x, y, ALIEN_SPEED)
aliens.add(alien)
aliens.draw(screen)
bullets.draw(screen)
screen.blit(player.image, player.rect)
pygame.display.flip()
clock.tick(FPS)Now, the alien ships will move back and forth horizontally and gradually come down. If the alien ships reach the player ship or the player gets hit by an alien bullet, the game ends. If the player shoots down all alien ships, the game resets with new aliens, and they move increasingly faster for each respawn. Additionally, the shooting frequency of the alien ships will increase.
With these changes, the game's difficulty will progressively increase as the player successfully clears each wave of aliens. The alien ships will move faster and shoot more frequently, presenting an ongoing challenge for the player.
ai@quaat.com
Add a welcome screen that display the score from the last game along with the high score in front of a background image. Add the text: Press "P" to play or "Q" to quit. If the player press P, the game starts. If the player press Q, the game exits. When a game is completed, the screen shifts back to the welcome screen.
To add a welcome screen with the requested features, follow these steps:
Load the background image for the welcome screen:
welcome_bg = pygame.image.load("welcome_bg.png")Define a function to display the welcome screen:
def welcome_screen(last_score, high_score):
font = pygame.font.Font(None, 36)
welcome_text = "Press 'P' to play or 'Q' to quit"
welcome_text_surface = font.render(welcome_text, True, WHITE)
welcome_text_rect = welcome_text_surface.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
score_text = f"Last Score: {last_score} High Score: {high_score}"
score_text_surface = font.render(score_text, True, WHITE)
score_text_rect = score_text_surface.get_rect(center=(SCREEN_WIDTH // 2, welcome_text_rect.y - 50))
while True:
screen.blit(welcome_bg, (0, 0))
screen.blit(welcome_text_surface, welcome_text_rect)
screen.blit(score_text_surface, score_text_rect)
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN:
if event.key == K_p:
return True
if event.key == K_q:
pygame.quit()
sys.exit()
pygame.display.flip()
clock.tick(FPS)Initialize the last_score and high_score variables:
last_score = 0
high_score = 0Call the welcome_screen() function before the main game loop starts:
if not welcome_screen(last_score, high_score):
pygame.quit()
sys.exit()Update the main game loop to reset the game state and return to the welcome screen after a game is completed:
# Replace these lines:
if pygame.sprite.spritecollide(player, bullets, False) or any(alien.rect.colliderect(player.rect) for alien in aliens):
pygame.quit()
sys.exit()
# With these lines:
if pygame.sprite.spritecollide(player, bullets, False) or any(alien.rect.colliderect(player.rect) for alien in aliens):
last_score = SCORE
high_score = max(high_score, last_score)
SCORE = 0
ALIEN_SPEED = 2
alien_shoot_prob = ALIEN_SHOOT_PROB
player.rect.midbottom = (SCREEN_WIDTH // 2, SCREEN_HEIGHT - 30)
bullets.empty()
aliens.empty()
for row in range(ALIEN_ROWS):
for col in range(ALIEN_COLUMNS):
x = col * (alien_imgs[row].get_width() + ALIEN_SPACING)
y = row * (alien_imgs[row].get_height() + ALIEN_SPACING)
alien = Alien(row, x, y, ALIEN_SPEED)
aliens.add(alien)
if not welcome_screen(last_score, high_score):
pygame.quit()
sys.exit()Now, when the game starts, the welcome screen will be displayed with the last score and high score, and the text Press "P" to play or "Q" to quit. If the player presses P, the game starts. If the player presses Q, the game exits. When a game is completed, the screen will shift back to the welcome screen.
ai@quaat.com
resize the 'welcome_bg.png' to the screen size
To resize the welcome_bg.png to match the screen size, you can use the pygame.transform.scale() function. Here's how to do it:
Scale the welcome_bg image after loading it:
welcome_bg = pygame.image.load("welcome_bg.png")
welcome_bg = pygame.transform.scale(welcome_bg, (SCREEN_WIDTH, SCREEN_HEIGHT))This will scale the welcome_bg image to match the SCREEN_WIDTH and SCREEN_HEIGHT dimensions. The image will now be displayed at the correct size when used as the background for the welcome screen.
ai@quaat.com
The sprites for the alien ships are all different sizes. Resize each image individually as a function of the screen width (i.e. the resized images should all have the same width)
To resize the alien ship images based on the screen width, you can use the pygame.transform.scale() function. First, decide the percentage of screen width you want each alien ship image to occupy. For example, let's say you want the alien ships to have a width equal to 5% of the screen width:
Calculate the desired width for the alien ship images:
alien_width = int(SCREEN_WIDTH * 0.05)
Define a function to resize the images, maintaining their aspect ratio:
```python
def resize_image(image, new_width):
aspect_ratio = image.get_height() / image.get_width()
new_height = int(new_width * aspect_ratio)
return pygame.transform.scale(image, (new_width, new_height))Resize the alien ship images using the resize_image() function:
alien1_img = resize_image(alien1_img, alien_width)
alien2_img = resize_image(alien2_img, alien_width)
alien3_img = resize_image(alien3_img, alien_width)
alien4_img = resize_image(alien4_img, alien_width)
alien_imgs = [alien1_img, alien2_img, alien2_img, alien3_img, alien4_img]Now, the alien ship images will be resized to have the same width, which is equal to 5% of the screen width, while maintaining their original aspect ratio. You can adjust the percentage value based on your preference.
ai@quaat.com
create a separate function "load_image(filename)" that calls "pygame.image.load", and the set the images directly: alien*_img = resize_image(load_image("..."), alient_width)
To create a separate function load_image(filename) and set the images directly, follow these steps:
Define the load_image() function:
def load_image(filename):
return pygame.image.load(filename)Set the images directly using the "resize_image()" and "load_image()" functions:
alien1_img = resize_image(load_image("alien1.png"), alien_width)
alien2_img = resize_image(load_image("alien2.png"), alien_width)
alien3_img = resize_image(load_image("alien3.png"), alien_width)
alien4_img = resize_image(load_image("alien4.png"), alien_width)
alien_imgs = [alien1_img, alien2_img, alien2_img, alien3_img, alien4_img]Now, the load_image() function is used to load the image files, making the code more concise and easier to read.
ai@quaat.com
in the game, use a background image resized to the screen size
To use a background image resized to the screen size in the game, follow these steps:
Load the background image for the game screen:
game_bg = pygame.image.load("game_bg.png")Resize the game_bg image to match the screen size:
game_bg = pygame.transform.scale(game_bg, (SCREEN_WIDTH, SCREEN_HEIGHT))Draw the game_bg image in the main game loop before drawing other elements:
while True:
# Replace this line:
# screen.fill(WHITE)
# With this line:
screen.blit(game_bg, (0, 0))
# Rest of the game loop code...Now, the game will display the resized background image instead of using a solid color as the background.
ai@quaat.com
Add sound effects. When the player is shooting, play the "shoot.wav" sound. If an alien ship is hit, play "invaderkilled.wav". When the player dies and it is game over, play "explosion.wav" and wait 3 seconds before returning back to the welcome page.
To add sound effects to your game, first, make sure you have initialized the mixer in your game:
pygame.mixer.init()
Then, follow these steps:Load the sound files:
shoot_sound = pygame.mixer.Sound("shoot.wav")
invaderkilled_sound = pygame.mixer.Sound("invaderkilled.wav")
explosion_sound = pygame.mixer.Sound("explosion.wav")Play the shoot.wav sound when the player shoots a bullet:
if event.type == KEYDOWN and event.key == K_SPACE:
bullet = Bullet(player.rect.centerx, player.rect.top, -1)
bullets.add(bullet)
shoot_sound.play()Play the invaderkilled.wav sound when an alien ship is hit:
aliens_hit = pygame.sprite.groupcollide(bullets, aliens, True, True)
if aliens_hit:
invaderkilled_sound.play()
SCORE += len(aliens_hit) * 10Play the explosion.wav sound when the player dies, wait for 3 seconds, and then return to the welcome screen:
if pygame.sprite.spritecollide(player, bullets, False) or any(alien.rect.colliderect(player.rect) for alien in aliens):
explosion_sound.play()
pygame.time.delay(3000) # Wait for 3 seconds (3000 milliseconds)
last_score = SCORE
high_score = max(high_score, last_score)
SCORE = 0
ALIEN_SPEED = 2
alien_shoot_prob = ALIEN_SHOOT_PROB
player.rect.midbottom = (SCREEN_WIDTH // 2, SCREEN_HEIGHT - 30)
bullets.empty()
aliens.empty()
for row in range(ALIEN_ROWS):
for col in range(ALIEN_COLUMNS):
x = col * (alien_imgs[row].get_width() + ALIEN_SPACING)
y = row * (alien_imgs[row].get_height() + ALIEN_SPACING)
alien = Alien(row, x, y, ALIEN_SPEED)
aliens.add(alien)
if not welcome_screen(last_score, high_score):
pygame.quit()
sys.exit()Now, the game will play sound effects for shooting, hitting alien ships, and when the player dies.