Bonus Project: Dodger

What This Is

A game that gets harder until you lose. You slide left and right along the bottom of the screen. Something falls at you. You dodge it, and the next one comes faster. Three lives, and then it is over.

This is extra credit and it is optional. Nothing later in the course depends on it. It exists because you finished early, or because you want to build something you can show somebody.

Before You Start

You need everything through session 16. Motion, collision as a condition, math.random, and a counting loop. Every one of those is used, and the counting loop is what draws your lives.

Nothing here is new. This project is built entirely out of things you already have, which is the point of putting it at session 16 — it is the first place a real game is reachable with no new tools at all.

Copy template-game and rename it bp-dodger. No new files, no libraries, nothing to install.

Build It

Five stages, and the whole file is printed at the end of every one. Run it after each stage — a stage that works is worth more than three stages you cannot test.

Type it rather than pasting it. The reading you do on the way is the whole point, and pasting skips all of it. When something breaks, the listing at the end of the stage is what your file should look like.

1. A player you can steer

A wide, short rectangle near the bottom. Move it with Left and Right. You want the kind of key check that keeps working while the key is held:

if love.keyboard.isDown("left") then
    playerX = playerX - playerSpeed * dt
end

Then stop it leaving the screen. Two conditions, one per side, and the right-hand one uses playerX + playerW rather than playerX.

The whole file after stage 1:

1
local playerX = 370
2
local playerY = 540
3
local playerW = 60
4
local playerH = 20
5
local playerSpeed = 400
6

7
function love.update(dt)
8
    if love.keyboard.isDown("left") then
9
        playerX = playerX - playerSpeed * dt
10
    end
11

12
    if love.keyboard.isDown("right") then
13
        playerX = playerX + playerSpeed * dt
14
    end
15

16
    if playerX < 0 then
17
        playerX = 0
18
    end
19

20
    if playerX + playerW > 800 then
21
        playerX = 800 - playerW
22
    end
23
end
24

25
function love.draw()
26
    love.graphics.setColor(0.3, 0.9, 0.5)
27
    love.graphics.rectangle("fill", playerX, playerY, playerW, playerH)
28
end
29

30
function love.keypressed(key)
31
    if key == "escape" then
32
        love.event.quit()
33
    end
34
end

2. One block, falling

Variables for the block's x, y, size and speed. Add the speed to y every frame. Start it above the top of the window — blockY = -50 — so it slides into view rather than appearing.

The whole file after stage 2:

1
math.randomseed(os.time())
2

3
local playerX = 370
4
local playerY = 540
5
local playerW = 60
6
local playerH = 20
7
local playerSpeed = 400
8

9
local blockX = math.random(0, 750)
10
local blockY = -50
11
local blockW = 50
12
local blockH = 50
13
local blockSpeed = 200
14

15
function love.update(dt)
16
    if love.keyboard.isDown("left") then
17
        playerX = playerX - playerSpeed * dt
18
    end
19

20
    if love.keyboard.isDown("right") then
21
        playerX = playerX + playerSpeed * dt
22
    end
23

24
    if playerX < 0 then
25
        playerX = 0
26
    end
27

28
    if playerX + playerW > 800 then
29
        playerX = 800 - playerW
30
    end
31

32
    blockY = blockY + blockSpeed * dt
33
end
34

35
function love.draw()
36
    love.graphics.setColor(0.3, 0.9, 0.5)
37
    love.graphics.rectangle("fill", playerX, playerY, playerW, playerH)
38

39
    love.graphics.setColor(0.95, 0.35, 0.3)
40
    love.graphics.rectangle("fill", blockX, blockY, blockW, blockH)
41
end
42

43
function love.keypressed(key)
44
    if key == "escape" then
45
        love.event.quit()
46
    end
47
end

3. Send it round again

When the block goes past the bottom, you dodged it. Score a point, put it back at the top at a new random x, and make the next one faster:

if blockY > 600 then
    score = score + 1
    blockSpeed = blockSpeed + 15
    blockY = -50
    blockX = math.random(0, 750)
