0

I am currently taking an A level computer science course in which I have to create a game for a project. I know this code is probably not efficient but I am trying to keep it to my own work and would like a hand with two bits that I am a bit stuck on

This code currently starts with a intro screen and once in the game, scrolls left,right and removes lives when the player falls off of the screen. When all lives are lost there is a game over screen that is shown

I was wondering if there was a way to set a limit to the scrolling screen so that when the player goes left it stops scrolling at a certain point and stops the player at the edge of the screen to stop them falling off. I want to set the far left of the bottom platform to be the edge, this forces the player to go right

Another small one is if there is any way to reduce lag

If there is anymore information you need to help feel free to ask Any suggestions would be appreciated Thanks for any help

import pygame as pg
import time
import random


pg.init()#initiates pygame

display_height = 690#Creates width and height of screen
display_width = 1024

#Colours
white = (255,255,255) 
black = (0,0,0)
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
grass = (24,85,36)
yellow = (255,255,0)
lightGrey = (184,184,184)
grey = (73,71,65)

Robot_height = 99#Height of robot
Robot_width = 112#Width of robot
Bullet_Fired = False
PowerUp_Active = False
Robot_acc = 0.3 #Robot Acceleration
vec = pg.math.Vector2

gameDisplay = pg.display.set_mode((display_width,display_height)) #Sets display properties of window
pg.display.set_caption ("Game") #Title on window
clock = pg.time.Clock()
robotImg = pg.image.load("robot1.png") #Loads robots image
lifeImg = pg.image.load("Life.png")#Loads image from folder
lifeImg = pg.transform.scale(lifeImg, (80, 80))#Sets dimensions of image
backgroundImg = pg.image.load("Background.png")#Loads background image
backgroundImg = pg.transform.scale(backgroundImg, (display_width, display_height))#Sets dimensions of background to fit the screen
inBackgroundImg = pg.image.load("IntroBackground1.png")#Loads intro background
controlsImg = pg.image.load("controls.png")#Loads controls screen background
controlsImg = pg.transform.scale(controlsImg, (display_width, display_height))#Sets dimensions to fit screen
largeText = pg.font.Font("Font.ttf",77)#Large text set
smallText = pg.font.Font("Font.ttf",32)#Small text set

#Class for platforms
class Platform(pg.sprite.Sprite):
    def __init__(self, x,y,w,h):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((w,h))#sets width and height of platform
        self.image.fill(grass)#Fills rectangle with blue
        self.rect = self.image.get_rect()#Rectangle set
        self.rect.x = x#x position
        self.rect.y = y#y position

#List of platforms
PLATFORM_LIST = [[0,display_height - 40,display_width,40],
                 [display_width + 300,display_height - 40,display_width,40],
                 [display_width /2 - 50,display_height * 3/4,100,20],
                 [display_width -10,display_height * 3/4,100,20]]
#Platform group
platforms = pg.sprite.Group()

#Checks through "PLATFORM_LIST" and adds all the platforms the the grounp "platforms"
for plat in PLATFORM_LIST:
    p = Platform(*plat)
    platforms.add(p)

#Draws platforms to the screen
def draw():
    for plat in platforms:
        pg.draw.rect(gameDisplay, grass, plat)

#Class for robot
class RobotClass(pg.sprite.Sprite):
    def __init__(self):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((Robot_width,Robot_height))#Height and width of the robot
        self.rect = self.image.get_rect()#Gets rectangle of robot
        self.rect.center = (display_width / 2, display_height / 2)#Location of center of robot
        self.RobotPos = vec(display_width / 2, display_height / 2)#Position of robot as vector
        self.bottom = (0,0)#Bottom of robot
        self.vel = vec(0, 0)#Robots velocity
        self.acc = vec(0, 0.3)#Robots Acceleration

startX = display_width/2
startY = display_height/2

#Creates Robot
Robot = RobotClass()

#Jump function
def jump():
    #Checks pixel below robot to see if there is a collision
    Robot.rect.x = Robot.rect.x +1
    hits = pg.sprite.spritecollide(Robot , platforms, False)
    Robot.rect.x = Robot.rect.x -1
    if hits:
        #Gives robot velocity of 5 upwards
        Robot.vel.y = -10

