Game — Turtle Maze Walker

By the end of this lesson you can:

• Bind a keyboard key to a Python function with screen.onkey().
• Use screen.listen() + screen.mainloop() to make the window respond to events.
• Define tiny "move up/down/left/right" functions and wire each to an arrow key.
• Detect when the player reaches the goal — distance check from the goal's coordinates.

In turtle, pressing a key just calls a function you wrote. Try this:

import turtle

player = turtle.Turtle(shape="turtle")
screen = turtle.Screen()

def up():
    player.setheading(90)
    player.forward(20)

screen.listen()
screen.onkey(up, "Up")    # arrow keys: "Up", "Down", "Left", "Right"
screen.mainloop()

Click the turtle window, then press ↑. The turtle moves up 20 pixels. Press it again — moves again. The key is wired to your function.

The four-step shape

1.  Define handler functions  (def up(): ...)
2.  Tell screen to listen      (screen.listen())
3.  Bind keys to handlers      (screen.onkey(up, "Up"))
4.  Enter the event loop       (screen.mainloop())

After step 4, your script doesn't run any more lines. It just sits waiting for key presses. Each press fires the matching handler.

The four direction handlers

STEP = 20

def up():    player.setheading(90);  player.forward(STEP)
def down():  player.setheading(270); player.forward(STEP)
def left():  player.setheading(180); player.forward(STEP)
def right(): player.setheading(0);   player.forward(STEP)

screen.listen()
screen.onkey(up,    "Up")
screen.onkey(down,  "Down")
screen.onkey(left,  "Left")
screen.onkey(right, "Right")

Setting the heading before moving means the turtle always points the right way — handy for a turtle-shaped cursor that visibly turns.

Key names

Up Down Left Right    arrow keys
space                  spacebar
Return                 enter
Escape                 esc
a b c ... z            single letters (case-sensitive on some systems)
1 2 3 4 ... 0          number keys

The goal · distance check

Pick a goal position. After each move, check if the player's position is close enough.

GOAL = (200, 150)

def at_goal():
    gx, gy = GOAL
    return abs(player.xcor() - gx) < 15 and abs(player.ycor() - gy) < 15

Why < 15 instead of ==? Because the player moves in 20-pixel steps and almost never lands exactly on the goal. A 15-pixel tolerance feels generous and forgiving.

Reacting to reaching the goal

At the end of every direction handler, check the goal and announce:

def check_win():
    if at_goal():
        win_label.write("YOU WIN!", font=("Arial", 36, "bold"))

def up():
    player.setheading(90); player.forward(STEP); check_win()

Drawing walls

Walls are static — just lines drawn by a helper turtle. Use hideturtle and speed(0) so they appear instantly.

def draw_wall(x1, y1, x2, y2):
    walls.penup(); walls.goto(x1, y1); walls.pendown()
    walls.goto(x2, y2)

walls = turtle.Turtle()
walls.hideturtle(); walls.speed(0); walls.color("dimgray"); walls.pensize(4)
draw_wall(-200, 100, 200, 100)
draw_wall(100, 100, 100, -100)
# ... more walls ...

Detecting collisions with walls is harder — really, you check if the next position would cross a line. We'll keep walls visual-only today; the maze just sets expectations. Walking through walls is rude but allowed in v1.

Save as maze.py:

# maze.py — arrow-key maze walker

import turtle

screen = turtle.Screen()
screen.setup(width=500, height=500)
screen.title("Maze Walker")
screen.bgcolor("white")

# Walls
walls = turtle.Turtle()
walls.hideturtle(); walls.speed(0)
walls.color("dimgray"); walls.pensize(4)

def line(x1, y1, x2, y2):
    walls.penup(); walls.goto(x1, y1); walls.pendown(); walls.goto(x2, y2)

line(-200, -200, 200, -200)     # bottom
line(200, -200, 200, 200)       # right
line(200, 200, -200, 200)       # top
line(-200, 200, -200, -200)     # left
line(-200, 100, 100, 100)       # ledge
line(100, 100, 100, -50)        # vertical
line(-100, -50, 100, -50)       # lower ledge

# Goal marker
GOAL = (170, 170)
gx, gy = GOAL
flag = turtle.Turtle()
flag.hideturtle(); flag.penup(); flag.goto(gx - 12, gy - 12); flag.pendown()
flag.color("green"); flag.begin_fill()
for _ in range(4):
    flag.forward(24); flag.right(90)
flag.end_fill()

# Player
player = turtle.Turtle(shape="turtle")
player.color("steelblue"); player.penup(); player.goto(-170, -170); player.pendown()
player.pensize(1)

# Win message
win = turtle.Turtle()
win.hideturtle(); win.penup(); win.goto(-100, 0)

STEP = 20

def at_goal():
    return abs(player.xcor() - gx) < 15 and abs(player.ycor() - gy) < 15

def check_win():
    if at_goal():
        win.color("green")
        win.write("YOU WIN!", font=("Arial", 36, "bold"))
        screen.onkey(None, "Up")
        screen.onkey(None, "Down")
        screen.onkey(None, "Left")
        screen.onkey(None, "Right")

def up():
    player.setheading(90); player.forward(STEP); check_win()

def down():
    player.setheading(270); player.forward(STEP); check_win()

def go_left():
    player.setheading(180); player.forward(STEP); check_win()

def go_right():
    player.setheading(0); player.forward(STEP); check_win()

screen.listen()
screen.onkey(up,        "Up")
screen.onkey(down,      "Down")
screen.onkey(go_left,   "Left")
screen.onkey(go_right,  "Right")

screen.mainloop()

What you'll see

A 500×500 square room with a few interior walls. A green flag in the top-right, a steel-blue turtle starting in the bottom-left. Click the window, then arrow-key the turtle through the gaps to the flag. When you reach it, a big "YOU WIN!" appears and the arrow keys are unbound.

Read the diff

Three new shapes. (1) Many small helper turtles — one for walls, one for the flag, one for the win message, plus the player itself. Each has its own job. (2) Functions wired to keys — up, down, go_left, go_right. (Note: we couldn't use left and right as function names because they shadow built-in turtle methods.) (3) The event loop — screen.mainloop() at the end. Your script ends there; the program is now driven entirely by the user.

Interactive games follow a fixed shape. Define handler functions for each player action. Tell the screen to listen(). Bind keys to handlers with onkey(). Enter the event loop with mainloop(). The script then sits and reacts. Check the win condition at the end of each handler. Collision detection is just "is the new position somewhere it shouldn't be?" — undo if yes.