Walls

There are walls in the game which the player shouldn’t be able to walk through. To handle this, you need to include functions to stop the player moving through the walls. The walls are shown on the background, which you can see in Figure 10-3. This code stops the players from walking over the area of the background where the walls are located. Follow these steps:

1. Select the line below the last function in your program.
2. This first function checks whether the player can move upwards or there is a wall in the way. The function returns 1 if the player can move and 0 if they can’t. These numbers are used later in the program and determine the distance the player moves. The single function will stop the player moving through the top wall as well as through the wall above two of the four doors. Add it to your program now:

   def upClear(x, y):
    canMove = True

    if verticalDoorLeft <= x <= verticalDoorRight and
      y - 1 < topWall:
        canMove = True
    elif y - 1 < topWall:
        canMove = False
    elif (x < leftWall or x > rightWall) and y - 1 <
      middleDoorsTop:
        canMove = False

    if canMove:
        return 1
    else:
        return 0

3. Like the upClear() function, the downClear() function checks whether the player can move downwards or whether there is a wall in the way:

   def downClear(x, y):
    canMove = True

    if verticalDoorLeft <= x <= verticalDoorRight and
      bottomWall < y + 1:
        canMove = True
    elif bottomWall < y + 1:
        canMove = False
    elif (x < leftWall or x > rightWall) and y + 1 >
      middleDoorsBottom:
        canMove = False

    if canMove:
        return 1
    else:
        return 0

4. The leftClear() function checks whether the player can move left or whether there is a wall in the way:

   def leftClear(x, y):
    canMove = True

    if middleDoorsTop <= y <= middleDoorsBottom and
      x - 1 < leftWall:
        canMove = True
    elif x - 1 < leftWall:
        canMove = False
    elif (y > bottomWall or y < topWall) and x - 1 <
      verticalDoorLeft:
        canMove = False

    if canMove:
        return 1
    else:
        return 0

5. Finally, the rightClear() function checks whether the player can move to the right or whether there is a wall in the way:

   def rightClear(x, y):
    canMove = True

    if middleDoorsTop <= y <= middleDoorsBottom and
      x + 1 > rightWall:
        canMove = True

    elif x + 1 > rightWall:
        canMove = False
    elif (y > bottomWall or y < topWall) and x + 1 >
      verticalDoorRight:
        canMove = False

    if canMove:
        return 1
    else:
        return 0

Doors, Collisions and Coins

The next functions in your program are used to check when the player walks through a door, whether the players have collided and whether the player is touching a coin.

1. Add a new line below the code you’ve already added to the program.
2. The first function will check if the player has moved through one of the doors. If the player has moved through a door, it will return new x and y coordinates for the player, which will move the player to the opposite door in the game.

   def checkOffscreen(x, y):
    if x < -14:
        x = windowSize[0] - 14
    elif x > windowSize[0] - 14:
        x = -14

    if y < -20:
        y = windowSize[1] - 20
    elif y > windowSize[1] - 20:
        y = -20
    return x, y

3. The next part of the program checks whether the players are touching. If they are, they should push each other away in opposite directions. So that the players aren’t pushed through walls, the distance the players move is set using two loops, one for the x coordinates and the other for the y coordinates. Each loop checks whether the player can continue to move in that direction, adding 1 to the distance they travel if they can and 0 if they can’t. Add this code to your program now:

   def playersTouching():
    global pOneX, pOneY, pTwoX, pTwoY

    if -32 < pOneX - pTwoX < 32 and -40 < pOneY - pTwoY < 40:
        xDiff = pOneX - pTwoX
        yDiff = pOneY - pTwoY

        for dist in range(abs(xDiff) / 2):
            pOneMove = leftClear(pOneX, pOneY) +
              rightClear(pOneX, pOneY)
            pTwoMove = leftClear(pTwoX, pTwoY) +
              rightClear(pTwoX, pTwoY)
            if xDiff > 0:
                pOneX += pOneMove / 2 * xDiff / xDiff
                pTwoX -= pTwoMove / 2 * xDiff / xDiff
            else:
                pOneX -= pOneMove / 2 * xDiff / xDiff
                pTwoX += pTwoMove / 2 * xDiff / xDiff

for dist in range(abs(yDiff) / 2):
            pOneMove = upClear(pOneX, pOneY) +
               downClear(pOneX, pOneY)
            pTwoMove = upClear(pTwoX, pTwoY) +
               downClear(pTwoX, pTwoY)
            if yDiff > 0:
                pOneY += pOneMove / 2 * yDiff / yDiff
                pTwoY -= pTwoMove / 2 * yDiff / yDiff
            else:
                pOneY -= pOneMove / 2 * yDiff / yDiff
                pTwoY += pTwoMove / 2 * yDiff / yDiff

