Scribd
Upload
54 views8 pages

Asteroids

This document defines classes and functions to create a basic asteroids game in Pygame. It defines classes for a Player object that can move and rotate on the screen, Asteroid objects that spawn and move randomly, and Bullet objects fired from the player. Functions control the movement and drawing of these objects, spawning of asteroids, and firing of bullets when the spacebar is pressed. The game runs in a main loop, updating positions and drawing each frame while listening for user input.

Uploaded by

api-614478378
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
54 views8 pages

Asteroids

This document defines classes and functions to create a basic asteroids game in Pygame. It defines classes for a Player object that can move and rotate on the screen, Asteroid objects that spawn and move randomly, and Bullet objects fired from the player. Functions control the movement and drawing of these objects, spawning of asteroids, and firing of bullets when the spacebar is pressed. The game runs in a main loop, updating positions and drawing each frame while listening for user input.

Uploaded by

api-614478378
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

"""

import pygame
from math import sin, cos, radians

#Define display/window
displaySize = (1280, 720)
win = pygame.display.set_mode(displaySize)
pygame.display.set_caption("ASTROIDS")

#Variables
fps = 60

players = []

class Player:
def __init__(self, image, size, rotation, moveSpeed, turnSpeed):
self.size = size
self.rotation = rotation

self.image =
pygame.transform.rotate(pygame.transform.scale(pygame.image.load(f"Assets//{im
age}"), self.size), rotation + 90)
self.rotatedImage = self.image

self.rect = pygame.Rect(displaySize[0]/2, displaySize[1]/2,


self.size[0], self.size[1])
self.rotatedRect = self.rect

self.moveSpeed = moveSpeed
self.turnSpeed = turnSpeed

self.momentumVector = [0.0, 0.0]


self.sumVector = [0.0, 0.0]

def Move(self, k):


self.sumVector = [self.momentumVector[0] +
cos(radians(self.rotation)), self.momentumVector[1] +
sin(radians(self.rotation))]

if k == "up":
self.rect.x += self.sumVector[0] * self.moveSpeed
self.rect.y -= self.sumVector[1] * self.moveSpeed
self.momentumVector = self.sumVector
else:
self.rect.x += self.momentumVector[0] * self.moveSpeed
self.rect.y -= self.momentumVector[1] * self.moveSpeed

self.rotatedImage = pygame.transform.rotate(self.image, self.rotation)


self.rotatedRect =
self.rotatedImage.get_rect(center=self.image.get_rect(topleft=(self.rect.x,
self.rect.y)).center)

def Rotate(self, k):


if k == "right":
self.rotation -= self.turnSpeed
if k == "left":
self.rotation += self.turnSpeed

self.rotatedImage = pygame.transform.rotate(self.image, self.rotation)


self.rotatedRect =
self.rotatedImage.get_rect(center=self.image.get_rect(topleft=(self.rect.x,
self.rect.y)).center)

def Draw(self):
win.blit(self.rotatedImage, self.rotatedRect)

players.append(Player(image="ship.png", size=(60, 60), rotation=0,


moveSpeed=0.1, turnSpeed=4))

def Movement():
keysPressed = pygame.key.get_pressed()
for player in players:
#player.sumVector = [player.momentumVector[0] +
cos(radians(player.rotation)), player.momentumVector[1] +
sin(radians(player.rotation))]

if keysPressed[pygame.K_UP]:
player.Move("up")
#player.rect.x += player.sumVector[0] * player.moveSpeed
#player.rect.y -= player.sumVector[1] * player.moveSpeed
#player.momentumVector = player.sumVector
else:
player.Move("/")
#player.rect.x += player.momentumVector[0] * player.moveSpeed
#player.rect.y -= player.momentumVector[1] * player.moveSpeed

if keysPressed[pygame.K_RIGHT]:
player.Rotate("right")
#player.rotation -= player.turnSpeed
if keysPressed[pygame.K_LEFT]:
player.Rotate("left")
#player.rotation += player.turnSpeed

#player.rotatedImage = pygame.transform.rotate(player.image,
player.rotation)
#player.rotatedRect =
player.rotatedImage.get_rect(center=player.image.get_rect(topleft=(pl ayer.rect
.x, player.rect.y)).center)

player.Draw()
print(player.sumVector)

def main():
clock = pygame.time.Clock()
run = True
while run:
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False

win.fill((0, 0, 0))
Movement()
pygame.display.update()

pygame.quit()

if __name__ == "__main__":
main()
"""

