~ Pygame and Python - creating a game with various features

Add a cool background to your pygame game! It makes all the difference doesn't it?

Use a cool background image to use as your main game screen's background

The code below shows you how to add a background - make sure you watch the video to take note of the specific dimensions and requirements, although you can obviously customise this to suit your own requirements

Video Demo


import pygame
import random
# Define some colors
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)

background_image = 'background.jpg' #file name of the background image

#Set the max speed the player can move - changing this value can increase/decrease difficulty

#set the max speed the AI can move - changing this value can increase/decrease difficulty

#This function draws the background on the screen 
#max_x and max_y are the maximum x and y values of the screen
def draw_background(screen, file_name):
    myimage = pygame.image.load(file_name)
    imagerect = myimage.get_rect()
    screen.blit(myimage, imagerect)

#This function draws the smaller user-controllable stick figure on the screen
#Colour and scale paramaters have been added to the stick figure so that different varieties of stick figure
#Can be produced whilst using the same function, with the scale being used
#to adjust the size of the stick figure, and the colour being used to set the colour of the stick figures body.
def draw_stick_figure(screen, x, y, colour, scale):
    # Draw the Head
    #Each value is adjusted by the scale paramater to adjust the size of the stick figure
    #We have to convert this value to an int as scale may be a float, a type that is not
    #accepted by pygame.draw.ellipse
    pygame.draw.ellipse(screen, BLACK, [int(1 * scale) + x, y, int(10 * scale), int(10 * scale)], 0) 
    # Legs
    #Right leg (colour, length of leg....)
    pygame.draw.line(screen, BLACK, [int(5 * scale) + x, int(17 * scale) + y], [int(10 * scale) + x, int(27 * scale) + y], int(2 * scale))
    #Left Leg
    pygame.draw.line(screen, BLACK, [int(5 * scale) + x, int(17 * scale) + y], [x, int(27 * scale) + y], int(2 * scale))
    # Body
    pygame.draw.line(screen, colour, [int(5 * scale) + x, int(17 * scale) + y], [int(5 * scale) + x, int(7 * scale) + y], int(2 * scale))
    # Arms
    pygame.draw.line(screen, colour, [int(5 * scale) + x, int(7 * scale) + y], [int(9 * scale) + x, int(17 * scale) + y], int(2 * scale))
    pygame.draw.line(screen, colour, [int(5 * scale) + x, int(7 * scale) + y], [int(1 * scale) + x, int(17 * scale) + y], int(2 * scale))

#This function ensures that the number entered is between the range of the min and max values (inclusive). 
#If the number is outside of this range, we return the closest allowed value. I.e. if the max was 10 and the number
#entered was 12, 10 would be returned as this is the maximum value allowed
def keep_in_range(number, min_no, max_no):
    if (number < min_no):
        return min_no
    elif (number > max_no):
        return max_no
        return number

# Setup
# Set the width and height of the screen [width,height]

screen_size = [700, 500]
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption("My Game")
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()

#Counts the number of times the screen has been redrawn, incremented for every pygame.display.flip()
step = 0
# Hide the mouse cursor
# Speed in pixels per frame
x_speed = 0
y_speed = 0

# Current position
x_coord = 300
y_coord = 1

#AI Players current position
ai_x_coord = 300
ai_y_coord = 300

#The AI players last position
old_ai_x_coord = 300 
old_ai_y_coord = 300

ai_moves = (-AI_SPEED, 0, AI_SPEED) #A list of moves that the ai player can make each turn

#stores the current direction the ai character is moving
ai_x_direction = 0
ai_y_direction = 0
# -------- Main Program Loop -----------
while not done:
    # --- Event Processing
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True
            # User pressed down on a key
        elif event.type == pygame.KEYDOWN:
            # Figure out if it was an arrow key. If so
            # adjust speed.
            if event.key == pygame.K_LEFT:
                x_speed = -PLAYER_SPEED
            elif event.key == pygame.K_RIGHT:
                x_speed = PLAYER_SPEED
            elif event.key == pygame.K_UP:
                y_speed = -PLAYER_SPEED
            elif event.key == pygame.K_DOWN:
                y_speed = PLAYER_SPEED
        # User let up on a key
        elif event.type == pygame.KEYUP:
            # If it is an arrow key, reset vector back to zero
            if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                x_speed = 0
            elif event.key == pygame.K_UP or event.key == pygame.K_DOWN:
                y_speed = 0
    # --- Game Logic
    # Move the object according to the speed vector.
    x_coord = x_coord + x_speed
    y_coord = y_coord + y_speed

    if (x_coord < 0):
        x_coord = 0

    if (y_coord < 0):
        y_coord = 0

    #Adjust the x and y co-ordinates to ensure that the stick figure is kept on the screen and can't
    #travel off of it
    x_coord = keep_in_range(x_coord, 0, screen_size[0] - 10) #We adjust the upper limit of our allowed range to match the stick figures width
    y_coord = keep_in_range(y_coord, 0, screen_size[1] - 27) #We adjust the upper limit of our allowed range to match the stick figures height
    #Every 30 steps (screen draws) we change the direction the ai player is moving in
    #This makes the movement of the ai player look more realistic. This works because 
    #step % 30 is gives the remained when the value step is divided by 30, which will only
    #occur every 30 steps. You can experiment with changing this value and seeing how the ai 
    #character moves
    if (step % 30 == 0):
        ai_x_direction = random.choice(ai_moves)
        ai_y_direction = random.choice(ai_moves)

    #Update the old ai co-ordinate values
    old_ai_x_coord = ai_x_coord
    old_ai_y_coord = ai_y_coord

    #move the ai player in the chosen direction
    ai_x_coord = ai_x_coord + ai_x_direction
    ai_y_coord = ai_y_coord + ai_y_direction

    #Limit the ai character to ensure it stays on the screen
    ai_x_coord = keep_in_range(ai_x_coord, 0, screen_size[0] - 20)
    ai_y_coord = keep_in_range(ai_y_coord, 0, screen_size[1] - 54)

    #If our x co-ordinate has not changed, then we could have collided with a screen edge so we reverse the direction
    #This helps to keep the movement looking natural by preventing the ai player from repeatedly
    #moving along the edge of the screen
    if (ai_x_coord == old_ai_x_coord):
        ai_x_direction *= -1;
    #the same is true for the y co-ordinate
    if (ai_y_coord == old_ai_y_coord):
        ai_y_direction *= -1;

    # --- Drawing Code
    # First, clear the screen to WHITE. Don't put other drawing commands
    # above this, or they will be erased with this command.
    draw_background(screen, background_image) #draw the background
    draw_stick_figure(screen, x_coord, y_coord, RED, 1) #draw the user controlled stick figure on the screen
    draw_stick_figure(screen, ai_x_coord, ai_y_coord, BLUE, 2) #draw the ai controlled stick figure on the screen
    # Go ahead and update the screen with what we've drawn.
    step += 1#increment step
    # Limit frames per second
# Close the window and quit.