4. The next function checks whether a player is touching the coin by checking if their position is near the coin. The function will return True if they are and False if they aren’t. This function does not add points to the players’ scores or reset the coin’s position; this is done later in the program. Add this function to your program now:

   def touchingCoin(x, y):
    return -32 < x - coinPos[0] < 20 and -40 <
      y - coinPos[1] < 20

5. The last function generates a random position for the coin. This is used to set its original position and a new position when the coin is collected. In the file editor, add this code to your program:

   def randomPosition():
    x = random.randrange(32, windowSize[0] - 52)
    y = random.randrange(32, windowSize[1] - 52)
    return x, y

Setting Up the Window and Variables

Now that the program has all the functions needed in the game, it’s time to add variables and other Python code to join it all together.

The next part of the program sets up the size of the window, followed by variables for displaying text, player positions, images and sounds:

1. Select the line below the code you added in the section above.
2. Add this code to set up the window size and the clock for the game:

   windowSize = [640, 384]
screen = pygame.display.set_mode(windowSize)
clock = pygame.time.Clock()

3. The next part of the program sets the font in which the points will be displayed. Each character in a monospace font is the same size, which makes it much easier to know how much space the points will take up when they are displayed above the players’ heads. Add this code to your program now:

   # Font for points
pointFont = pygame.font.SysFont("Monospace", 15)

4. The next set of variables sets the players’ starting positions, the coin’s starting position, the points collected by each player and variables that are used when animating the players. Add this code now:

   # Variables for position etc.
pOneX = windowSize[0] / 4
pOneY = windowSize[1] / 2

pTwoX = (windowSize[0] / 4) * 3
pTwoY = windowSize[1] / 2

coinPos = randomPosition()

pOnePoints = 0
pTwoPoints = 0

pOneCount = 0
pTwoCount = 0

pOneMoving = False
pTwoMoving = False

5. The next part of the program sets the values for the wall and door locations. These variables are used in the functions that check whether the players have walked into walls or are going through doors. Add these variables to your program now:

   # Variables for walls
leftWall = 28
topWall = 16
rightWall = windowSize[0] - 60
bottomWall = 312

middleDoorsTop = 144
middleDoorsBottom = 182
verticalDoorLeft = 284
verticalDoorRight = verticalDoorLeft + 40

6. The next set of variables store the loaded images for the background, all the player animation sprites and the coin. All the images are resized to make them look retro and pixelated. The image stored in the light variable is used for lights in the game. Later in the program, it is placed over all the other images so that it looks like a light is shining on them. Add the code to load the images now:

   # Load images
background = pygame.image.load("background.png")
background = pygame.transform.scale(background, windowSize)

light = pygame.image.load("light.png")
light = pygame.transform.scale(light, windowSize)

pOneMove1 = pygame.image.load("sprite1_walking1.png")
pOneMove1 = pygame.transform.scale2x(pOneMove1)

pOneMove2 = pygame.image.load("sprite1_walking2.png")
pOneMove2 = pygame.transform.scale2x(pOneMove2)

pOneStanding = pygame.image.load("sprite1_standing.png")
pOneStanding = pygame.transform.scale2x(pOneStanding)

pTwoMove1 = pygame.image.load("sprite2_walking1.png")
pTwoMove1 = pygame.transform.scale2x(pTwoMove1)

pTwoMove2 = pygame.image.load("sprite2_walking2.png")
pTwoMove2 = pygame.transform.scale2x(pTwoMove2)

pTwoStanding = pygame.image.load("sprite2_standing.png")
pTwoStanding = pygame.transform.scale2x(pTwoStanding)

coin = pygame.image.load("coin.png")
coin = pygame.transform.scale2x(coin)

7. The final set of variables loads the coin collect sound and game music into the program. Add it now:

   # Load music and sound
coinSound = pygame.mixer.Sound("coin.wav")
pygame.mixer.music.load("music.mp3")
pygame.mixer.music.play(-1)

Character Controls and Animations

The first part of the game loop enables the program to check whether any keys have been pressed. It also calls the functions that check whether the player is walking into a wall and determine what sprite is to be used in the animation.

Let’s get started.

1. Select the line below the code you added in the last section.
2. The game loop starts in the usual way. Add this code to your program now:

   # Game loop
done = False
while not done:

3. At the start of the game loop, the program checks whether any keys have been pressed. If the w, a, s or d keys have been pressed, the program will move player 1. Add this code to your program now:

       # Get movement
    # Player 1 movement
    pOneMoving = False
    keys = pygame.key.get_pressed()
    if keys[pygame.K_s]:
        pOneY += downClear(pOneX, pOneY)
        pOneMoving = True
    if keys[pygame.K_w]:
        pOneY -= upClear(pOneX, pOneY)
        pOneMoving = True
    if keys[pygame.K_a]:
        pOneX -= leftClear(pOneX, pOneY)
        pOneMoving = True
    if keys[pygame.K_d]:
        pOneX += rightClear(pOneX, pOneY)
        pOneMoving = True

    pOneX, pOneY = checkOffscreen(pOneX, pOneY)

4. To decide which image is displayed for player 1, the program checks whether the player is moving. If it is moving, the program uses the moveAnimation() function to determine which sprite should be displayed for the animation. If the player isn't moving, it displays the standing sprite. Add the code now:

       # Player 1 animation
    if pOneMoving:
        pOneCount += 1
        pOneImage = moveAnimation(pOneMove1, pOneMove2,
          pOneCount)
    else:
        pOneImage = pOneStanding

5. The code for player 2 is very similar to the code for player 1 but just uses different keys for movement and different images for the animation. Add this code now:

       # Player 2 movement
    pTwoMoving = False
    if keys[pygame.K_DOWN]:
        pTwoY += downClear(pTwoX, pTwoY)
        pTwoMoving = True
    if keys[pygame.K_UP]:
        pTwoY -= upClear(pTwoX, pTwoY)
        pTwoMoving = True
    if keys[pygame.K_LEFT]:
        pTwoX -= leftClear(pTwoX, pTwoY)
        pTwoMoving = True
    if keys[pygame.K_RIGHT]:
        pTwoX += rightClear(pTwoX, pTwoY)
        pTwoMoving = True

    pTwoX, pTwoY = checkOffscreen(pTwoX, pTwoY)

6. Finally, add the code that animates player 2:

       # Player 2 animation
    if pTwoMoving:
        pTwoCount += 1
        pTwoImage = moveAnimation(pTwoMove1, pTwoMove2,
            pTwoCount)
    else:
        pTwoImage = pTwoStanding

You can see the coin in the game in Figure 10-4. As the players move around the game they collect the coins, which adds to their score. In the next section, you will add code to do this.

Player Collisions and Collecting Coins

After the player moves, your program needs to check two things: whether the players are touching each other and whether either of them have collected a coin. The playersTouching() function is used to check whether the players are touching. The touchingCoin() function is used for both players, alongside if statements for each player and a final if statement that sets the coin’s position to a new random location.

1. On the line below the code you’ve already added to the program, add this code to check whether the players are touching:

       # Check touching
    playersTouching()

2. The next part of the program checks whether player 1 is touching the coin and adds a point to their total if they are:

       # Check touching coin
    if touchingCoin(pOneX, pOneY):
        pOnePoints += 1
        coinSound.play()

3. After checking whether player 1 is touching the coin, the next few lines of code check whether the other player is touching the coin:

       if touchingCoin(pTwoX, pTwoY):
pTwoPoints += 1
coinSound.play()

4. If either player is touching the coin, it needs to move to a new random location. Add this code to do that now:

       # Move coin if touching
    if touchingCoin(pOneX, pOneY) or touchingCoin(pTwoX,
      pTwoY):
coinPos = randomPosition()

Displaying Points and Updating the Window

Now that all of the game logic has run in the program, all that’s left is to display the points, sprites and background on the window.

1. Click in the window below the rest of your program and create a new line.
2. On the new line, add these lines of code to render the players’ points as strings that can be displayed on the PyGame surface:

   # Render points for display
    pOnePointLabel = pointFont.render(str(pOnePoints), 1, (255, 255, 255))
    pTwoPointLabel = pointFont.render(str(pTwoPoints), 1, (255, 255, 255))

3. The next part of the code blits the background, coin, sprites, points and lighting onto the PyGame surface:

       # Update display
    screen.blit(background, (0, 0))
    screen.blit(coin, coinPos)
    screen.blit(pOneImage, [pOneX, pOneY])
    screen.blit(pTwoImage, [pTwoX, pTwoY])
    screen.blit(pOnePointLabel, [pOneX - 9, pOneY - 9])
    screen.blit(pTwoPointLabel, [pTwoX - 9, pTwoY - 9])
    screen.blit(light, (0, 0))

    pygame.display.flip()

4. The final bit of code allows the window to be closed:

       # exit
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True
    clock.tick(60)
pygame.quit()