end

That one line is the entire game design. Without it you have a thing that falls; with it you have something that eventually beats you, which is what makes people play again.

Put math.randomseed(os.time()) at the very top of the file, once. Without it your blocks fall in the identical pattern every single run, which is a strange thing to discover twenty minutes in.

The whole file after stage 3:

1
math.randomseed(os.time())
2

3
local playerX = 370
4
local playerY = 540
5
local playerW = 60
6
local playerH = 20
7
local playerSpeed = 400
8

9
local blockX = math.random(0, 750)
10
local blockY = -50
11
local blockW = 50
12
local blockH = 50
13
local blockSpeed = 200
14

15
local score = 0
16
local lives = 3
17

18
function love.update(dt)
19
    if love.keyboard.isDown("left") then
20
        playerX = playerX - playerSpeed * dt
21
    end
22

23
    if love.keyboard.isDown("right") then
24
        playerX = playerX + playerSpeed * dt
25
    end
26

27
    if playerX < 0 then
28
        playerX = 0
29
    end
30

31
    if playerX + playerW > 800 then
32
        playerX = 800 - playerW
33
    end
34

35
    blockY = blockY + blockSpeed * dt
36

37
    if blockY > 600 then
38
        score = score + 1
39
        blockSpeed = blockSpeed + 15
40
        blockY = -50
41
        blockX = math.random(0, 750)
42
    end
43
end
44

45
function love.draw()
46
    love.graphics.setColor(0.3, 0.9, 0.5)
47
    love.graphics.rectangle("fill", playerX, playerY, playerW, playerH)
48

49
    love.graphics.setColor(0.95, 0.35, 0.3)
50
    love.graphics.rectangle("fill", blockX, blockY, blockW, blockH)
51
end
52

53
function love.keypressed(key)
54
    if key == "escape" then
55
        love.event.quit()
56
    end
57
end

4. Getting hit

Four things have to be true at once for two rectangles to be touching, and this is session 14's condition with different variable names. Write all four, joined with and. When it is true, take a life and send the block back to the top.

Test it by standing still and letting one hit you. If your lives drop by three at once, the block is still overlapping you on the next frame — which means you took the life but forgot to move the block.

The whole file after stage 4:

1
math.randomseed(os.time())
2

3
local playerX = 370
4
local playerY = 540
5
local playerW = 60
6
local playerH = 20
7
local playerSpeed = 400
8

9
local blockX = math.random(0, 750)
10
local blockY = -50
11
local blockW = 50
12
local blockH = 50
13
local blockSpeed = 200
14

15
local score = 0
16
local lives = 3
17

18
function love.update(dt)
19
    if love.keyboard.isDown("left") then
20
        playerX = playerX - playerSpeed * dt
21
    end
22

23
    if love.keyboard.isDown("right") then
24
        playerX = playerX + playerSpeed * dt
25
    end
26

27
    if playerX < 0 then
28
        playerX = 0
29
    end
30

31
    if playerX + playerW > 800 then
32
        playerX = 800 - playerW
33
    end
34

35
    blockY = blockY + blockSpeed * dt
36

37
    local hit = blockX < playerX + playerW
38
        and blockX + blockW > playerX
39
        and blockY < playerY + playerH
40
        and blockY + blockH > playerY
41

42
    if hit then
43
        lives = lives - 1
44
        blockY = -50
45
        blockX = math.random(0, 750)
46
    end
47

48
    if blockY > 600 then
49
        score = score + 1
50
        blockSpeed = blockSpeed + 15
51
        blockY = -50
52
        blockX = math.random(0, 750)
53
    end
54
end
55

56
function love.draw()
57
    love.graphics.setColor(0.3, 0.9, 0.5)
58
    love.graphics.rectangle("fill", playerX, playerY, playerW, playerH)
59

60
    love.graphics.setColor(0.95, 0.35, 0.3)
61
    love.graphics.rectangle("fill", blockX, blockY, blockW, blockH)
62
end
63