import pygame
from math import sin, cos, radians
from random import randint

#Define display/window
displaySize = (1200, 800)
win = pygame.display.set_mode(displaySize)
pygame.display.set_caption("ASTROIDS")

#Variables
fps = 60

players = []
shot = False

asteroids = []
removeAsteroids = []
startSpawnRate = 100
spawnRate = startSpawnRate

bullets = []
removeBullets = []
class Player:
def __init__(self, image, size, startPosition, rotation, moveSpeed,
turnSpeed):
self.size = size
self.rotation = rotation

self.image =
pygame.transform.rotate(pygame.transform.scale(pygame.image.load(f"Assets//{im
age}"), self.size), rotation + 90)
self.rotatedImage = self.image

self.rect = pygame.Rect(startPosition[0], startPosition[1],


self.size[0], self.size[1])
self.rotatedRect = self.rect

self.moveSpeed = moveSpeed
self.turnSpeed = turnSpeed

self.momentumVector = [0, 0]
self.sumVector = [0, 0]

def UpdateRotation(self):
self.rotatedImage = pygame.transform.rotate(self.image, self.rotation)
self.rotatedRect =
self.rotatedImage.get_rect(center=self.image.get_rect(topleft=(self.rect.x,
self.rect.y)).center)

def Translate(self, k):


self.sumVector = [round(self.momentumVector[0] +
cos(radians(self.rotation))), round(self.momentumVector[1] +
sin(radians(self.rotation)))]

if k == "up":
self.rect.x += self.sumVector[0] * self.moveSpeed
self.rect.y -= self.sumVector[1] * self.moveSpeed
self.momentumVector = self.sumVector
else:
self.rect.x += self.momentumVector[0] * self.moveSpeed
self.rect.y -= self.momentumVector[1] * self.moveSpeed

def Rotate(self, k):


if k == "right":
self.rotation -= self.turnSpeed
if k == "left":
self.rotation += self.turnSpeed

def ScreenWrap(self):
#X-axis
if self.rect.x > displaySize[0]:
self.rect.x -= displaySize[0] + self.size[0]
if self.rect.x < -self.size[0]:
self.rect.x += displaySize[0] + self.size[0]
#Y-axis
if self.rect.y > displaySize[1]:
self.rect.y -= displaySize[1] + self.size[1]
if self.rect.y < -self.size[1]:
self.rect.y += displaySize[1] + self.size[1]

def Draw(self):
win.blit(self.rotatedImage, self.rotatedRect)

class Asteroid:
def __init__(self, image, size, moveSpeed):
self.size = [randint(size[0]-20, size[0]+20), randint(size[1]-40,
size[1]+40)]
self.rotation = randint(0, 360)

self.startPosition = [randint(0, displaySize[0]), -self.size[1]]


self.moveSpeed = randint(moveSpeed-2, moveSpeed+2)

self.image =
pygame.transform.rotate(pygame.transform.scale(pygame.image.load(f"Assets//{im
age}"), self.size),self.rotation)
self.rect = pygame.Rect(self.startPosition[0], self.startPosition[1],
self.size[0], self.size[1])

def ScreenWrap(self):
if self.rect.x > displaySize[0]:
self.rect.x -= displaySize[0] + self.size[0]
if self.rect.x < -self.size[0]:
self.rect.x += displaySize[0] + self.size[0]

if self.rect.y > displaySize[1]:


self.rect.y -= displaySize[1] + self.size[1]
if self.rect.y < -self.size[1]:
self.rect.y += displaySize[1] + self.size[1]

def Move(self):
self.rect.x += cos(radians(self.rotation)) * self.moveSpeed
self.rect.y -= sin(radians(self.rotation)) * self.moveSpeed

def Draw(self):
win.blit(self.image, self.rect)

class Bullet:
def __init__(self, image, playerRect, rotation, moveSpeed, sumVector):
self.lifeTime = 100
self.size = (30, 30)
self.moveSpeed = moveSpeed
self.rotation = rotation
self.sumVector = sumVector

self.image =
pygame.transform.rotate(pygame.transform.scale(pygame.image.load(f"Assets//{im
age}"), self.size),self.rotation - 90)
self.rect = pygame.Rect(playerRect.x, playerRect.y, self.size[0],
self.size[1])

def Move(self):
self.rect.x += cos(radians(self.rotation)) * self.moveSpeed
self.rect.y -= sin(radians(self.rotation)) * self.moveSpeed

def ScreenWrap(self):
if self.rect.x > displaySize[0]:
self.rect.x -= displaySize[0] + self.size[0]
if self.rect.x < -self.size[0]:
self.rect.x += displaySize[0] + self.size[0]

if self.rect.y > displaySize[1]:


self.rect.y -= displaySize[1] + self.size[1]
if self.rect.y < -self.size[1]:
self.rect.y += displaySize[1] + self.size[1]

def Draw(self):
win.blit(self.image, self.rect)

def PlayerMovement(keysPressed):
for player in players:
player.UpdateRotation()
#Translation
if keysPressed[pygame.K_UP]:
player.Translate("up")
else:
player.Translate("/")

#Rotation
if keysPressed[pygame.K_RIGHT]:
player.Rotate("right")
if keysPressed[pygame.K_LEFT]:
player.Rotate("left")

#ScreenWrapping
player.ScreenWrap()
player.Draw()

def AsteroidSpawning(keysPressed):
global spawnRate
spawnRate -= 1

if spawnRate <= 0:
asteroids.append(Asteroid(image="asteroid.png", size=(120, 120),
moveSpeed=3))
spawnRate = startSpawnRate

for asteroid in asteroids:


for bullet in bullets:
if bullet.x < displaySize[0]/2:
removeAsteroids.append(asteroid)
removeBullets.append(bullet)

asteroid.Move()
asteroid.ScreenWrap()

asteroid.Draw()

def BulletSpawning(keysPressed):
global shot

if not keysPressed[pygame.K_SPACE]:
shot = False

if keysPressed[pygame.K_SPACE] and shot == False:


bullets.append(Bullet(image="bullet.png", playerRect=players[0].rect,
rotation=players[0].rotation, moveSpeed=15,
sumVector=players[0].momentumVector))
shot = True

for bullet in bullets:


bullet.lifeTime -= 1
if bullet.lifeTime <= 0:
removeBullets.append(bullet)

bullet.Move()
bullet.ScreenWrap()
bullet.Draw()

players.append(Player(image="ship.png", size=(60, 60),


startPosition=(displaySize[0]/2, displaySize[1]/2), rotation=0, moveSpeed=0.1,
turnSpeed=4))
def main():
clock = pygame.time.Clock()
run = True
while run:
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False

keysPressed = pygame.key.get_pressed()

win.fill((0, 0, 0))
PlayerMovement(keysPressed)
AsteroidSpawning(keysPressed)
BulletSpawning(keysPressed)
pygame.display.update()

for asteroid in removeAsteroids:


asteroids.remove(asteroid)
removeAsteroids.remove(asteroid)

for bullet in removeBullets:


bullets.remove(bullet)
removeBullets.remove(bullet)

pygame.quit()

if __name__ == "__main__":
main()

You might also like