#Settings for text
def text_objects(text, font):
    textSurface = font.render(text, True, white)
    return textSurface, textSurface.get_rect()

#Displays lives of Robot
def display_lives(lives):
    global lifeImg
    TextSurf, TextRect = text_objects("Lives:", smallText)#Sets text and font
    TextRect.topleft = (1,16)#Places text in top left of screen
    gameDisplay.blit(TextSurf, TextRect) #displays text
    if lives == 3:#Displays 3 spanners
        gameDisplay.blit(lifeImg,(110,0))
        gameDisplay.blit(lifeImg,(160,0))
        gameDisplay.blit(lifeImg,(210,0))
    if lives == 2:#Displays 2 spanners
        gameDisplay.blit(lifeImg,(110,0))
        gameDisplay.blit(lifeImg,(160,0))
    if lives == 1:#Displays 1 spanners
        gameDisplay.blit(lifeImg,(110,0))
    if lives == 0:#Should end game when all lives are lost
        game_over()

#Function for button that takes parameters (message,x,y,height,width,active colour,inactive colour,text size,action)      
def button(msg,x,y,w,h,i,a,t,action=None):
    mouse = pg.mouse.get_pos() #Gets (x,y) position of mouse
    Text = pg.font.Font("Font.ttf",t) #Lets text size be input
    click = pg.mouse.get_pressed() #Gets whenther mouse has been clicked (mouse1,middle mouse,mouse2)

    if x+w > mouse[0] > x and y+50 > mouse[1] > y:#Checks to see if mouse is within boundaries of button
        pg.draw.rect(gameDisplay, a,(x,y,w,h),5)#Changes color of box when being hovered over
        if click[0] == 1 and action != None:#If mouse1 is clicked and there is an action to be performed it will be run
            action()#action is parameter and the () is used to initiate function
    else:
        pg.draw.rect(gameDisplay, i,(x,y,w,h),5)#Sets default button

    TextSurf, TextRect = text_objects(msg, Text)#Runs text_objects with inputted parameter of the message
    TextRect.center = ((x+(w/2)),(y+(h/2)))#Places text inside the button
    gameDisplay.blit(TextSurf, TextRect)#Displays text


def Exit():#Used for button on intro screen to exit
    pg.quit()
    quit()

#What happens when player runs out of lives
def game_over():
    while True:
        for event in pg.event.get():#lets window be closed
            if event.type == pg.QUIT:
                pg.quit()
                quit()
        gameDisplay.blit(inBackgroundImg, (0, 0))
        TextSurf, TextRect = text_objects(("Game"), largeText)#Places large text on screen
        TextRect.center = ((display_width/2+10),(180))#location of text
        gameDisplay.blit(TextSurf, TextRect)
        TextSurf, TextRect = text_objects(("Over"), largeText)
        TextRect.center = ((display_width/2+10),(280))
        gameDisplay.blit(TextSurf, TextRect)
        pg.draw.rect(gameDisplay, yellow,(290,125,445,220),5)#Puts yellow box over game over

        button("Retry",410,600,207,70,yellow,lightGrey,45,game_loop)
        button("Quit",display_width-105,display_height-55,100,50,yellow,lightGrey,33,Exit)

        pg.display.update()#updates screen
        clock.tick(15)

#Function for control screen
def controls():
    while True:
        for event in pg.event.get():#lets window be closed
            if event.type == pg.QUIT:
                pg.quit()
                quit()
        gameDisplay.blit(controlsImg, (0, 0))#Places controlsImg on screen
        button("Back",5,display_height-55,100,50,black,grey,30,game_intro)#places back button in bottom left corner

        pg.display.update()#updates screen
        clock.tick(15)#sets clock rate