64
function love.keypressed(key)
65
    if key == "escape" then
66
        love.event.quit()
67
    end
68
end

5. Show the score and the lives

No text needed. Draw the score as a bar whose width is the score times twenty, and the lives as a row of squares:

for i = 1, lives do
    love.graphics.rectangle("fill", 740 - (i - 1) * 30, 20, 20, 20)
end

That is a counting loop doing real work. Three lives draws three squares, one life draws one, and you never wrote an if to decide which.

The Whole Program

Every stage above, finished and in one piece. This is the exact file the picture below came from — nothing is left out and nothing is abbreviated.

1
math.randomseed(os.time())
2

3
local playerX = 370
4
local playerY = 540
5
local playerW = 60
6
local playerH = 20
7
local playerSpeed = 400
8

9
local blockX = math.random(0, 750)
10
local blockY = -50
11
local blockW = 50
12
local blockH = 50
13
local blockSpeed = 200
14

15
local score = 0
16
local lives = 3
17

18
function love.update(dt)
19
    if love.keyboard.isDown("left") then
20
        playerX = playerX - playerSpeed * dt
21
    end
22

23
    if love.keyboard.isDown("right") then
24
        playerX = playerX + playerSpeed * dt
25
    end
26

27
    if playerX < 0 then
28
        playerX = 0
29
    end
30

31
    if playerX + playerW > 800 then
32
        playerX = 800 - playerW
33
    end
34

35
    blockY = blockY + blockSpeed * dt
36

37
    local hit = blockX < playerX + playerW
38
        and blockX + blockW > playerX
39
        and blockY < playerY + playerH
40
        and blockY + blockH > playerY
41

42
    if hit then
43
        lives = lives - 1
44
        blockY = -50
45
        blockX = math.random(0, 750)
46
    end
47

48
    if blockY > 600 then
49
        score = score + 1
50
        blockSpeed = blockSpeed + 15
51
        blockY = -50
52
        blockX = math.random(0, 750)
53
    end
54
end
55

56
function love.draw()
57
    love.graphics.setColor(0.3, 0.9, 0.5)
58
    love.graphics.rectangle("fill", playerX, playerY, playerW, playerH)
59

60
    love.graphics.setColor(0.95, 0.35, 0.3)
61
    love.graphics.rectangle("fill", blockX, blockY, blockW, blockH)
62

63
    love.graphics.setColor(0.3, 0.9, 0.5)
64
    love.graphics.rectangle("fill", 20, 20, score * 20, 14)
65

66
    love.graphics.setColor(0.95, 0.85, 0.2)
67
    for i = 1, lives do
68
        love.graphics.rectangle("fill", 740 - (i - 1) * 30, 20, 20, 20)
69
    end
70
end
71

72
function love.keypressed(key)
73
    if key == "escape" then
74
        love.event.quit()
75
    end
76
end

What Success Looks Like

A black 800 by 600 window with a green bar at the top left showing five dodges, three yellow squares at the top right for lives, a red block falling at the upper left, and a green player at the bottom right

Five dodges so far, three lives left, and the sixth block on its way down — noticeably faster than the first one was. The green bar at the top left is the score, and it grows a notch every time a block gets past you.

Then Make It Yours

End the game. At zero lives, stop everything and show something that says so. A variable called alive that the update checks first is the cheapest way.
Restart on a key press. Set everything back to its starting value in one place. If that turns out to be annoying, that is session 21 telling you what functions are for.
Add a second block. A whole second set of variables. Then a third. Stop at three and notice how bad this is getting — session 18 is the fix, and doing it the painful way first is why the fix will make sense.
Make it fair. Right now the speed goes up forever and the game becomes impossible in a way that feels cheap rather than hard. Cap it, or make the block narrower as it speeds up, and decide which feels better by playing it.
Something worth catching. A second falling shape, a different color, that gives a life back instead of taking one.

The walkthrough is not the submission. Getting the program running earns the credit; what you change afterward is what makes it worth reading. Hand in the folder and a sentence saying what you added, or what broke and what you did about it.