Learn 6 Core Syntax Concepts
Through a Game

When you first learn Python, new terms such as if, else, while, variables, and functions appear all at once. Each concept may seem clear when you read about it, but when you face an empty code editor, it can be difficult to know which syntax to use first.

Syntax is not a list of words to memorize. It is a set of tools for solving problems. The purpose of each concept becomes clear when you use it to move a character five spaces, attack a slime ahead, or choose a path based on a signpost.

Codedash's Python Dungeon is a game-based learning environment where you can solve the same problem with block coding or Python code. This guide explores Python's core syntax through the following six levels.

Core Python Syntax to Know First

move_right()

steps = 0

if is_enemy_right():
    attack_right()
else:
    move_right()

steps = 0
while steps < 5:
    move_right()
    steps = steps + 1

not is_downstairs()

if is_enemy_right():
    attack_right()

In block coding, placing one block inside another corresponds to indentation in Python code. Movement functions such as move_right() are not built-in Python functions; they are game-specific functions provided by Python Dungeon. Now let's see how each syntax concept is used in actual levels.

Chapter 1-1 First Steps: Function Calls and Execution Order

CHAPTER 1 · LEVEL 1

The goal of the first level is to use move_right() to send the character to the goal. The character must move five spaces from the starting point to the goal, so you run the move-right action five times.

[Run Code]
  └─ [Move Right]
      └─ [Move Right]
          └─ [Move Right]
              └─ [Move Right]
                  └─ [Move Right]

move_right()
move_right()
move_right()
move_right()
move_right()

When you connect blocks from top to bottom, the character moves in the order in which the blocks are connected. Python code also runs one line at a time from top to bottom. This level demonstrates function calls, parentheses, and execution order.

Chapter 1-5 Round and Round: Repeating Movement with while

CHAPTER 1 · LEVEL 5

In Chapter 1-5, you follow the walls in this sequence: up 6 spaces → right 5 spaces → down 4 spaces → left 3 spaces → up 2 spaces → right 1 space.

You could write the same movement function on many separate lines, but a while statement and a variable that stores the number of moves let you express the structure as "keep moving until the specified condition is no longer met."

[Set steps to 0]
[Repeat while steps < 6]
  ├─ [Move Up]
  └─ [steps = steps + 1]

Using the same structure,
repeat right 5 times,
down 4 times,
left 3 times,
and up 2 times

[Move Right]

steps = 0
while steps < 6:
    move_up()
    steps = steps + 1

steps = 0
while steps < 5:
    move_right()
    steps = steps + 1

steps = 0
while steps < 4:
    move_down()
    steps = steps + 1

steps = 0
while steps < 3:
    move_left()
    steps = steps + 1

steps = 0
while steps < 2:
    move_up()
    steps = steps + 1

move_right()

You can also solve this level with for ... in range(...). The default block list lets you build a simpler solution with count-based repeat blocks, but here the Python code was converted into blocks so you can compare the while condition, counter variable, and stopping point together.

Chapter 2-1 Slime Ambush: Check the Situation and Attack

CHAPTER 2 · LEVEL 1

There are slimes in the middle of the path. If the character only moves forward, an enemy will block the way, so you need to check whether an enemy is to the right and attack first when one is present.

[Repeat while not at the stairs]
  ├─ [If there is an enemy to the right]
  │    └─ [Attack Right]
  └─ [Move Right]

while not is_downstairs():
    if is_enemy_right():
        attack_right()
    move_right()

is_enemy_right() checks whether an enemy is to the right and returns true or false. The if statement runs attack_right() only when the result is true. The while statement repeats the detection and movement until the character reaches the goal.

You can solve this level by writing a fixed sequence of movement and attack commands, but a conditional creates a general problem-solving structure that checks for an enemy and responds when one is present.

Chapter 3-2 Fork of Fate: Variables and if/else

CHAPTER 3 · LEVEL 2

Each time you run this level, the signpost returns either "up" or "down". If you always choose one fixed path, you may fail depending on the signpost's result. Instead, store the direction you read in a variable and choose the path with if/else.

[Move Right 3 Spaces]
[direction = signpost value]
[If direction == "up"]
  ├─ [Move Up 1 Space]
  ├─ [Move Right 4 Spaces]
  └─ [Move Down 1 Space]
[Otherwise]
  ├─ [Move Down 1 Space]
  ├─ [Move Right 4 Spaces]
  └─ [Move Up 1 Space]
[Move Right 1 Space]

move_right(3)
direction = read_signpost()

if direction == "up":
    move_up()
    move_right(4)
    move_down()
else:
    move_down()
    move_right(4)
    move_up()

move_right()

1. Store the signpost result in the direction variable.
2. Use the == comparison operator to check whether the value is "up".
3. Use if/else to run only one of the two paths, upper or lower.

Comparing the block's two-branch structure with Python indentation makes it easy to see which if an else belongs to.

Chapter 4-2 Addition Door: Add and Use Two Values

CHAPTER 4 · LEVEL 2

The dungeon contains two scrolls with numbers and a locked door. The numbers on the scrolls can change each time the level runs, so you cannot write the answer in advance. Store each value in a variable, add the two numbers, and use the result to open the door.

[Move Right 3 Spaces]
[a = scroll value]
[Move Right 2 Spaces]
[b = scroll value]
[Move Right 1 Space]
[result = a + b]
[Unlock Door with result]
[Move Right 2 Spaces]

move_right(3)
a = read_scroll()

move_right(2)
b = read_scroll()

move_right()
result = a + b
unlock_door(result)
move_right(2)

In a + b, + is an arithmetic operator that adds two numbers. The calculation is stored in the result variable and then passed to unlock_door(result).

Chapter 5-1 Secret of the Magic Rune 2: Repeat the Same Route with while

CHAPTER 5 · LEVEL 1

In Chapter 5-1, you must step on each magic rune around a rectangle twice. Because the route around the perimeter stays the same and only the number of repetitions is two, you can put the actions for one lap inside a while statement.

[Move Right 3 Spaces]
[Set lap to 0]
[Repeat while lap < 2]
  ├─ [Move Up 4 Spaces]
  ├─ [Move Right 4 Spaces]
  ├─ [Move Down 4 Spaces]
  ├─ [Move Left 4 Spaces]
  └─ [lap = lap + 1]
[Move Down 2 Spaces]
[Move Right 4 Spaces]

move_right(3)

lap = 0
while lap < 2:
    move_up(4)
    move_right(4)
    move_down(4)
    move_left(4)
    lap = lap + 1

move_down(2)
move_right(4)

lap stores the number of laps completed so far. Add 1 after each lap and end the loop when lap < 2 becomes false. You can also solve this level with for, but this example uses a counter variable to demonstrate how while checks a condition and ends a loop.

Why It Helps to View Block Coding and Python Code Together

Codedash runs in the browser without requiring a separate Python environment. Instead of learning block coding and text coding as separate courses, you can compare them as two representations of the same problem.

Use Classroom Features in Your Lessons

You cannot skip directly to later chapters; each one unlocks only after you complete the previous chapter. To access Chapter 3 and later as an individual user, log in and purchase access or receive access through a redemption code. Access purchased directly remains valid for 365 days from the payment date.

Frequently Asked Questions