#Function to gun the intro screen
def game_intro():
    while True:
        for event in pg.event.get():#lets window be closed
            if event.type == pg.QUIT:
                pg.quit()
                quit()
        gameDisplay.blit(inBackgroundImg, (0, 0))#Places background image
        TextSurf, TextRect = text_objects(("Lost on planet X"), largeText)#Places large text on screen
        TextRect.center = ((display_width/2),(200))#location of text
        gameDisplay.blit(TextSurf, TextRect)#displays text
        pg.draw.rect(gameDisplay, yellow,(65,130,900,150),5)#Puts yellow box over title

        button("Play",412,550,200,50,yellow,lightGrey,36,game_loop) #Play button at middle bottom
        button("Controls",412,450,200,50,yellow,lightGrey,32,controls) #Controls button in middle of screen
        button("Quit",display_width-105,display_height-55,100,50,yellow,lightGrey,33,Exit) #Quit button in bottom right


        pg.display.update()#updates screen
        clock.tick(15)#sets clock rate

#game loop
def game_loop():
    global PLATFORM_LIST
    global startX
    global startY
    global backgroundImg
    Robot.RobotPos = (startX,startY)
    lives = 3 #Robot Lives
    Robot_friction = -0.3 #Friction value
    vec = pg.math.Vector2 #Setting vec as vector quantity
    while True:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                pg.quit
                quit()
            #Starts acceleration when key is pressed
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_LEFT:
                    Robot.acc.x = -Robot_acc
                elif event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot_acc
                elif event.key == pg.K_UP:
                    jump()
            #Adds friction to accleration to slow robot down when key is not being pressed
            if event.type == pg.KEYUP:
                if event.key == pg.K_LEFT or event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot.acc.x * Robot_friction

        #Adjusts velocity of robot by adding the acceleration on each cycle
        Robot.vel = Robot.vel+ Robot.acc
        #gameDisplay.fill(sky)
        gameDisplay.blit(backgroundImg,(0,0))
        #Draws the platforms to the screen and adds them to platform group
        draw()
        #Changes Robot position according to its velocity,acceleration and the friction
        Robot.RobotPos = Robot.RobotPos + Robot.vel + 0.5 * Robot.acc
        #Loads robot onto screen
        gameDisplay.blit(robotImg,(Robot.rect))
        #pg.draw.rect(gameDisplay, red, Robot.rect, 2
        display_lives(lives)#lives
        pg.display.update()#Updates display
        clock.tick(60)

        #Sets bottom of robot to its position
        Robot.rect.midbottom =  Robot.RobotPos

        #Collision detection
        if Robot.vel.y > 0:
            hits = pg.sprite.spritecollide(Robot , platforms, False)
            if hits:
                #Puts Robot on top of platform
                Robot.RobotPos.y = hits[0].rect.top + 1
                Robot.vel.y = 0        
        #Scrolling
        if Robot.rect.left < display_width/4:
            Robot.RobotPos.x = Robot.RobotPos.x + abs(Robot.vel.x)
            startX = startX + abs(Robot.vel.x)
            for plat in platforms:
                plat.rect.x = plat.rect.x + int(abs(Robot.vel.x))
                draw()
        if Robot.rect.right > (display_width-display_width/4):
            Robot.RobotPos.x = Robot.RobotPos.x - abs(Robot.vel.x)
            startX = startX - abs(Robot.vel.x)
            for plat in platforms:
                plat.rect.x = plat.rect.x - int(abs(Robot.vel.x))
                draw()

        #Losing a life
        if Robot.rect.top > display_height:
            lives = lives - 1
            Robot.RobotPos.y = Robot.RobotPos.y - (40+Robot_height)
            Robot.RobotPos.x = Robot.RobotPos.x - 200
            Robot.vel.x = 0


        #Sets top velocity of robot    
        if Robot.vel.x > 6:
            Robot.vel.x = 6
        if Robot.vel.x < -6:
            Robot.vel.x = -6
        #Makes robot velocity = 0 when it is close to 0
        if Robot.vel.x < 0.05 and Robot.vel.x > -0.05:
            Robot.acc.x = 0
            Robot.vel.x = 0

