Star Dodger Game Code

#This game was (mainly) not developed by me. I take no credit for the major part of the code.
# Star Dodger

import os, sys
import pygame
from pygame.locals import *
import random
import time

#All the things to make Pygame window
pygame.init()
screen = pygame.display.set_mode((320, 640))
pygame.display.set_caption('Mouse Dodge')
pygame.mouse.set_visible(0)

#Load images and define mouse_pos
background = pygame.image.load('rec/screen/bg.png')
game_over = pygame.image.load('rec/screen/game_over.png')
mouse_pos = pygame.mouse.get_pos()

class Game():
    def __init__(self):
        # get player
        self.player = pygame.image.load('rec/game/mouse.png')
        self.player_r = self.player.get_bounding_rect()
        #load images and rects for the comets
        self.load_img()
        #Pygame clock
        self.clock = pygame.time.Clock()
        self.last_tick = 0
        #upgrades
        self.laser = False
        self.force_field = False

        #Variables

        self.ship = 0
        self.start_time = 0
        self.time_passed = 0
        self.state = 1
        self.money = 200
        self.str_spd1 = 14
        self.str_spd2 = 12
        self.str_spd3 = 16
        self.force_count = 0




        while 1:
            #Loop self.Loop()
            self.Loop()

    def load_img(self):
        #load images for stars and laser
        self.explosion = pygame.image.load('rec/game/explosion.png')
        self.star = pygame.image.load('rec/game/star.png')
        self.star_r = self.star.get_bounding_rect()
        self.ran_x = random.randint(20,300)
        self.star2 = pygame.image.load('rec/game/star2.png')
        self.star2_r = self.star2.get_bounding_rect()
        self.ran_x2 = random.randint(20,300)
        self.star3 = pygame.image.load('rec/game/star3.png')
        self.star3_r = self.star3.get_bounding_rect()
        self.ran_x3 = random.randint(20,300)
        self.force_img =  pygame.image.load('rec/game/force_img.png')

    def laser_shoot(self):
        self.laser_img = pygame.image.load('rec/game/laser.png')
        self.laser_img_r = self.laser_img.get_bounding_rect()

        self.mouse_pos = pygame.mouse.get_pos()
        self.mouse_x, self.mouse_y = self.mouse_pos
        self.laser_img_r.y-=50
        (self.laser_x, self.laser_y) = (self.mouse_x,self.mouse_y)
        screen.blit(self.laser_img,(self.laser_x, self.laser_y))

    def mouse_update(self):
        self.mouse_pos = pygame.mouse.get_pos()
        self.mouse_x, self.mouse_y = self.mouse_pos
        (self.player_r.x, self.player_r.y) = self.mouse_pos

    def update(self):
        #Set random x coord
        self.star_r.x = self.ran_x
        self.star2_r.x = self.ran_x2
        self.star3_r.x = self.ran_x3
        # set Comet speeds
        self.star_r.y += self.str_spd1
        self.star2_r.y += self.str_spd2
        self.star3_r.y += self.str_spd3
        #blit stars at random
        if self.star_r.y > 640:
            self.star_r.y = 0
            self.ran_x = random.randint(5,110)

        if self.star2_r.y > 640:
            self.star2_r.y = 0
            self.ran_x2 = random.randint(100,200)

        if self.star3_r.y > 640:
            self.star3_r.y = 0
            self.ran_x3 = random.randint(190,315)


    def blitPlayer(self, screen):
        #Blit the layer and the stars
        (mouse_x, mouse_y) = self.mouse_pos
        if self.force_field == True:
            screen.blit(self.force_img,(mouse_x-14, mouse_y-13))

        screen.blit(self.player,(self.mouse_pos))
        screen.blit(self.star,(self.ran_x, self.star_r.y))
        screen.blit(self.star2,(self.ran_x2, self.star2_r.y))
        screen.blit(self.star3,(self.ran_x3, self.star3_r.y))
        #Check if stars collide with player
        star_col = self.player_r.colliderect(self.star_r)or self.player_r.colliderect(self.star2_r)or self.player_r.colliderect(self.star3_r)

        if self.force_field == True and star_col == True:
            screen.blit(self.explosion,(self.mouse_pos))
            self.force_count+=1

        if self.force_count >= 9:
            self.force_field = False
            self.force_count = 0

        if self.laser == True and pygame.mouse.get_pressed()[0]:
            self.laser_shoot()

        if star_col == True and self.force_field == False:
            self.force_count = 0
            self.state = 0
            if self.money > 0:
                self.money = self.money - 25




    def Draw(self):
        #Draw BG and Blit the player and stars
        screen.blit(background,(0,0))
        self.blitPlayer(screen)

    def main_menu(self):
        #Main screen
        self.main = pygame.image.load('rec/screen/main.png')
        screen.blit(self.main,(0,0))
        self.play = pygame.image.load('rec/screen/play.png')
        self.play_r = self.play.get_bounding_rect()
        self.play_r.x,self.play_r.y = (100,400)
        screen.blit(self.play,(100, 400))
        screen.blit(self.player,(self.mouse_pos))
        if self.player_r.colliderect(self.play_r)and pygame.mouse.get_pressed()[0]:
            self.state = 2
            self.star_r.y = 0
            self.star2_r.y = 0
            self.star3_r.y = 0
            self.start_time = time.clock()

    def store(self):
        #if the self state is 3 it opens store
        screen.blit(self.player,(self.mouse_pos))
        #Blit items and such
        self.store_img = pygame.image.load('rec/screen/store.png')
        screen.blit(self.store_img,(0,0))

        #Forcefield item
        self.force_item = pygame.image.load('rec/screen/force_field_item.png')
        self.force_item_r = self.force_item.get_bounding_rect()
        self.force_item_r.x,self.force_item_r.y = (0,200)
        screen.blit(self.force_item,(0,200))

        # Laser Item
        self.laser_item = pygame.image.load('rec/screen/laser_item.png')
        self.lsr_itm_r = self.laser_item.get_bounding_rect()
        self.lsr_itm_r.x,self.lsr_itm_r.y = (0,300)
        screen.blit(self.laser_item,(0,300))

        # play again button
        self.store_again = pygame.image.load('rec/screen/play_again.png')
        self.store_again_r = self.store_again.get_bounding_rect()
        self.store_again_r.x,self.store_again_r.y = (50,600)
        screen.blit(self.store_again,(50, 600))
        screen.blit(self.player,(self.mouse_pos))

        #self.laser_item = pygame.image.load('rec/screen/laser_item.png')
        #self.lsr_itm_r = self.laser_item.get_bounding_rect()
        #screen.blit(self.laser_item,(0,200))
        #screen.blit(self.player,(self.mouse_pos))

        self.store_again = pygame.image.load('rec/screen/play_again.png')
        self.store_again_r = self.store_again.get_bounding_rect()
        self.store_again_r.x,self.store_again_r.y = (50,600)
        screen.blit(self.store_again,(50, 600))

        #Write the amount of money
        myfont = pygame.font.SysFont("impact", 20)
        money_amnt = "You Have: %s Dollars" %(str(self.money))
        label = myfont.render((money_amnt), 1, (255,255,0))
        screen.blit(label, (75, 100))


        # if statements for clicks
        screen.blit(self.player,(self.mouse_pos))
        if self.player_r.colliderect(self.lsr_itm_r)and pygame.mouse.get_pressed()[0]and self.money >= 150:
            self.laser = True
            self.money = self.money - 150
        if self.player_r.colliderect(self.force_item_r)and pygame.mouse.get_pressed()[0]and self.money >= 50 and self.force_field == False:
            self.force_field = True
            self.money = self.money - 50
            print("force activated")
        if self.player_r.colliderect(self.store_again_r)and pygame.mouse.get_pressed()[0]:
            self.state = 1


        # if statements for clicks
        screen.blit(self.player,(self.mouse_pos))
        if self.player_r.colliderect(self.lsr_itm_r)and pygame.mouse.get_pressed()[0]and self.money == 150:
            self.laser = True
        if self.player_r.colliderect(self.store_again_r)and pygame.mouse.get_pressed()[0]:
            self.state = 0
            self.money = self.money - 25


    def time_pass(self):
        #timer for main game play
        self.time_passed = time.clock()
        if self.time_passed > (self.start_time + 10):
            self.state = 3
            self.money = self.money + 50

    def stage_pass(self):
        #get images and blit bbs and imgs for stage_pass
        self.round_pass = pygame.image.load('rec/screen/level_pass.png')
        screen.blit(self.round_pass,(0,0))
        self.store_buttn = pygame.image.load('rec/screen/store_label.png')
        self.store_buttn_r = self.store_buttn.get_bounding_rect()
        self.store_buttn_r.x,self.store_buttn_r.y = (40,400)
        screen.blit(self.store_buttn,(40, 400))
        self.play_again = pygame.image.load('rec/screen/play_again.png')
        self.play_again_r = self.play_again.get_bounding_rect()
        self.play_again_r.x,self.play_again_r.y = (50,500)
        screen.blit(self.play_again,(50, 500))
        screen.blit(self.player,(self.mouse_pos))

        if self.player_r.colliderect(self.store_buttn_r)and pygame.mouse.get_pressed()[0]:
            self.state = 4
        if self.player_r.colliderect(self.play_again_r)and pygame.mouse.get_pressed()[0]:
            self.state = 1

    def game_over(self):
        # Game over Screen
        key = pygame.key.get_pressed()
        screen.blit(game_over,(0,0))
        if key[pygame.K_RETURN]:
            self.state = 1

    def Tick(self):
        # updates to player location and animation frame
        self.last_tick = pygame.time.get_ticks()
        self.clock.tick()

    def eventLoop(self):
        # the main event loop, detects keypresses
        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit()

    def Loop(self):
        # main game loop
        self.eventLoop()
        self.mouse_update()

        if self.state == 0:
            self.game_over()
        if self.state == 1:
            self.main_menu()
        if self.state == 2:
            self.time_pass()

            if pygame.time.get_ticks() - self.last_tick > 20:
                self.update()
                self.Tick()
                self.Draw()
        if self.state ==3:
            self.stage_pass()
        if self.state == 4:
            self.store()
        pygame.display.update()




Game()