game_intro()
pg.quit()
quit()
Ashley Kelly
  • 35
  • 5
  • When asking a question, make sure to only ask one question. This narrows the answers down, makes the question easier to comprehend and increases searchability for other users. Also include [mcve] in your question (if necessary) and not your code, since it's too much code to read for a SO question. And as I wrote in your previous question; try follow naming conventions, otherwise it'll much harder to read and understand your code since it's unclear what's a variable, class, function or constant on the name alone, meaning that we have to look up the where it's defined every time we encounter it. – Ted Klein Bergman Apr 25 '17 at 08:53
  • In [this](http://stackoverflow.com/a/14357169/6486738) SO answer you'll find what you're looking for (for your first sub-question). – Ted Klein Bergman Apr 25 '17 at 08:55
  • To reduce lag, make sure you're only drawing to the screen once every loop. In your game loop you're drawing (using your `draw()` function) and then you're drawing again after checking for scrolling (`if Robot.rect.left < display_width/4:`). Check for scrolling first and then draw instead, meaning you're only drawing once every loop no matter what. – Ted Klein Bergman Apr 25 '17 at 09:00

1 Answers1

0

I managed to complete this problem myself so I will briefly explain what I did.

I added a variable called off set which tracked how far away the scrolled screen was from the original position.

offset = 0

I then added this variable into my scrolling code

if Robot.rect.left < display_width/4:
            Robot.RobotPos.x = Robot.RobotPos.x + abs(Robot.vel.x)
            startX = startX + int(abs(Robot.vel.x))
            offset = offset + int(abs(Robot.vel.x))
            for plat in platforms:
                plat.rect.x = plat.rect.x + int(abs(Robot.vel.x))
            for coin in coins:
                coin.rect.x = coin.rect.x + int(abs(Robot.vel.x))

if Robot.rect.right > (display_width-display_width/4):
            Robot.RobotPos.x = Robot.RobotPos.x - abs(Robot.vel.x)
            startX = startX - int(abs(Robot.vel.x))
            offset = offset - int(abs(Robot.vel.x))
            for plat in platforms:
                plat.rect.x = plat.rect.x - int(abs(Robot.vel.x))
            for coin in coins:
                coin.rect.x = coin.rect.x - int(abs(Robot.vel.x))

I then added an extra if to this function. This only runs the scroll part off the code when the offset is smaller then zero. Any values that are bigger than zero indicate that the screen has been offset to the left. This code therefore only lets you scroll when you are not at the edge of the screen

if offset > 0:
            pass
elif Robot.rect.left < display_width/4:
            Robot.RobotPos.x = Robot.RobotPos.x + abs(Robot.vel.x)
            startX = startX + int(abs(Robot.vel.x))
            offset = offset + int(abs(Robot.vel.x))
            for plat in platforms:
                plat.rect.x = plat.rect.x + int(abs(Robot.vel.x))
            for coin in coins:
                coin.rect.x = coin.rect.x + int(abs(Robot.vel.x))

To then stop the sprite from falling off of the screen I added a wall at the edge using my platform function and added it to a group just in case I need to use more walls later.

w1 = Platform(0,0,10,display_height)
wall = pg.sprite.Group()
wall.add(w1)

After this I created a condition using spritecollide to check whether the sprite is touching the wall

hit = pg.sprite.spritecollide(Robot , wall,False)
        if hit:
            Robot.vel.x = 0
            Robot.acc.x = 0

Although this worked there became a problem where it was hard for the sprite to move away from the wall since its velocity was constantly being set to 0 so I added another variable that checks if the left arrow is being pressed 

hit = pg.sprite.spritecollide(Robot , wall,False)
        if hit:
            if left == True:
                Robot.vel.x = 0
                Robot.acc.x = 0

This then only resets the values if you are trying to move left

if event.type == pg.KEYDOWN:
                if event.key == pg.K_LEFT:
                    Robot.acc.x = -Robot_acc
                    left = True
                elif event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot_acc                  
                elif event.key == pg.K_UP:
                    jump()
            elif Robot.acc.x < 0:
                left = True
            else:
                left = False

Here is all my code together in case I missed anything out or there are different parts you want to look at.

*edit This code does not currently scroll or display the wall. The scrolling doesn't matter since the robot should be in the middle of the screen when it is scrolling so the wall will still be there but there will be no way to collide with it and it is invisible so you cant see it

Feel free to ask questions if I didn't explain a part very well or you just want some more info.

import pygame as pg
import time
import random


pg.init()#initiates pygame

display_height = 690#Creates width and height of screen
display_width = 1024

#Colours
white = (255,255,255) 
black = (0,0,0)
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
grass = (24,85,36)
yellow = (255,255,0)
lightGrey = (184,184,184)
grey = (73,71,65)
brown = (66, 40, 13) 

Robot_height = 99#Height of robot
Robot_width = 112#Width of robot
Bullet_Fired = False
PowerUp_Active = False
Robot_acc = 0.3 #Robot Acceleration
vec = pg.math.Vector2

gameDisplay = pg.display.set_mode((display_width,display_height)) #Sets display properties of window
pg.display.set_caption ("Game") #Title on window
clock = pg.time.Clock()
robotImg = pg.image.load("robot1.png") #Loads robots image
lifeImg = pg.image.load("Life.png")#Loads image from folder
lifeImg = pg.transform.scale(lifeImg, (80, 80))#Sets dimensions of image
backgroundImg = pg.image.load("Background.png")#Loads background image
backgroundImg = pg.transform.scale(backgroundImg, (display_width, display_height))#Sets dimensions of background to fit the screen
inBackgroundImg = pg.image.load("IntroBackground1.png")#Loads intro background
controlsImg = pg.image.load("controls.png")#Loads controls screen background
controlsImg = pg.transform.scale(controlsImg, (display_width, display_height))#Sets dimensions to fit screen
largeText = pg.font.Font("Font.ttf",77)#Large text set
smallText = pg.font.Font("Font.ttf",32)#Small text set

#Class for platforms
class Platform(pg.sprite.Sprite):
    def __init__(self, x,y,w,h):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((w,h))#sets width and height of platform
        self.image.fill(grass)#Fills rectangle with blue
        self.rect = self.image.get_rect()#Rectangle set
        self.rect.x = x#x position
        self.rect.y = y#y position

#List of platforms x , y , width , height
PLATFORM_LIST = [[-5,display_height - 40,2005,40],
                 [2300,display_height - 40,1000,40],
                 [1100,display_height - 190,300,20],
                 ]
#Platform group
platforms = pg.sprite.Group()

w1 = Platform(0,0,10,display_height)
wall = pg.sprite.Group()
wall.add(w1)

#Checks through "PLATFORM_LIST" and adds all the platforms the the grounp "platforms"
for plat in PLATFORM_LIST:
    p = Platform(*plat)
    platforms.add(p)

#Draws platforms to the screen
def draw():
    for plat in platforms:
        pg.draw.rect(gameDisplay, grass, plat)

#Class for robot
class RobotClass(pg.sprite.Sprite):
    def __init__(self):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((Robot_width,Robot_height))#Height and width of the robot
        self.rect = self.image.get_rect()#Gets rectangle of robot
        self.rect.center = (display_width / 2, display_height / 2)#Location of center of robot
        self.RobotPos = vec(display_width / 2, display_height / 2)#Position of robot as vector
        self.bottom = (0,0)#Bottom of robot
        self.vel = vec(0, 0)#Robots velocity
        self.acc = vec(0, 0.3)#Robots Acceleration

startX = display_width/2
startY = display_height/2

#Creates Robot
Robot = RobotClass()

#Jump function
def jump():
    #Checks pixel below robot to see if there is a collision
    Robot.rect.x = Robot.rect.x +1
    hits = pg.sprite.spritecollide(Robot , platforms, False)
    Robot.rect.x = Robot.rect.x -1
    if hits:
        #Gives robot velocity of 5 upwards
        Robot.vel.y = -10

#Settings for text
def text_objects(text, font):
    textSurface = font.render(text, True, white)
    return textSurface, textSurface.get_rect()

#Displays lives of Robot
def display_lives(lives):
    global lifeImg
    TextSurf, TextRect = text_objects("Lives:", smallText)#Sets text and font
    TextRect.topleft = (1,16)#Places text in top left of screen
    gameDisplay.blit(TextSurf, TextRect) #displays text
    if lives == 3:#Displays 3 spanners
        gameDisplay.blit(lifeImg,(110,0))
        gameDisplay.blit(lifeImg,(160,0))
        gameDisplay.blit(lifeImg,(210,0))
    if lives == 2:#Displays 2 spanners
        gameDisplay.blit(lifeImg,(110,0))
        gameDisplay.blit(lifeImg,(160,0))
    if lives == 1:#Displays 1 spanners
        gameDisplay.blit(lifeImg,(110,0))
    if lives == 0:#Should end game when all lives are lost
        game_over()

#Displays score in top right of screen and takes in parameter score
def display_score(score):
    #Displays the score itself
    TextSurf, TextRect = text_objects(str(score), smallText)#Sets text and font
    TextRect.topleft = (display_width-120,16)#Places text in top left of screen
    gameDisplay.blit(TextSurf, TextRect)

    #Displays the text "score" infront of the score
    TextSurf, TextRect = text_objects("Score:", smallText)#Sets text and font
    TextRect.topleft = (display_width-255,16)#Places text in top left of screen
    gameDisplay.blit(TextSurf, TextRect)

#Function for button that takes parameters (message,x,y,height,width,active colour,inactive colour,text size,action)      
def button(msg,x,y,w,h,i,a,t,action=None):
    mouse = pg.mouse.get_pos() #Gets (x,y) position of mouse
    Text = pg.font.Font("Font.ttf",t) #Lets text size be input
    click = pg.mouse.get_pressed() #Gets whenther mouse has been clicked (mouse1,middle mouse,mouse2)

    if x+w > mouse[0] > x and y+50 > mouse[1] > y:#Checks to see if mouse is within boundaries of button
        pg.draw.rect(gameDisplay, a,(x,y,w,h),5)#Changes color of box when being hovered over
        if click[0] == 1 and action != None:#If mouse1 is clicked and there is an action to be performed it will be run
            action()#action is parameter and the () is used to initiate function
    else:
        pg.draw.rect(gameDisplay, i,(x,y,w,h),5)#Sets default button

    TextSurf, TextRect = text_objects(msg, Text)#Runs text_objects with inputted parameter of the message
    TextRect.center = ((x+(w/2)),(y+(h/2)))#Places text inside the button
    gameDisplay.blit(TextSurf, TextRect)#Displays text


def Exit():#Used for button on intro screen to exit
    pg.quit()
    quit()

#What happens when player runs out of lives
def game_over():
    while True:
        for event in pg.event.get():#lets window be closed
            if event.type == pg.QUIT:
                pg.quit()
                quit()
        gameDisplay.blit(inBackgroundImg, (0, 0))
        TextSurf, TextRect = text_objects(("Game"), largeText)#Places large text on screen
        TextRect.center = ((display_width/2+10),(180))#location of text
        gameDisplay.blit(TextSurf, TextRect)
        TextSurf, TextRect = text_objects(("Over"), largeText)
        TextRect.center = ((display_width/2+10),(280))
        gameDisplay.blit(TextSurf, TextRect)
        pg.draw.rect(gameDisplay, yellow,(290,125,445,220),5)#Puts yellow box over game over

        button("Retry",410,600,207,70,yellow,lightGrey,45,game_loop)
        button("Quit",display_width-105,display_height-55,100,50,yellow,lightGrey,33,Exit)

        pg.display.update()#updates screen
        clock.tick(15)

#Function for control screen
def controls():
    while True:
        for event in pg.event.get():#lets window be closed
            if event.type == pg.QUIT:
                pg.quit()
                quit()
        gameDisplay.blit(controlsImg, (0, 0))#Places controlsImg on screen
        button("Back",5,display_height-55,100,50,black,grey,30,game_intro)#places back button in bottom left corner

        pg.display.update()#updates screen
        clock.tick(15)#sets clock rate


#Function to gun the intro screen
def game_intro():
    while True:
        for event in pg.event.get():#lets window be closed
            if event.type == pg.QUIT:
                pg.quit()
                quit()
        gameDisplay.blit(inBackgroundImg, (0, 0))#Places background image
        TextSurf, TextRect = text_objects(("Lost on planet X"), largeText)#Places large text on screen
        TextRect.center = ((display_width/2),(200))#location of text
        gameDisplay.blit(TextSurf, TextRect)#displays text
        pg.draw.rect(gameDisplay, yellow,(65,130,900,150),5)#Puts yellow box over title

        button("Play",412,550,200,50,yellow,lightGrey,36,game_loop) #Play button at middle bottom
        button("Controls",412,450,200,50,yellow,lightGrey,32,controls) #Controls button in middle of screen
        button("Quit",display_width-105,display_height-55,100,50,yellow,lightGrey,33,Exit) #Quit button in bottom right


        pg.display.update()#updates screen
        clock.tick(15)#sets clock rate

#game loop
def game_loop():
    left = False
    offset = 0
    global PLATFORM_LIST
    global startX
    global startY
    global backgroundImg
    Robot.RobotPos = (startX,startY)
    score = 0 #Score
    lives = 3 #Robot Lives
    Robot_friction = -0.3 #Friction value
    vec = pg.math.Vector2 #Setting vec as vector quantity
    while True:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                pg.quit
                quit()
            #Starts acceleration when key is pressed
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_LEFT:
                    Robot.acc.x = -Robot_acc
                    left = True
                elif event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot_acc                  
                elif event.key == pg.K_UP:
                    jump()
            elif Robot.acc.x < 0:
                left = True
            else:
                left = False 

            print(left)
            #Adds friction to accleration to slow robot down when key is not being pressed
            if event.type == pg.KEYUP:
                if event.key == pg.K_LEFT or event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot.acc.x * Robot_friction

        #Adjusts velocity of robot by adding the acceleration on each cycle
        Robot.vel = Robot.vel+ Robot.acc
        #gameDisplay.fill(sky)
        gameDisplay.blit(backgroundImg,(0,0))
        #Changes Robot position according to its velocity,acceleration and the friction
        Robot.RobotPos = Robot.RobotPos + Robot.vel + 0.5 * Robot.acc
        #Loads robot onto screen
        gameDisplay.blit(robotImg,(Robot.rect))
        #pg.draw.rect(gameDisplay, red, Robot.rect, 2
        display_lives(lives)
        display_score(score)#lives

        #Sets bottom of robot to its position
        Robot.rect.midbottom =  Robot.RobotPos

        #Collision detection
        if Robot.vel.y > 0:
            hits = pg.sprite.spritecollide(Robot , platforms, False)
            if hits:
                if Robot.RobotPos.y < hits[0].rect.bottom:
                    #Puts Robot on top of platform
                    Robot.RobotPos.y = hits[0].rect.top + 1
                    Robot.vel.y = 0

        hit = pg.sprite.spritecollide(Robot , wall,False)
        if hit:
            if left == True:
                Robot.vel.x = 0
                Robot.acc.x = 0
            else:
                pass

        #Scrolling
        if offset > 0:
            pass
        elif Robot.rect.left < display_width/4:
            Robot.RobotPos.x = Robot.RobotPos.x + abs(Robot.vel.x)
            startX = startX + int(abs(Robot.vel.x))
            offset = offset + int(abs(Robot.vel.x))
            for plat in platforms:
                plat.rect.x = plat.rect.x + int(abs(Robot.vel.x))

        if Robot.rect.right > (display_width-display_width/4):
            Robot.RobotPos.x = Robot.RobotPos.x - abs(Robot.vel.x)
            startX = startX - int(abs(Robot.vel.x))
            offset = offset - int(abs(Robot.vel.x))
            for plat in platforms:
                plat.rect.x = plat.rect.x - int(abs(Robot.vel.x))

        draw()

        #Losing a life
        if Robot.rect.top > display_height:
            lives = lives - 1
            Robot.RobotPos.y = Robot.RobotPos.y - (40+Robot_height)
            Robot.RobotPos.x = Robot.RobotPos.x - 200
            Robot.vel.x = 0


        #Sets top velocity of robot    
        if Robot.vel.x > 6:
            Robot.vel.x = 6
        if Robot.vel.x < -6:
            Robot.vel.x = -6
        #Makes robot velocity = 0 when it is close to 0
        if Robot.vel.x < 0.05 and Robot.vel.x > -0.05:
            Robot.acc.x = 0
            Robot.vel.x = 0

        pg.display.update()#Updates display
        clock.tick(60)

game_intro()
pg.quit()
quit()
Ashley Kelly
  • 35
  • 5