cy.yaml

adventures:
    story:
        name: Story
        default_save_name: Story
        description: Story
        levels:
            1:
                story_text: |
                    In level 1 you can make a story with a different main character that you enter yourself.

                    In the first line, use `{ask}` and ask who the main character of the story will be.

                    After that first line, start with `{print}` if the sentence needs to be printed.
                    You use `{echo}` if you want your main character to be at the end of the sentence.
                example_code: |
                    ```
                    {ask} The main character of this story is
                    {print} The main character is now going to walk in the forest
                    {echo} They're a bit scared,
                    {print} They hear crazy noises everywhere
                    {print} They're afraid this is a haunted forest
                    ```
                story_text_2: |
                    ### Exercise
                    Can you make your own story in Hedy now by using `{print}` , `{ask}` and `{echo}`?
            2:
                story_text: |
                    In level 2 you can make your story more fun. Your main character's name can now be anywhere in the sentence.

                    You do have to program a little bit extra for that. You must now name your main character first.

                    You can then put that name anywhere in a sentence.

                    ### Exercise
                    Can you make a story using a variable yourself? Can you add even more variables?
                example_code: |-
                    ```
                    name {is} {ask} What is the name of the main character?
                    {print} name is now going to run in the woods
                    {print} name is a bit scared
                    {print} Suddenly she hears a crazy noise...
                    {sleep}
                    {print} name is afraid this is a haunted forest
                    ```
                story_text_2: |
                    ### Exercise
                    Now it's time to add variables to your own story that you've made in the previous level.
                    Go to 'My programs', look for your level 1 story adventure and copy the code. Paste the code in your input screen in this level.

                    This code won't work in this level, because you have not used variables yet.
                    Change the `{ask}` commands and `{echo}` commands in your code to the correct form that you've learned in this level.

                    **Extra** Add a sleep command to your code to build up tension in your story.
            3:
                story_text: |
                    In level 3 you can make your story more fun. You can use randomness for any monster, animal or other obstacle, like this:
                example_code: |
                    ```
                    animals {is} 🦔, 🐿, 🦉, 🦇
                    {print} They now hear the sound of an animals {at} {random}
                    ```
                story_text_2: |
                    The command `{add}` can also come in handy in your story.
                example_code_2: |
                    ```
                    {print} They hear a sound
                    animals {is} 🐿, 🦔, 🦇, 🦉
                    animal {is} {ask} What do you think it is?
                    {add} animal {to_list} animals
                    {print} it was an animals {at} {random}
                    ```
                story_text_3: |
                    This is an example of the `{remove}` command in your story

                    ### Exercise
                    Can you use the 3 new commands `{at} {random}` , `{add} {to_list}` and `{remove} {from}` in your own story?
                example_code_3: |
                    ```
                    {print} His backpack got way too heavy.
                    {print} Inside were a bottle of water, a flashlight and a brick.
                    bag {is} water, flashlight, brick
                    dump {is} {ask} Which item should he dump?
                    {remove} dump {from} bag
                    ```
            4:
                story_text: |
                    ### Exercise
                    Copy the example code and finish it by adding quotation marks on the blanks in lines 1 and 2.
                    The blanks in line 3 and 4 should not be replaced by quotation marks, but a `{sleep}` and a `{clear}` command. Can you make it work?

                    ### Exercise 2
                    Go back to the previous level and copy your story code. Make the code work in this level by adding quotation marks in the right spots.
                    Mind: The variables in your own story should be outside of the quotation marks. Just like the second line of the example code. In that line the variable name is placed outside of the quotation marks.
                example_code: |
                    ```
                    name {is} {ask} _ What is your name? _
                    {print}  _ The main character is called _ name
                    _
                    _
                    {print} name  _ is now going to walk in the woods _
                    {print} name _ is a bit scared _
                    animals {is} 🦔, 🐿, 🦉, 🦇
                    {print} _ He hears the sound of a _ animals {at} {random}
                    {print} name _ is afraid this is a haunted forest _
                    ```
            5:
                story_text: |
                    In this level you can program different endings, which will make your story even more fun.

                    ### Exercise
                    Think of two endings for your story, for example:

                    - The princess is walking through the forest
                    - She runs into a monster

                    - Happy ending: She takes her sword and the monster quickly runs away
                    - Bad Ending: The monster eats the princess

                    You can also ensure that a name can be entered again. That works just like in the previous levels. You can combine that with an `{if}`, and then you have already made a whole program!
                example_code: |
                    ```
                    name {is} {ask} 'Who is walking in the forest?'
                    {print} name ' walks through the forest'
                    {print} name ' encounters a monster'
                    end {is} {ask} 'Would you like a good or a bad ending?'
                    {if} end {is} good {print} name ' takes the sword and the monster quickly runs away'
                    {else} {print} 'The monster eats ' name
                    ```
            7:
                story_text: |
                    In a story, someone says words several times. For example, when someone calls for help or sings a song.
                    You can put such repetitions in your story, in this level with `{repeat}`.

                    ### Exercise
                    Can you make your own story with repitition?
                example_code: |
                    ```
                    {print} 'The prince kept calling for help'
                    {repeat} 5 {times} {print} 'Help!'
                    {print} 'Why is nobody helping me?'
                    ```
            8:
                story_text: |
                    In this level you can use multiple lines in your {if} commands, this way you can upgrade your happy or sad ending!

                    ### Exercise
                    Can you make your own story with two different endings?
                example_code: |
                    ```
                    {print} 'OH NO! The T-rex is closing in!'
                    end = {ask} 'Do you want a happy or a sad ending?'
                    {if} end {is} happy
                        {print} 'Just in time Richard jumps back into the time machine!'
                        {print} 'Michael types in the code and...'
                        {print} '💥ZAP!💥'
                        {print} 'They are back in their garage'
                    {else}
                        {print} 'Michael yells COME ON RICHARD! RUN FASTER!'
                        {print} 'But Richard is too slow...'
                        {print} 'The T-rex closes in and eats him in one big bite!🦖'
                    ```
            9:
                story_text: |
                    In this level you can use nesting to put `{if}`, `{repeat}` or `{for}` commands inside other `{if}`, `{repeat}` or `{for}` commands. This gives you many options and really helps you to make your story interactive.
                example_code: |
                    ```
                    {print} 'Robin is walking downtown'
                    location = {ask} 'Is Robin going into a shop, or does she go home?'
                    {if} location {is} shop
                        {print} 'She enters the shop.'
                        {print} 'Robin sees an interesting looking book'
                        book = {ask} 'Does Robin buy the book?'
                        {if} book {is} yes
                            {print} 'Robin buys the book and goes home'
                        {else}
                            {print} 'Robin leaves the shop and goes home'
                    {else}
                        {print} 'Robin goes home'
                    ```
            10:
                story_text: |
                    In this level you can use the {for} command in your story. In this way you could easily program the children's book 'brown bear, brown bear, what do you see'.
                example_code: |
                    ```
                    animals = red bird, black sheep, green frog, yellow duck, little child
                    {print} 'brown bear'
                    {print} 'brown bear'
                    {print} 'What do you see?'
                    {for} animal {in} animals
                        {print} 'I see a ' animal ' looking at me'
                        {print} animal
                        {print} animal
                        {print} 'What do you see?'
                    {print} 'I see all the animals looking at me!'
                    ```
            12:
                story_text: In this level you can use the quotation marks to save multiple words in a variable.
                example_code: |
                    ```
                    name = 'The Queen of England'
                    {print} name ' was eating a piece of cake, when suddenly...'
                    ```
            13:
                story_text: |
                    By using the `{and}` and `{or}` commands, you can shorten your stories. For example, check out the dragon story.

                    ### Exercise
                    Can you make your own adventure minigame like this?
                example_code: |
                    ```
                    sword = 'lost'
                    game = 'on'
                    {print} 'Our hero is walking through the forest'
                    {print} 'The path splits two ways'
                    {for} i {in} {range} 0 {to} 2
                        {if} game {is} 'on'
                            path = {ask} 'Which path should she choose?'
                            {if} path {is} 'left' {and} sword {is} 'found'
                                {print} 'Our hero comes across a dragon!'
                                {print} 'Luckily our hero has a sword to defeat the beast!'
                                game = 'over'
                            {if} path {is} 'left' {and} sword {is} 'lost'
                                {print} 'Our hero finds a dragon, but she doesnt have any weapons!'
                                {print} 'Our hero is beaten by the dragon...'
                                {print} 'Try again'
                                game = 'over'
                            {if} path {is} 'right' {and} sword {is} 'found'
                                {print} 'You have already found the sword. There is nothing left here.'
                                {print} 'She walks back'
                            {if} path {is} 'right' {and} sword {is} 'lost'
                                {print} 'Our hero finds a sword'
                                {print} 'This could come in very handy'
                                sword = 'found'
                    ```
            15:
                story_text: |
                    Using the `{while}` loop can make your stories more interesting. For example, you can use `{while} game == 'on'` so you can play until the game is over.
                    Or you can use `{while} sword == 'lost'` so the player can't continue the game until they have found something.

                    ### Exercise
                    The example code shows you how to use the `{while}` loop in a story. Now **think of your own scenario** in which the player has to find something before they can continue.
                example_code: |
                    ```
                    keys = 'lost'
                    {print} 'You are standing in your garden and you have lost your keys.'
                    {print} 'Where do you want to look for them?'
                    {print} 'You can choose: tree, flowerbed, rock, postbox'
                    {while} keys == 'lost'
                        location = {ask} 'Where do you want to look?'
                        {if} location == 'flowerbed'
                            {print} 'Here they are!'
                            keys = 'found'
                        {else}
                            {print} 'Nope they are not at the ' location
                    {print} 'Now you can enter the house!'
                    ```
            18:
                story_text: |
                    We are going to print another story, but now we have to use brackets with `{print}`.

                    ### Exercise 1
                    Create a story of at least 5 sentences. You don't have to use 'name' just yet.
                example_code: |
                    ```
                    {print}('Welcome to this story!')
                    ```
                story_text_2: |
                    ### Exercise 2
                    We have already prepared an `{input}` for you. First, use the `name` variable in your story.
                    Then add a second `{ask}` and use that variable as well.
                    Tip: Remember the commas in a `{print}` between text and variables!
                example_code_2: |
                    ```
                    naam = {input}("What's your name?")
                    {print}('Welcome to this story!')
                    ```
    add_remove_command:
        name: '{add} {to} & {remove} {from}'
        default_save_name: add_remove_command
        description: introducing add to and remove from
        levels:
            3:
                story_text: |
                    ## Add to
                    You can add items to the list with the `{add} {to_list}` command. To add an item to a list you can simply type: `{add} penguin {to} animals` or you can use the `{ask}` command like in the example code.
                example_code: |
                    ```
                    animals {is} dog, cat, kangaroo
                    like {is} {ask} What is your favorite animal?
                    {add} like {to_list} animals
                    {print} I choose animals {at} {random}
                    ```
                story_text_2: |
                    ## Remove from
                    If you can add items to a list, of course you can also take them off. This is done with the `{remove} {from}` command.
                example_code_2: |
                    ```
                    animals {is} dog, cat, kangaroo
                    dislike {is} {ask} What animal do you not like?
                    {remove} dislike {from} animals
                    {print} I choose animals {at} {random}
                    ```
                story_text_3: |
                    ### Exercise
                    Try out the new commands in this virtual restaurant. Add the flavor the player is hpoing for to the list and remove the flavors they are allergic to.
                example_code_3: |
                    ```
                    {print} Mystery milkshake
                    flavors {is} strawberry, chocolate, vanilla
                    hope {is} {ask} What flavor are you hoping for?
                    _
                    allergies {is} {ask} Are you allergic to any flavors?
                    _
                    {print} You get a flavors {at} {random} milkshake
                    ```
    and_or_command:
        name: '{and} & {or}'
        default_save_name: and or
        description: introducing and or
        levels:
            13:
                story_text: |-
                    We are now going to learn `{and}` and `{or}`! If you want to check two statements, you don't have to use two `{if}`s but can use `{and}` and `{or}`.

                    If you use `{and}`, both statements, left and right of the `{and}` need to be true. We can also use `{or}`. Then only one statement needs to be correct.
                example_code: |
                    ```
                    name = {ask} 'what is your name?'
                    age = {ask} 'what is your age?'
                    {if} name {is} 'Hedy' {and} age {is} 2
                        {print} 'You are the real Hedy!'
                    ```
    ask_command:
        name: '{ask}'
        default_save_name: ask_command
        description: Introduction ask command
        levels:
            1:
                story_text: |
                    ## The ask command
                    Now that you can use the `{print}` command, you are ready to learn the next command: `{ask}`. With the `{ask}` command, you can ask a question. Check it out:
                example_code: |
                    ```
                    {print} Hello!
                    {ask} What is your name?
                    ```
                story_text_2: |
                    ## The echo command
                    If you want the computer to repeat the answer, you can use the `{echo}` command. The answer will then be echoed back at the end of the sentence, so in this example after hello.
                example_code_2: |
                    ```
                    {print} Hello!
                    {ask} What is your name?
                    {echo} hello
                    ```
                story_text_3: |
                    ### Exercise
                    Try out the `{ask}` and `{echo}` commands. Firstly, fill in the blanks to make this program work.
                    Then ask 2 more questions using the `{ask}` command, after each `{ask}` use an `{echo}` to print the answer on the screen.
                example_code_3: |
                    ```
                    _ How are you doing?
                    _
                    ```
            2:
                story_text: |
                    ## The ask command
                    Now that we can use **variables** in our codes, we no longer need the `{echo}` command.
                    We can use variables to store the answers to our questions and this way we can use the answer to multiple questions in our codes.
                    Check it out:

                    This way your code is becoming interactive!
                example_code: |
                    ```
                    name {is} {ask} What is your name?
                    {print} Hello name
                    age {is} {ask} How old are you?
                    {print} name is age years old.
                    ```
                story_text_2: |
                    ### Exercise
                    In the previous tab you have practised with setting variables with the `{is}` command.
                    You have created at least 3 variables and used them with a print command.
                    Now, instead of setting the variables we want you to make the variables interactive, like we did in our example.

                    Copy your code from the previous tab and make the variables interactive by using `{ask}` commands.
                example_code_2: |
                    ```
                    favorite_animals is ask What is your favorite animal?
                    print I like favorite_animals
                    ```
            18:
                story_text: The final change we will need to make to get Python code is changing `{ask}` into `{input}`.
                example_code: |
                    ```
                    {print}('My name is Hedy!')
                    name = {input}('What is your name?')
                    {print}('So your name is ', name)
                    ```
    blackjack:
        name: Blackjack
        default_save_name: Blackjack
        description: Try to get as close to 21 as you can
        levels:
            17:
                story_text: |
                    Blackjack is a simple game of cards in which you have to get as close to 21 points as possible. You get two cards. Each card is worth their numeral value, and the face cards (Jack, Queen and King) are worth 10 points.
                    The Ace is worth either 1 or 11 points (you can choose). The dealer, your opponent, also gets two cards.
                    If you want, you can get another card, and its points will be added to your total. The dealer can also choose to take another card.
                    But be careful not to get more than 21 points, because if you do, you lose!
                    The player who gets closest to 21, without going over it, wins!

                    ### Exercise
                    In this adventure we code the first part of our Blackjack game. We'll create a function to calculate how many points a card is worth.

                    ***Set the variables***
                    Start by making a list of all the cards, from 2 to Ace. Next make a list of the face cards, so Jack, Queen and King. Then pick a random card from the list of cards to be card_1.

                    ***Create a function to calculate the points***
                    Create a function that calculates how many points a card is worth.
                    All the face cards are worth 10 points, the Ace is worth 11 and all the other cards are worth their numeral.
                    Return the variable `points` at the end of the function.

                    ***Test the function***
                    Test if your function is working properly. Finish the first print command by filling in which card you've drawn. Then finish the second line by calling the function with card_1.
                    Run the code a couple of times. Are you happy with the results? Great! Then you can remove the testing part and move on the the next tab!
                example_code: |
                    ```
                    {print} 'BLACKJACK'

                    # Set these variables
                    cards = _
                    face_cards = _
                    card_1 =

                    # Create a function to calculate the points
                    {define} calculate_points {with} card:
                        {if} card {in} face_cards:
                            points = _
                        {elif} _
                            _
                        {else}:
                            _
                        _ points

                    # Test your function
                    {print} 'Your card is a ' _
                    {print} 'That is worth ' _ ' points'.
                    ```
    blackjack_2:
        name: Blackjack 2
        default_save_name: Blackjack_2
        description: Blackjack part 2
        levels:
            17:
                story_text: |
                    ### Exercise
                    In this adventure we code the second part of our Blackjack game.

                    ***Paste your code from the previous adventure***
                    In the previous adventure you've started a list of variables and created a function to calculate how many points a card is worth. Copy your code and paste it here. Mind that you don't need the testing part, so if you haven't removed that yet, please do so now.

                    ***Add more variables***
                    You have already set the lists `cards` and `face_cards` and the variable `card_1`. Underneath those variables create 3 more variables: `card_2`, dealer_card_1` and `dealer_card_2`. These variables are all set to a random card from the list of cards.

                    ***Add up points***
                    To calculate how many points you have scored we call the function with card 1 and we do it again for card 2. Then we add both these scores together to get your total.
                    Do the same thing for the dealers points, but be sure to use the dealer's cards and not your own!

                    ***2 Aces***
                    You're doing great! Almost all scores can be calculated now. There is only one exception: 2 Aces. If you get 2 Aces, your total is 12 points and not 22 (because 22 points would be losing!). This of course also goes for the dealer.

                    ***Show the score***
                    Lastly, you want to tell the program to tell you which cards you have drawn and how many points that is. Then show which cards the dealer has and how many points they have.

                    ***Continue in the next tab***
                    Great! You have finished this part of the game! Copy your code and go to the next tab to learn how to ask for an extra card and to declare a winner.
                example_code: |
                    ```
                    # Paste your code from the previous adventure here

                    # Add these variables to the list of variables
                    card_2 = _
                    dealer_card_1 = _
                    dealer_card_2 = _

                    # Add up your points
                    your_points_1 = {call} _ {with} card_1
                    your_points_2 = _
                    your_total = _

                    # Add up the dealers points
                    dealer_points_1 = _
                    _
                    _

                    # 2 Aces
                    {if} card_1 == 'Ace' {and} _
                        your_total = 12
                    {if} dealer_card_1 _
                        dealer_total = _

                    # Show the score
                    {print} 'You have drawn a ' _ ' and a ' _ '. That is ' _ ' points'
                    {print} 'The dealer has drawn a ' _ ' and a ' _ '. That is ' _ ' points'
                    ```
    blackjack_3:
        name: Blackjack 3
        default_save_name: Blackjack_3
        description: Blackjack part 3
        levels:
            17:
                story_text: |
                    In the previous tabs you have learned how to draw 2 random cards for yourself and for the dealer and to calculate how many points you both got.
                    In this adventure we add the option to ask for an extra card for both you and the dealer.

                    ### Exercise
                    ***Paste your code from the previous adventure*** Firstly, copy your code from the previous tab and paste it here.

                    ***Extra card for you*** If you want, you can get an extra card to get your total as close to 21 as possible. First ask the player if they want an extra card.
                    If they do, pick a random card and print what they have drawn. If the card is not an Ace, you can call the function and add the points to your total.
                    In case the card is an Ace, you can't use the function, because the Ace can be either 1 point or 11 points, depending on how many points you already have earned.
                    If your total is less than 11, you want the ace to be 11 points (because this is closest to 21). So you add 11 points to your total.
                    If the total is more than or equal to 11, you want the ace to be 1 point (because you don't want more than 21 points). So you add 1 point to your total.
                    Lastly, print your new total of points.

                    ***Extra card for the dealer*** The dealer can also get an extra card. The dealer doesn't need to be asked, because they always get an extra card if their total is less than 17.
                    Copy the 'Extra card for you code' and paste it in the dealers section. Then change it to fit the dealer picking an extra card and getting points added to their total.
                example_code: |
                    ```
                    # Paste your code from the previous adventure here

                    # Extra card for you
                    hit = {ask} _
                    {if} hit == 'yes':
                        card_3 = _
                        {print} _
                        {if} card_3 _ 'Ace':
                            your_points_3 = _
                            your_total = _
                        {else}:
                           {if} your_total _
                                _
                            {else}:
                                _
                        {print} _

                    # Extra card for the dealer
                    {if} dealer_total < 17
                    _
                    ```
    blackjack_4:
        name: Blackjack 4
        default_save_name: Blackjack_4
        description: Blackjack part 4
        levels:
            17:
                story_text: |
                    In the last 3 adventures you have alsmost created a working blackjack game! The only thing left to do is to decide a winner!

                    ### Exercise
                    ***Paste your code from the previous adventure*** Start by pasting the code that you've made so far into your programming field.

                    ***Decide a winner***
                    Firstly, if you and the dealer have an equal amount of points, it's a draw.
                    Secondly, if the dealer has more than 21 points and you don't, you are the winner.
                    Thirdly, if both you and the dealer have less than 22 points, we have to see who came closest to 21. We do that by comparing who has the highest score. Is your total higher than the dealer's total, then you are the winner. If not, the dealer wins.
                    Lastly, in all other scenarios (e.g. you have more than 21 points and the dealer doesn't, or you both have more than 21 points) you are the loser.

                    ***Enjoy the game!***
                    Does your game work properly? Amazing! You have done a great job! Enjoy your game!
                    If it doesn't work right away, no worries, you might have made a mistake. Just keep calm and bebug your code using the ladybug button.
                example_code: |
                    ```
                    # Paste your code from the previous adventure here

                    # Decide a winner
                    {if} _
                        {print} 'Its a draw! Play again!'
                    {elif} _
                        {print} 'You win!'
                    {elif} _ :
                        {if} _:
                            {print} _
                        {else}:
                            {print} _
                    {else}:
                        _
                    ```
    calculator:
        name: Calculator
        default_save_name: Calculator
        description: Create a calculator
        levels:
            6:
                story_text: |
                    Now that you can do maths, you can make a calculator yourself!
                example_code: |
                    ```
                    number_1 {is} {ask} 'Fill in the first number:'
                    number_2 {is} {ask} 'Fill in the second number:'
                    correct_answer = number_1 * number_2
                    {print} number_1 ' times ' number_2 ' is ' correct_answer
                    ```
                story_text_2: |
                    ### Exercise
                    The calculator above will calculate the answer for you, but you can also make a program to test your own maths skills, like this:
                    Fill in the blanks to make it complete!
                example_code_2: |
                    ```
                    correct_answer = 11 * 27
                    answer = {ask} 'How much is 11 times 27?'
                    {if} answer {is} _ {print} 'good job!'
                    {else} {print} 'Wrong! It was ' _
                    ```
                story_text_3: |
                    You can also let the computer do random calculations on its own using {random}.
                example_code_3: |
                    numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
                    number_1 = _
                    number_2 = _
                    correct_answer = number_1 * number_2
                    given_answer = 'What is ' number_1 ' times ' number_2 '?'
                    {if} _
                    {else} _
            9:
                story_text: |
                    In a previous level you've created a calculator, in this level you can expand that code so it asks multiple questions.

                    ### Exercise 1
                    Can you finish line 10 to get the code to work?

                    ### Exercise 2
                    Give the player feedback when the enter an answer, like `{print} 'Correct!'` or `{print} 'Wrong! The correct answer is ' correct_answer`.
                example_code: |
                    ```
                    score = 0
                    {repeat} 10 {times}
                        numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
                        number_1 = numbers {at} {random}
                        number_2 = numbers {at} {random}
                        correct_answer = number_1 * number_2
                        {print} 'What is ' number_1 ' times ' number_2 '?'
                        answer = {ask} 'Type your answer here...'
                        {print} 'Your answer is ' answer
                        {if} _ {is} _
                            score = score + 1
                    {print} 'Great job! Your score is... ' score ' out of 10!'
                    ```
            10:
                story_text: |
                    This calculator game helps you practise your tables of multiplication!
                    ### Exercise
                    Fill in the blanks. We want this program to ask the player these questions:
                    ```
                    How much is 1 times 1?
                    How much is 1 times 2?
                    How much is 1 times 3?
                    How much is 2 times 1?
                    How much is 2 times 2?
                    How much is 2 times 3?
                    How much is 3 times 1?
                    How much is 3 times 2?
                    How much is 3 times 3?
                    _
                    ```
                example_code: |
                    ```
                    numbers = 1, 2, 3
                    {for} _
                        {for} _
                            answer = {ask} _
                            correct = number_1 * number_2
                            {if} answer {is} correct
                                {print} 'Great job!'
                            {else}
                                {print} 'That is wrong. The right answer is ' correct
                    ```
            11:
                story_text: |
                    With a `{for}` you can simplify tables of multiplication practise program.

                    ### Exercise 1
                    Improve the example code such that it prints a nice multiplication table: <br> "1 times 10 is 10", "2 times 10 is 20", etc.

                    ### Exercise 2
                    Go back to your level 10 multiplication code, and modify it so that it uses a `{for}` and `{range}`.
                example_code: |
                    ```
                    number = 10
                    {for} i {in} {range} 1 to 10
                        {print} i * number
                    ```
            12:
                story_text: |
                    In this level, you can make a calculator that works for decimal numbers.

                    ### Exercise 1
                    Fill out the blanks to complete the calculator. Remember to use a period and not a comma for decimal numbers.

                    ### Exercise 2
                    Create a new mathematics practice program, but now use decimal numbers.
                    Create a list of numbers, choose two to multiple and let the player answer.
                    And of course you have to validate the answer! **(extra)** Increase the difficulty by adding lives: A player loses a life for a wrong answer and after three wrong answers the game ends.
                example_code: |
                    ```
                    number1 = {ask} 'What is the first number?'
                    number2 = {ask} 'What is the second number?'
                    answer = _
                    {print} number1 ' plus ' number2 ' is ' _
                    ```
            13:
                story_text: |
                    ### Exercise 1
                    Let's make the practice program a bit harder. The player now has to answers two questions correctly. Fill out the blanks to complete the program.

                    ### Exercise 2
                    Sometimes, calculations have multiple correct answers. For example, 10 can be divided by 5 and by 2. So the question 'What number divides 10?' can be answered by 2 and by 5.
                    Ask for a calculation that has multiple correct answers, ask the player to answer it, and determine if it is correct using `{or}`.
                    Empty the programming field and create your own solution.
                example_code: |
                    ```
                    answer1 = {ask} 'What is 10 times 7?'
                    answer2 = {ask} 'What is 6 times 7?'
                    {if} _ _ _ _ _ _ _
                        {print} _
                    ```
            14:
                story_text: |
                    In this adventure you will build a calculator that calculates your mean grade for you. If you get your calculator to work, you can move on to the next adventure, which allows you to add two extra features.

                    ### Exercise 1
                    Fill in the blanks to get the calculator to work.
                    * Start with the fourth line, add a question to figure out what grade the student got.
                    * In the fifth line you'll want to calculate the total of all grades, so the total = total + grade.
                    * Then we get to set the return value. We want to return the mean, so the total devided by the amount of tests (4).
                    * Lastly we finish the code by calling the function in line 8.

                    Did you get it? Awesome! Would you like to add even more to your calculator? **This adventure continues in the next tab!**
                example_code: |
                    ```
                    {define} calculate_mean_grade
                        total = 0
                        {for} i {in} {range} 1 {to} 4
                            grade = {ask} _
                            total = total + _
                            return _ / 4

                    mean_grade = {call} _
                    {print} 'Your mean grade is ' mean_grade
                    ```

                            total = total + _
                            return _ / 4

                    mean_grade = {call} _
                    {print} 'Your mean grade is ' mean_grade
            15:
                story_text: |
                    You can add the `{while}` loop to the calculator game you've learned to make in a previous level.
                    This makes sure the player can't continue to the next question if they answer incorrectly.

                    ### Exercise
                    Add the `{while}` loop in the function, ask the player what number_1 times number_2 is and print their answer.
                    Then `{call}` the function.
                example_code: |
                    ```
                    {define} new_question
                        numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
                        number_1 = numbers {at} {random}
                        number_2 = numbers {at} {random}
                        correct = number_1 * number_2
                        answer = 0
                        _
                        _
                        _
                        {print} 'Well done!'

                    {print} 'Give 10 correct answers to win!'
                    {for} i {in} {range} 1 {to} 10
                        _
                    {print} 'You win!'
                    ```
    calculator_2:
        name: Calculator 2
        default_save_name: Calculator 2
        description: Calculator 2
        levels:
            14:
                story_text: |
                    ### Exercise 2
                    **This is the second part of this adventure.** The adventure starts in the previous tab.
                    Of course, you don't always want to calculate the mean of 4 tests. You might want to calculate the mean of 10 tests or only 2...
                    We can fix this problem by adding the argument and variable 'amount_of_tests'.
                    * Start a new line on line 3. Set the amount_of_tests argument by asking the student how many tests they have made.
                    * Change the 4 in line 4 to the new argument amount_of_tests.
                    * Lastly, change the 4 in line 6 to amount_of_tests

                    Try out your new program. Does it work?

                    ### Exercise 3
                    Did you want to make your program even better? Great! In the previous program you could only calculate the mean grade of 1 subject, but it would be better if you could calculate the mean grade for all subjects you want!
                    We won't tell you how to do it, but we will give you one tip: Start your code in line 1 with: define calculate_mean_grade with subject.
                example_code: |
                    ```
                    # Use your own code from the previous adventure.
                    ```
    clear_command:
        name: '{clear}'
        default_save_name: clear_command
        description: clear command
        levels:
            4:
                story_text: |
                    Time for a new command! With `{clear}` you can clear all the text form your output screen. This way you can prevent your screen getting too full of text.
                    Beware! If you are using a `{clear}` command, you might need to use a `{sleep}` above it. Otherwise Hedy will clear your screen without giving you the time to read as you can see in the example!
                example_code: |
                    ```
                    {print} '3'
                    {clear}
                    {print} '2'
                    {clear}
                    {print} '1'
                    {clear}
                    {print} 'wait for it...'
                    {sleep} 3
                    {clear}
                    {print} 'SURPRISE!'
                    ```
    debugging:
        name: debugging
        default_save_name: debugging
        description: debugging adventure
        levels:
            1:
                story_text: |-
                    Welcome to a debugging adventure. Debugging a code means getting rid of mistakes in the code.
                    That means that in these debugging adventures, we will show you code that does not work yet.
                    You will have to figure out what's wrong and correct the mistakes.

                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    {print} I love programming
                    Do you love programming too?
                    {echo}
                    {print} What are your hobbies?
                    {echo} Your hobbies are
                    ```
            2:
                story_text: |-
                    Welcome to a debugging adventure. Debugging a code means getting rid of mistakes in the code.
                    That means that in these debugging adventures, we will give you a code that does not work yet.
                    You will have to figure out what's wrong and correct the mistakes.

                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    destination {ask} Where are you going on holidays?
                    {print} The flight to dstination leaves at 3 pm.
                    {ask} Did you check in your luggage yet?
                    {echo}
                    {print} Let me print your boarding pass for you.
                    {sleep}
                    Here you go! Have a nice trip!
                    ```
            3:
                story_text: |-
                    Welcome to a debugging adventure. Debugging a code means getting rid of mistakes in the code.
                    That means that in these debugging adventures, we will give you a code that does not work yet.
                    You will have to figure out what's wrong and correct the mistakes.

                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    movie_choices {is} dracula, fast and furious, home alone, barbie
                    chosen_movie {is} movies {at} {random}
                    {print} Tonight we will watch chosen _movies
                    like {ask} Do you like that movie?
                    {print} Tomorrow we will watch something else.
                    {add} chosen_movie {to} movie_choices
                    {print} Tomorrow we will watch tomorrows_movie
                    tomorrows_movie {is} movie_choices {at} {random}
                    I'll go get the popcorn! {print}
                    ```
            4:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    {print} 'Welcome to the online library!
                    {ask} What genre of books do you like?
                    {print} You like genre
                    author {is} {ask} 'Who's your favorite author?'
                    {print} 'author is your favorite author'
                    {print} Hmmm... i think you should try... books {at} {random}
                    ```
            5:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    {print} Welcome to Swimming Pool Hedy!
                    class {is} {ask} 'Are you here to join a class today?'
                    {if} class yes
                    {print} 'Great! You're joining a class!
                    {print} {else} 'You will not be joining a class'
                    discount {is} 'Do you have a discount code?'
                    {if} discount {is} yes
                    discount_answer {is} {ask} 'What's your discount code?'
                    discount_codes = Senior4231, Student8786, NewMember6709
                    {if} discount_answer {is} {in} discount_cods
                    {print} 'That will be $3,50'
                    'That will be $5,50'
                    {print} 'Have a nice swim!'
                    ```
            6:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    {print} 'Vending machine'
                    chosen_product = {ask} 'Please select a product'
                    1_dollar_products = coke orange juice water
                    2_dollar_products = chocolate, cookie, museli bar
                    3dollar_prodcuts = potato chips, beef jerky, banana bread
                    {if} chosen {is} {in} 1_dollar_products
                    price = 1
                    {if} chosen_product {is} 2_dollar_products
                    price = 2
                    {else} chosen_product {in} 3_dollar_products
                    price = 3
                    amount_of_products = '{ask} How many of ' chosen_product would you like to have?'
                    total = price + amount_of_product
                    {print} 'That will be $' price 'please'
                    ```
            7:
                story_text: |-
                    ### Exercise
                    Surprise! This program looks more like an output than a code. And yet, we don't want you to just add `{print}` commands in front of each line.
                    Fix this program to turn it into the nursery rhyme 'Brother John (Frère Jaques)' by using the {repeat} command of course!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    Are you sleeping?
                    Brother John!
                    Morning bells are ringing!
                    Ding, dang, dong!
                    ```
            8:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    {print} 'Welcome to Manicures and Pedicures by Hedy'
                    bodypart = {ask} 'Are you getting your fingernails or toenails done today? Or both?'
                    {if} bodyparts {is} both
                            {print} That will be $25'
                            price = 25
                        {else}
                            {print} That will be $18'
                            price = 18
                    color = {ask} What color would you like?
                    sparkles = {ask} 'Would you like some sparkles with that?'
                    {if} sparkles {is} yes
                        {print} 'We charge $3 extra for that'
                    price = price + 3
                    {else} {print} 'No sparkles' {print} 'So no extra charge'
                    {sleep} 5
                    {print} 'All done! That will be $' price ' please!'
                    {print} 'Thank you! Byebye!'
                    ```
            9:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    {print} 'Welcome to our sandwich shop'
                    amount 'How many sandwiches would you like to buy?'
                    {repeat} amount {times}
                    {ask} {is} {ask} 'What kind or bread would you like your sandwich to be?'
                    types_of_bread {is} white, wheat, rye, garlic, gluten free
                    {if} chosen_bread in types_of_bread
                    {print} 'Lovely!'
                    {else}
                    'I'm sorry we don't sell that'
                    topping {is} {ask} 'What kind of topping would you like?'
                    sauce {is} {ask} 'What kind of sauce would you like?'
                    {print} One chosen_bread with topping and sauce.
                    price = amount * 6
                    {print} 'That will be 'price dollar' please'
                    ```

                    price = amount * 6
                    {print} 'That will be 'price dollar' please'
            10:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    names = Muad Hasan Samira Noura
                    activities = fly a kite, go swimming, go hiking, catch tan in the sun
                    {for} name {is} names
                    {print} At the beach name loves to activity at random
                    ```
            11:
                story_text: |-
                    ### Exercise
                    Debug this calender program. The output of this program is supposed to look like a list of dates.
                    For example:

                    ```
                    Hedy calender
                    Here are all the days of November
                    November 1
                    November 2
                    November 3
                    ```
                    And so on.

                    Mind that you have to test your code extra carefully for the month February, because the amount of days in this month changes in leap years.
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    print 'Hedy calender'
                    months_with_31 days = January, March, May, July, September, October, December
                    months_with_30_days = April, June, August, November
                    month = ask 'Which month would you like to see?'
                    if month in months_with_31_days
                        days = 31
                        if month in months_with30_days
                            days = 30
                    if month = February
                        leap_years = 2020, 2024, 2028, 2036, 2040, 2044, 2028
                        year = ask 'What year is it?'
                    if year in leap_years
                        days = 29
                    else
                        days = 28

                    print 'Here are all the days of ' moth
                    for i in range 1 to days
                        print month i
                    ```
            12:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    define greet
                    greetings = 'Hello', 'Hi there', 'Goodevening'
                        print greetings at random

                    define take_order
                        food = ask 'What would you like to eat?'
                        print 'One food'
                        drink = 'What would you like to drink?'
                        print 'One ' drink
                        more = ask 'Would you like anything else?'
                            if more is 'no'
                        print 'Alright'
                            else
                            print 'And ' more
                    print 'Thank you'

                    print 'Welcome to our restaurant'
                    people = ask 'How many people are in your party tonight?'
                    for i in range 0 to people
                        call greet_costumer
                    ```
            13:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    defin movie_recommendation with name
                        action_movies == 'Die Hard', 'Fast and Furious', 'Inglorious Bastards'
                        romance_movies = 'Love Actually', 'The Notebook', 'Titanic'
                        comedy_movies = 'Mr Bean' 'Barbie''Deadpool'
                        kids_movies = 'Minions', 'Paddington', 'Encanto'
                        if name is 'Camila' or name is 'Manuel'
                            recommended_movie = kids_movie at random
                        if name is 'Pedro' or 'Gabriella'
                                mood = ask 'What you in the mood for?'
                            if mood is 'action'
                                recommended_movie = comedy_movies at random
                            if mood is 'romance'
                                recommended_movie = romance_movies
                        if mood is 'comedy'
                                recommended_movie = comedy_movies at random

                    print 'I would recommend ' recommended_movie ' for ' name

                    name = ask 'Who is watching?'
                    recommendation = ask 'Would you like a recommendation?'
                    if recommendaion is 'yes'
                    print movie_recommendation with name
                    else
                    print 'No problem!'
                    ```
            14:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    define calculate_heartbeat
                        print 'Press your fingertips gently against the side of your neck'
                        print '(just under your jawline)'
                        print 'Count the number of beats you feel for 15 seconds'
                        beats == ask 'How many beats do you feel in 15 seconds?'
                        heartbeat = beats*4
                        print 'Your heartbeat is ' heartbeat
                        if heartbeat >= 60 or heartbeat <= 100
                            print 'Your heartbeat seems fine'
                        else
                            if heartbeat > 60
                                print 'Your heartbeat seems to be too low'
                            if heartbeat < 100
                                print 'Your heartbeat seems to be too high'
                            print 'You might want to contact a medical professional'

                    measure_heartbeat = ask 'Would you like to measure your heartbeat?'
                    if measure_heartbeat = 'yes'
                        call measure_heartbeat
                    else
                        'no problem'
                    ```

                        print '(just under your jawline)'
                        print 'Count the number of beats you feel for 15 seconds'
                        beats == ask 'How many beats do you feel in 15 seconds?'
                        heartbeat = beats*4
                        print 'Your heartbeat is ' heartbeat
                        if heartbeat >= 60 or heartbeat <= 100
                            print 'Your heartbeat seems fine'
                        else
                            if heartbeat > 60
                                print 'Your heartbeat seems to be too low'
                            if heartbeat < 100
                                print 'Your heartbeat seems to be too high'
                            print 'You might want to contact a medical professional'

                    measure_heartbeat = ask 'Would you like to measure your heartbeat?'
                    if measure_heartbeat = 'yes'
                        call measure_heartbeat
                    else
                        'no problem'
            15:
                story_text: |-
                    ### Exercise
                    Debug this random children's story. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    names = 'Tanya', 'Romy', 'Kayla', 'Aldrin', 'Ali'
                    verbs='walking', 'skipping', 'cycling', 'driving', 'running'
                    locations = 'on a mountaintop', 'in the supermarket', 'to the swimming pool'
                    hiding_spots = 'behind a tree', under a table', in a box'
                    sounds = 'a trumpet', 'a car crash', 'thunder'
                    causes_of_noise = 'a television', 'a kid with firecrackers', 'a magic elephant', 'a dream'

                    chosen_ name = names at random
                    chosen_verb = verbs at random
                    chosen_location = 'locations at random'
                    chosen_sounds = noises at random
                    chosen_spot = hiding_spots random
                    chosen_causes = causes_of_noise at random

                    print chosen_name ' was ' chosen_verb ' ' chosen_location
                    print 'when they suddenly heard a sound like ' sounds at random
                    print chosen_name ' looked around, but they couldn't discover where the noise came from'
                    print chosen_name ' hid ' chosen_spot'
                    print 'They tried to look around, but couldn't see anything from there'
                    hidden = 'yes'
                    while hidden = 'yes'
                        print chosen_name 'still didn't see anything'
                    answer = ask 'does ' chosen_name ' move from their hiding spot?'
                        if answer = 'yes'
                            hidden == 'no'
                    print 'chosen_name moved from' chosen_spot
                    print 'And then they saw it was just' chosen_cause
                    print chosen_name 'laughed and went on with their day'
                    print The End
                    ```
            16:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                    Tip: Make sure that you only see your score once in the end.
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    country = ['The Netherlands', 'Poland', 'Turkey', 'Zimbabwe', 'Thailand', 'Brasil', 'Peru', 'Australia', 'India', 'Romania' ]
                    capitals = 'Amsterdam', 'Warshaw' 'Istanbul', 'Harare', 'Bangkok', 'Brasilia', 'Lima', 'Canberra', 'New Delhi', 'Bucharest'
                    score = 0
                    for i in range 0 to 10
                        answer = ask 'What's the capital of ' countries[i]
                        correct = capital[i]
                        if answer = correct
                            print 'Correct!'
                        score = score + 1
                        else
                            print 'Wrong,' capitals[i] 'in the capital of' countries[i]
                        print 'You scored ' score ' out of 10'

                    ```
            17:
                story_text: |-
                    ### Exercise
                    Debug this code. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    define food_order
                        toppings = ask 'pepperoni, tuna, veggie or cheese?'
                        size = ask 'big, medium or small?'
                        number_of_pizza = ask 'How many these pizzas would you like?'

                        print 'YOU ORDERED'
                        print number_of_pizzas ' size  ' topping ' pizza'

                    define drinks_order
                        drink = ask 'water, coke, icetea, lemonade or coffee?'
                        number_of_drinks = ask 'How many of these drinks would you like?'

                        print 'YOU ORDERED'
                        print number_of_drinks ' ' drink

                    'Welcome to Hedy pizza'
                    more_food = ask 'Would you like to order a pizza?'
                    while more_food = 'yes'
                        return food_order
                        more_food = ask 'Would you like to order a pizza?'
                    more_drinks = ask 'Would you like to order some drinks?'
                    while more_drinks == 'yes'
                        call drink_order
                        more_drinks == ask 'Would you like to order more drinks?'


                    print 'Thanks for ordering!'
                    ```
            18:
                story_text: |-
                    ### Exercise
                    Debug this Old MacDonald program from level 16. Good luck!
                example_code: |
                    **Warning! This code needs to be debugged!**
                    ```
                    animals = ['pig', 'dog', 'cow']
                    sounds = ['oink', 'woof', 'moo']
                    for i in range 1 to 3
                        animal = animals[i]
                        sound = sounds[i]
                        print 'Old MacDonald had a farm'
                        print 'E I E I O!'
                        print 'and on that farm he had a ' animal
                        print 'E I E I O!'
                        print 'with a ' sound sound ' here'
                        print 'and a ' sound sound ' there'
                        print 'here a ' sound
                        print 'there a ' sound
                        print 'everywhere a ' sound sound
                    ```
    default:
        name: Cyflwyniad
        default_save_name: intro
        description: Esboniad lefel
        levels:
            1:
                story_text: "In Level 1 you can use the commands `{print}`, `{ask}` and `{echo}`.\n Type your code in the programming field. Or press the green button in the example code block, and the code will be typed for you!\nTry the code yourself with the green 'Run code' button under the programming field.\n\nYou can print text to the screen using the `{print}` command.     \n"
                example_code: |
                    ```
                    {print} Hello world!
                    ```
            2:
                story_text: |
                    Congratulations! You've reached level 2. Hopefully you've already made some awesome codes!
                    In the first level you might've notice that the `{echo}` command can only save one bit of information at a time.
                    For example in the restaurant adventure, you could echo what the costumer wanted to eat, or what they wanted to drink, but not both in one sentence.

                    That changes in level 2. In level 2 you'll learn to work with variables, that allow you to save multiple pieces of information and print them in any place you want.
                    So let's go to the next tab!
                example_code: |
                    **Warning! This code does not work!**
                    In Hedy commands will change sometimes. `{echo}` for example only works in level 1. In this level you'll learn a better way to echo answers back.
                    ```
                    {print} Welcome at Hedy's
                    {ask} What would you like to eat?
                    {echo} So you want
                    {ask} what would you like to drink?
                    {echo} So you want
                    ```
            3:
                story_text: |
                    In level 3 you can make a list. You can let the computer choose something random from the list. You do that with `{at} {random}`.
            4:
                story_text: |
                    In level 4 `{ask}` and `{print}` have changed.

                    You must put text that you want to print between quotation marks.

                    This is useful, because now you can print all the words you want. Also the words you used to store something with `{is}`.

                    Most programming languages also use quotation marks when printing, so we are also getting a step closer to real programming!
                example_code: |
                    ```
                    {print} 'You need to use quotation marks from now on!'
                    answer {is} {ask} 'What do we need to use from now on?'
                    {print} 'We need to use ' answer
                    ```
            5:
                story_text: |
                    In level 5 there is something new, the `{if}`! With the `{if}` you can choose between two different options.
                    This code prints nice if you enter Hedy as a name, and boo! if you enter something else.
                    `{ask}` and `{print}` still work like they did in level 4.
                example_code: |
                    ```
                    name {is} {ask} 'what is your name?'
                    {if} name {is} Hedy {print} 'nice' {else} {print} 'boo!'
                    ```
            6:
                story_text: |
                    In the previous level you have practiced with `{ask}` and `{if}`. For example you can ask guests what they would like to eat.
                    What you can't yet do though, is calculate the price for everyone's dinner.

                    In the previous level you have practiced with `{ask}` and `{if}`. For example you can ask guests what they would like to eat.
                    What you can't yet do though, is calculate the price for everyone's dinner.

                    This level makes it possible to use addition, subtraction and multiplication in your programs. This way you can calculate the prices in your restaurant, but you could also add a secret code to give your friends and family a discount.
                    Another option in this level is programming your own maths game, for your little brother or sister to practice their multiplications.
                    Go see for yourself!
                example_code: |
                    ```
                    {print} '5 plus 5 is ' 5 + 5
                    {print} '5 minus 5 is ' 5 - 5
                    {print} '5 times 5 is ' 5 * 5
                    ```
            7:
                story_text: |
                    Level 7 adds the `{repeat}` command.  `{repeat}` can be used to execute one line of code multiple times.
                example_code: |
                    ```
                    {repeat} 3 {times} {print} 'Hedy is fun!'
                    ```
            8:
                story_text: |
                    `{ask}` and `{print}` still work as you know them. But `{if}`, `{else}`, {pressed} and `{repeat}` have changed!
                    You can now execute groups of code together, but you will have to *indent* the code.
                    That means putting four spaces at the beginning of the line. You will also have to indent when you just want to create a block of one line.
                example_code: |
                    This is how the `{repeat}` command works now:
                    ```
                    {repeat} 5 {times}
                        {print} 'Hello everyone'
                        {print} 'This is all repeated 5 times'
                    ```
                    This is how the `{if}` and `{else}` command work now:

                    ```
                    name = {ask} 'What is your name?'
                    {if} name {is} Hedy
                        {print} 'Welcome Hedy'
                        {print} 'You can play on your computer!'
                    {else}
                        {print} 'INTRUDER!'
                        {print} 'You cannot use this computer!'
                    ```
            9:
                story_text: |
                    Great job! You've reached another new level! In the previous level you've learned to use multiple lines of code in an {if} or {repeat} command. But you can't yet combine the two...
                    Good news! In this level you will be allowed to put an {if} inside an {if}, or inside a {repeat} command. Putting a block of code inside another block of code is called nesting.                     ``` Putting a block of code inside another block of code is called nesting.
                example_code: |
                    ```
                    answer = {ask} 'Are you ready to learn something new?'
                    {if} answer {is} yes
                        {print} 'Great! You can learn to use the repeat command in the if command!'
                        {print} 'Hooray!'
                        {print} 'Hooray!'
                        {print} 'Hooray!'
                    {else}
                        {print} 'Maybe you should practice some more in the previous level'
            10:
                story_text: |-
                    In this level we learn a new code called `{for}`. With `{for}` you can make a list and use all elements.
                    `{for}` creates a block, like `{repeat}` and `{if}` so all lines in the block need to start with spaces.
                example_code: |
                    ```
                    animals {is} dog, cat, blobfish
                    {for} animal {in} animals
                      {print} 'I love ' animal
                    ```
            11:
                story_text: |
                    You have reached level 11, you're doing great! In the higher levels, Hedy is focussing more and more on teaching you the programming language Python.
                    In Python there is no `{repeat}` command, but there is a command that works like {repeat}. Are you curious to find out how to say `{repeat}` in Python language? Quickly go on to find out!
            12:
                story_text: |-
                    **Decimal numbers**
                    So far, Hedy did not allow for decimal numbers like 1.5, but now we do allow that. Note that computers use the `.` for decimal numbers.
                example_code: |
                    ```
                    {print} 'Two and a half plus two and a half is...'
                    {print} 2.5 + 2.5
                    ```

                    {print} 2.5 + 2.5
            13:
                story_text: We are now going to learn `{and}` and `{or}`! If you want to check two statements, you don't have to use two {if}'s but can use `{and}` and `{or}`. If you use `{and}`, both statements, left and right of the `{and}` need to be true. We can also use `{or}`. Then only one statement needs to be correct.
                example_code: |
                    ```
                    name = {ask} 'what is your name?'
                    age = {ask} 'what is your age?'
                    {if} name {is} 'Hedy' {and} age {is} 2
                        {print} 'You are the real Hedy!'
                    ```
            14:
                story_text: |
                    We are going to learn more new items. You might know them already from mathematics, the `<` and `>`.
                    The `<` checks if the first number is smaller than the second, for example age `<` 12 checks if age is smaller than 12.
                    If you want to check if the first number is smaller or equal to the second, you can use `<=`, for example age `<=` 11.
                    The `>` checks if the first number is bigger than the second, for example points `>` 10 checks if points is larger than 10.
                    If you want to check if the first number is bigger or equal to the second, you can use `>=`, for example points `>=` 11.
                    You use these comparisons in an `{if}`, like this:
                example_code: |
                    ```
                    age = {ask} 'How old are you?'
                    {if} age > 12
                        {print} 'You are older than I am!'
                    ```

                    {if} age < 13
                        {print} 'You are younger than me!'
                    {else}
                        {print} 'You are older than me!'
            15:
                story_text: |-
                    We are going to learn a new loop, the `{while}` loop! We continue the loop as long as the statement is true.
                    So don't forget to change the value in the loop.

                    In the example code, we continue until a correct answer has been given.
                    If the correct answer is never given, the loop never ends!
                example_code: |
                    ```
                    answer = 0
                    {while} answer != 25
                        answer = {ask} 'What is 5 times 5?'
                    {print} 'A correct answer has been given'
                    ```
            16:
                story_text: |-
                    We are going to make lists the Python way, with square brackets around the lists! We also keep the quotation marks around each item like we have learned in previous levels.
                    You can use the square brackets as well to point out a place in the lists.
                example_code: |
                    ```
                    friends = ['Ahmed', 'Ben', 'Cayden']
                    {print} friends[1] ' is the first friend on the list.'
                    {print} friends[2] ' is the second friend on the list.'
                    {print} friends[3] ' is the third friend on the list.'
                    #now we will match 2 lists using the variable i
                    lucky_numbers = [15, 18, 6]
                    {for} i {in} {range} 1 {to} 3
                        {print} friends[i] 's lucky number is ' lucky_numbers[i]
                    ```
            17:
                story_text: |-
                    Now we are going to change indentation a little bit. Every time that we need an indentation, we need `:` at the line before the indentation.

                    In this level you can also use a new command: `{elif}`. `{elif}` is short for `{else} {if}` and you need it when you want to make 3 (or more!) options.
                    Check it out!
            18:
                story_text: |-
                    We arrived at real Python code! That means we need to use parentheses with {print} and {range} from now on.
                    {print}('My name is ', name)
    dice:
        name: Dice
        default_save_name: Dice
        description: Make your own dice
        levels:
            3:
                story_text: |
                    In this level we can choose from a list. With that we can let the computer choose one side of the die.
                    Take a look at the games you have in your closet at home.
                    Are there games with a (special) die? You can also copy it with this code.
                    For example, the dice of the game Earthworms with the numbers 1 to 5 and an earthworm on it.

                    ![Die of earthworms with 1 to 5 and an earthworm on it](https://cdn.jsdelivr.net/gh/felienne/hedy@24f19e9ac16c981517e7243120bc714912407eb5/coursedata/img/dobbelsteen.jpeg)
                example_code: |
                    ```
                    choices {is} 1, 2, 3, 4, 5, earthworm
                    {print} You threw _ {at} {random}
                    ```
                story_text_2: |
                    ### Exercise
                    The dice in the example above are dice for a specific game. Can you make normal dice?
                    Or other special dice from a different game?
                example_code_2: |
                    ```
                    choices {is} _
                    ```
            4:
                story_text: |
                    In this level you can also create dice. But this time you can try it yourself, without an example code!

                    ### Exercise
                    Make your own dice in this level.
                    Tip: If you have no idea how to make dice. Take a peek at your dice from the previous level, but don't forget to add quotation marks.
            5:
                story_text: |
                    We are going to add the `{if}` and `{else}` commands to our dice!

                    ### Exercise
                    Complete the sample code so that the code says "You can stop throwing" once you have thrown an earthworm. It should say "You have to throw again" if you've thrown anything else.
                    **Extra** Maybe you want to recreate a die from a completely different game. That's fine too! Then make up your own reaction, e.g. 'yes' for 6 and 'pity' for something else.
                example_code: |
                    ```
                    choices {is} 1, 2, 3, 4, 5, earthworm
                    throw {is} choices {at} {random}
                    {print} 'you have thrown' choices
                    _ throw {is} earthworm {print} 'You can stop throwing.'
                    _ {print} 'You have to throw it again!'
                    ```
            6:
                story_text: |
                    You can also make an Earthworm die again in this, but now you can also calculate how many points have been rolled.
                    You may know that the worm counts 5 points for Earthworms. Now after a roll you can immediately calculate how many points you have thrown.
                    This is the code to calculate points for one die:

                    ### Exercise
                    Can you make the code so that you get the total score for 8 dice? To do that, you have to cut and paste some lines of the code.
                example_code: |
                    ```
                    choices = 1, 2, 3, 4, 5, earthworm
                    points = 0
                    throw = choices {at} {random}
                    {print} 'you threw' throw
                    {if} throw {is} earthworm points = points + 5 {else} points = points + throw
                    {print} 'those are' points ' point'
                    ```
                example_code_2: |
                    Did you manage to calculate the score for 8 dice? That required a lot of cutting and pasting, right? We are going to make that easier in level 7!
            7:
                story_text: |
                    You can also make a dice again in level 5. With the `{repeat}` code you can easily roll a whole hand of dice.

                    ### Exercise
                    Try to finish the sample code!  **(extra)** Think of a game you know that involves a dice and program that using a `{repeat}`.
                example_code: |
                    ```
                    choices = 1, 2, 3, 4, 5, 6
                    _ _ _ _ _ _ _
                    ```
            10:
                story_text: "Is everybody taking too long throwing the dice? In this level you can let Hedy throw all the dice at once!\n\n### Exercise \nChange the names into names of your friends or family, and finish the code.\n"
                example_code: |
                    ```
                    players = Ann, John, Jesse
                    choices = 1, 2, 3, 4, 5, 6
                    _ _ _ _
                        {print} player ' throws ' choices {at} {random}
                        {sleep}
                    ```
            15:
                story_text: |
                    ### Exercise
                    In this level you can create a little game in which you'll have to throw 6 as fast as possible.
                    We have started the code, it's up to you to get the game to work!

                    Firstly, add a `{while}` loop that checks if 6 has been thrown or not.
                    As long as you haven't thrown 6 already, throw the dice on a random number.
                    Print what the player has thrown.
                    Add a try to the amount of tries
                    Wait a second before you throw again, or - in case you've thrown a 6 - before the game ends.
                example_code: |
                    ```
                    options = 1, 2, 3, 4, 5, 6
                    {print} 'Throw 6 as fast as you can!'
                    thrown = 0
                    tries = 0
                    _
                    _
                    _
                    _
                    _
                    {print} 'Yes! You have thrown 6 in ' tries ' tries.'
                    ```
    dishes:
        name: Dishes?
        default_save_name: Dishes
        description: Use the computer to see who does the dishes (Start at level 2)
        levels:
            3:
                story_text: |
                    Do you always disagree at home about who should wash the dishes or change the litter box today?
                    Then you can let the computer choose very fairly. You can program that in this level!
                    You first make a list of the members of your family. Then choose `{at} {random}` from the list.
                example_code: |
                    ```
                    people {is} mom, dad, Emma, Sophie
                    {print} people {at} {random}
                    ```
                story_text_2: |
                    Don't feel like doing the dishes yourself? Hack the program by removing your name from the list with the `{remove}` `{from}` command.
            4:
                story_text: |
                    With quotation marks you can make your dishwashing planning more beautiful.
                    This time the sample code is not quite complete.

                    Can you complete the code by filling the blanks? Every blank must be replaced with one word of symbol.

                    Tip: Don't forget the quotation marks!
                example_code: |
                    ```
                    people {is} mom, dad, Emma, Sophie
                    {print} _ the dishes are done by _
                    {sleep}
                    {print} people {at} _
                    ```
            5:
                story_text: |
                    With the `{if}` you can now have more fun with choice in the program. You can have your program respond to the choice that the computer has made.

                    Can you finish the code so that it prints 'too bad' when it is your turn and otherwise 'yes!'?
                    Don't forget the quotes!
                example_code: "```\npeople {is} mom, dad, Emma, Sophie\ndishwasher {is} people {at} {random}\n{if} dishwasher {is} Sophie {print} _ too bad I have to do the dishes _ \n{else} {print} 'luckily no dishes because' _ 'is already washing up'\n```\n"
            6:
                story_text: |
                    How often is everyone going to do the dishes? Is that fair? You can count it in this level.
                example_code: |
                    ```
                    people = mom, dad, Emma, Sophie
                    emma_washes = 0
                    dishwasher = people {at} {random}
                    {print} 'The dishwasher is' dishwasher
                    {if} dishwasher {is} Emma emma_washes = emma_washes + 1
                    {print} 'Emma will do the dishes this week' emma_washes 'times'
                    ```

                    Now you can copy lines 3 to 5 a few times (e.g. 7 times for a whole week) to calculate for a whole week again.
                    Do you make the code for the whole week?
                story_text_2: |
                    If you are extremely unlucky the previous program might choose you to to the dishes for the whole week! That's not fair!
                    To create a fairer system you can use the `{remove}` command to remove the chosen person from the list. This way you don't have to do the dishes again untill everybody has had a turn.

                    Monday and tuesday are ready for you! Can you add the rest of the week?
                    And... can you come up with a solution for when your list is empty?
                example_code_2: |
                    ```
                    people = mom, dad, Emma, Sophie
                    dishwasher = people {at} {random}
                    {print} 'Monday the dishes are done by: ' dishwasher
                    {remove} dishwasher {from} people
                    dishwasher = people {at} {random}
                    {print} 'Tuesday the dishes are done by: ' dishwasher
                    {remove} dishwasher {from} people
                    dishwasher = people {at} {random}
                    ```
            7:
                story_text: |
                    With the `{repeat}` you can repeat pieces of code. You can use this to calculate who will be washing dishes for the entire week.
                example_code: |
                    ```
                    people = mom, dad, Emma, Sophie
                    {repeat} _ _ {print} 'the dishwasher is' _
                    ```
            10:
                story_text: |
                    In this level you could make an even better dish washing shedule.
                example_code: |
                    ```
                    days = Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
                    names = mom, dad, Emma, Sophie
                    _ day _ days
                        {print} names {at} {random} ' does the dishes on ' day
                    ```
    elif_command:
        name: '{elif}'
        default_save_name: elif
        description: elif
        levels:
            17:
                story_text: |
                    In this level you can also use a new command: `{elif}`. `{elif}` is a combination of the keywords `{else}` and `{if}` and you need it when you want to make 3 (or more!) options.
                    Check it out!
                example_code: |
                    ```
                    prices = ['1 million dollars', 'an apple pie', 'nothing']
                    your_price = prices[{random}]
                    {print} 'You win ' your_price
                    {if} your_price == '1 million dollars' :
                        {print} 'Yeah! You are rich!'
                    {elif} your_price == 'an apple pie' :
                        {print} 'Lovely, an apple pie!'
                    {else}:
                        {print} 'Better luck next time..'
                    ```
    for_command:
        name: '{for}'
        default_save_name: for
        description: for command
        levels:
            10:
                story_text: |-
                    ## For
                    In this level we learn a new code called `{for}`. With `{for}` you can make a list and use all elements.
                    `{for}` creates a block, like `{repeat}` and `{if}` so all lines in the block need to start with 4 spaces.
                example_code: |
                    ```
                    animals = dog, cat, blobfish
                    {for} animal {in} animals
                        {print} 'I love ' animal
                    ```
                story_text_2: |
                    ### Exercise
                    Finish this code by adding `{for} action {in} actions` to line 2.
                example_code_2: |
                    ```
                    actions = clap your hands, stomp your feet, shout Hurray!
                    _
                        {repeat} 2 {times}
                            {print} 'If youre happy and you know it, ' action
                            {sleep} 2
                        {print} 'If youre happy and you know it, and you really want to show it'
                        {print} 'If youre happy and you know it, ' action
                        {sleep} 3
                    ```
            11:
                story_text: |-
                    In this level, we add a new form of the `{for}`. In earlier levels, we used `{for}` with a list, but we can also use `{for}` with numbers.
                    We do that by adding a variable name, followed by  `{in}` `{range}`. We then write the number to start at, `{to}` and the number to end at.
                    Try the example to see what happens! In this level again, you will need to use indentations in lines below the `{for}` statements.
                example_code: |
                    ```
                    {for} counter {in} {range} 1 {to} 10
                        {print} counter
                    {print} 'Ready or not. Here I come!'
                    ```
            17:
                story_text: |
                    Now we are going to change indentation a little bit. Every time that we need an indentation, we need `:` at the line before the indentation.
                example_code: |
                    ```
                    {for} i {in} {range} 1 {to} 10:
                        {print} i
                    {print} 'Ready or not, here I come!'
                    ```
    fortune:
        name: Fortune teller
        default_save_name: Fortune Teller
        description: Let Hedy predict the future
        levels:
            1:
                story_text: |
                    Have you ever been to a carnival and had your future predicted by a fortune teller? Or have you ever played with a magic eight ball?
                    Then you probably know that they can't really predict your future, but it's still fun to play!

                    In the upcoming levels you can learn how to create your own fortune telling machine!
                    In level 1 you can start off easy by letting Hedy introduce herself as a fortune teller and let her `{echo}` the players' answers.
                    Like this:
                example_code: |
                    ```
                    _ Hello, I'm Hedy the fortune teller!
                    _ Who are you?
                    _ Let me take a look in my crystal ball
                    _ I see... I see...
                    _ Your name is
                    ```
                story_text_2: |
                    ### Exercise
                    Copy the example code into your inputscreen and fill in the blanks to make the code work.
                    **Extra** Change the code and let the fortune teller not only predict your name, but also your age, your favorite sports team or something else about yourself.
            3:
                story_text: |
                    In the previous levels you've created your first fortune telling machine, but Hedy couldn't really predict anything, only `{echo}`.
                    In this level you can use a variable and the `{at} {random}` command to really let Hedy choose an answer for you. Check out this code for instance:
                example_code: |
                    ```
                    {print} I’m Hedy the fortune teller!
                    question {is} {ask} What do you want to know?
                    {print} This is what you want to know: question
                    answers {is} yes, no, maybe
                    {print} My crystal ball says...
                    {sleep} 2
                    {print} answers {at} {random}
                    ```
                story_text_2: |
                    ### Exercise
                    Now, Hedy can only answer yes, no or maybe. Can you give Hedy more answer options, like 'definitely' or 'ask again'.
            4:
                story_text: |
                    ### Exercise
                    We have removed all the quotation marks from this example code, can you add them in all the right places?

                    ### Exercise 2
                    Go back to the previous level and copy your fortune teller code. Make the code work in this level by adding quotation marks in the right spots.
                example_code: |
                    ```
                    _ Add the quotation marks to this code _
                    {print} Im Hedy the fortune teller!
                    question {is} {ask} What do you want to know?
                    {print} This is your question:  question
                    answers {is} yes, no, maybe
                    {print} My crystal ball says...
                    {sleep} 2
                    {print} answers {at} {random}
                    ```
            5:
                story_text: |
                    In this level you'll learn to (secretly) tip the odds in your favor, when using the fortune teller!
                    By using `{if}` and `{else}` you can make sure that you will always get a good fotune, while other people might not.
                    Check out this example to find out how.
                example_code: |
                    ```
                    {print} 'Im Hedy the fortune teller!'
                    {print} 'I can predict if youll win the lottery tomorrow!'
                    person {is} {ask} 'Who are you?'
                    {if} person {is} Hedy {print} 'You will definitely win!🤩' {else} {print} 'Bad luck! Someone else will win!😭'
                    ```
            6:
                story_text: |
                    In this level you can use math in your predictions as a fortune teller. This allows you to make up (silly) formulas to calculate the future.
                    For example you could calculate how rich you'll get or how many kids you will have when you grow up.



                    ### Exercise
                    Can you think of your own (silly) fortune telling machine?
                example_code: |
                    ```
                    {print} 'I am Hedy the fortune teller!'
                    {print} 'I can predict how many kids youll get when you grow up!'
                    age = {ask} 'How old are you?'
                    siblings = {ask} 'How many siblings do you have?'
                    length = {ask} 'How tall are you in centimetres?'
                    kids = length / age
                    kids = kids - siblings
                    {print} 'You will get ...'
                    {sleep}
                    {print} kids ' kids!'
                    ```

                    If the previous example wasn't silly enough for you, take a look at this one!
                    ```
                    {print} 'Im Hedy the silly fortune teller!'
                    {print} 'I will predict how smart you are!'
                    football = {ask} 'On a scale 1-10 how much do you love football?'
                    bananas = {ask} 'How many bananas did you eat this week?'
                    hygiene = {ask} 'How many times did you wash your hands today?'
                    result = bananas + hygiene
                    result = result * football
                    {print} 'You are ' result ' percent smart.'
                    ```
            7:
                story_text: |
                    In this level you can use the `{repeat}` command to make your machine tell multiple fortunes at once.
                example_code: |
                    ```
                    {print} 'Im Hedy the fortune teller!'
                    {print} 'You can ask 3 questions!'
                    {repeat} 3 {times} question = {ask} 'What do you want to know?'
                    answer = yes, no, maybe
                    {repeat} 3 {times} {print} 'My crystal ball says... ' answer {at} {random}
                    ```
            8:
                story_text: |
                    In the previous levels you've learned how to use `{repeat}` to make the fortune teller answer 3 questions in a row, but we had a problem with printing the questions.
                    Now that problem is solved, because of the new way of using the `{repeat}` command.
                    In the next example you can have your fortune teller ask 3 questions and also print them!

                    ### Exercise
                    Can you fill in right command on the blanks?
                example_code: |
                    ```
                    {print} 'I am Hedy the fortune teller!'
                    {print} 'You can ask me 3 questions.'
                    answers = yes, no, maybe
                    _ _ _
                       question = {ask} 'What do you want to know?'
                       {print} question
                       {sleep}
                       {print} 'My crystal ball says...' answers {at} {random}
                    ```
            10:
                story_text: |
                    In this level you'll learn how to program the game MASH (mansion, apartment, shack, house). In this game you can predict for all the players at once, what their future will look like.

                    ### Exercise 1
                    Add two names to the list and see how the output of the program changes when you run it.
                example_code: |
                    ```
                    houses = mansion, apartment, shack, house
                    loves = nobody, a royal, their neighbour, their true love
                    pets = dog, cat, elephant
                    names = Jenna, Ryan, Jim
                    {for} name {in} names
                        {print} name ' lives in a ' houses {at} {random}
                        {print} name ' will marry ' loves {at} {random}
                        {print} name ' will get a ' pets {at} {random} ' as their pet.'
                        {sleep}
                    ```
            12:
                story_text: |-
                    From level 12 on, you will also have to use quotation marks in lists, before and after each item.

                    ### Exercise
                    Add two predictions to the list
                example_code: |
                    ```
                    fortunes = 'you will slip on a banana peel', _
                    {print} 'I will take a look in my crystal ball for your future.'
                    {print} 'I see... I see...'
                    {sleep}
                    {print} fortunes {at} {random}
                    ```
    functions:
        name: functions
        default_save_name: functions
        description: functions
        levels:
            12:
                story_text: |
                    In this level you'll learn how to use **functions**. A function is a block of code you can easily use multiple times. Using functions helps us organize pieces of code that we can use again and again.
                    To create a function, use `{define}` and give the function a name. Then put all the lines you want in the function in a indented block under the `{define}` line.
                    Leave one empty line in your code to make it look nice and neat. Great job! You have created a function!

                    Now, whenever we need that block of code, we just use <code>{call}</code> with the function's name to call it up! We don't have to type that block of code again.

                    Check out this example code of a game of Twister. The function 'turn' contains a block of code that chooses which limb should go where.

                    ### Exercise
                    Finish this code by setting the 2 variables chosen_limb and chosen_color.
                    Then, choose how many times you want to call the function to give the twister spinner a spin.

                    ### Exercise 2
                    Improve your code by adding a variable called 'people'. Use the variable to give all the players their own command in the game.
                    For example: 'Ahmed, right hand on green' or 'Jessica, left foot on yellow'.
                example_code: |
                    ```
                    sides = 'left', 'right'
                    limbs = 'hand', 'foot'
                    colors = 'red', 'blue', 'green', 'yellow'

                    {define} turn
                        chosen_side = sides {at} {random}
                        chosen_limb = limbs _
                        chosen_color = colors _
                        {print} chosen_side ' ' chosen_limb ' on ' chosen_color

                    {print} 'Lets play a game of Twister!'
                    {for} i {in} {range} 1 to _
                        {call} turn
                        {sleep} 2
                    ```
            13:
                story_text: |
                    Now that you've learned how to use functions, you'll learn how to use a function with an argument.
                    An **argument** is a variable that is used within a function. It is not used outside the function.

                    For example in this code we've programmed the first verse of the song 'My Bonnie is over the ocean'.
                    In this example code the argument `place` is used. Place is a variable that is only used in the function, so an argument.
                    To use `place` we have programmed the line `define song with place`.
                    When the function is called, computer will replace the argument `place`, with the piece of text after `call song with`.

                    ### Exercise
                    The next verse of this song goes:

                    Last night as I lay on my pillow
                    Last night as I lay on my bed
                    Last night as I lay on my pillow
                    I dreamed that my Bonnie is dead

                    Can you program this verse in the same way as the example?
                example_code: |
                    ```
                    {define} song {with} place
                        {print} 'My Bonnie is over the ' place

                    {call} song {with} 'ocean'
                    {call} song {with} 'sea'
                    {call} song {with} 'ocean'
                    ```
            14:
                story_text: |
                    In the previous levels you have learned to create functions and use arguments with them. Another great use of a function is to let it calculate something for you.
                    You can give the function a calculation and it will give you the answer of the calculation. This answer is called a **return value**.

                    For example, in this code the function calculate_new_price will calculate the new price of any item. It will give you the new price as a return value.

                    ### Exercise
                    Finish this code. We have already made the variable new_price for you, you only need to set it.
                    You should finish the line of code by calling the function that calculates the new price.
                example_code: |
                    ```
                    {define} calculate_new_price {with} amount, percentage
                        percentage = percentage / 100
                        discount_amount = amount * percentage
                        return amount - discount_amount

                    old_price = {ask} 'How much is on the price tag?'
                    discount = {ask} 'What percentage is the discount?'

                    new_price = _ calculate_new_price {with} old_price, _
                    {print} 'The new price is ' new_price ' dollar'
                    ```
    guess_my_number:
        name: Guess my number
        default_save_name: guess my number
        description: guess my number
        levels:
            14:
                story_text: |
                    In this level you can program the game 'Guess my number'

                    ### Exercise
                    Fill in the correct symbols on the blanks to get the game to work.
                example_code: |
                    ```
                    {print} 'Guess my number'
                    numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
                    number = numbers {at} {random}
                    game = 'on'
                    {for} i {in} {range} 1 {to} 10
                        {if} game == 'on'
                            guess = {ask} 'Which number do you think it is?'
                            {if} guess _ number
                                {print} 'Lower!'
                            {if} guess _ number
                                {print} 'Higher!'
                            {if} guess _ number
                                {print} 'You win!'
                                game = 'over'
                    ```
    hangman:
        name: Hangman
        default_save_name: Hangman
        description: Guess the word
        levels:
            17:
                story_text: |
                    In this adventure we program a game of hangman. First we make some preparations, then we program the game and in the third part we add a drawing with the turtle.

                    ### Exercise
                    ***Set the variables*** In this game of hangman, Player 1 chooses an answer and Player 2 has to guess the letters in this answer.
                    To let the computer know all the letters in the word, we will turn the answer into a list of letters. We also do this with the guesses Player 2 makes.
                    We will start the game with 2 empty lists. We have made an empty list for the variable answer for you. Now make an empty list for guessed_letters as well.
                    Then we fill in how many mistakes were made. At the start of the game, this should be 0.
                    The variable `amount_letters` tells us how many letters are in the answer. Ask Player 1 to tell us how many letters their word has.
                    Lastly we tell the computer if the game is over. We use the variable `game_over` and set it to `False`.

                    ***Choosing the answer*** We want Player 1 to be able to choose the answer. We'll ask them, as many times as necessary, what the next letter is.
                    Then we add that letter to the answer. Lastly, we add an empty _ to the list of guessed letters, so we get as many _s as there are letters in the answer.

                    ***Player 2's turn***
                    Tell Player 2 its their turn. Then tell Player 2 how many letters there are in the answer. Finally, print the list of `guessed_letters`.

                    ***Go to the next tab*** Now that all the starting variables are set, we can start programming the game itself. Check out the next tab to learn how!
                example_code: |
                    ```
                    print 'Hangman!'

                    # Set the variables
                    answer = []
                    guessed_letters = _
                    mistakes_made = _
                    amount_letters = {ask} _
                    _ = 'False'

                    # Choosing the answer
                    {for} _
                        letter = {ask} 'Player 1, what is letter ' i '?'
                        _
                        {add} '_' {to} _

                    # Player 2 turn
                    print _
                    print _
                    print guessed_letters
                    ```
    hangman_2:
        name: Hangman 2
        default_save_name: Hangman_2
        description: Hangman 2
        levels:
            17:
                story_text: |
                    Now it's time to program the hangman game.

                    ### Exercise

                    ***Paste your code*** Copy your code from the previous tab and paste the code in the programming field.

                    ***The game*** This games continues playing until Player 2 is game over. Fill in the while command accordingly. Now, Player 2 is allowed to guess a letter, so ask Player 2 to guess a letter.
                    We need to check if their answer is correct, so check if their `guess` is (somewhere) in the (list) `answer`. Then we let the computer figure out which of the letter(s) is the guess. We have already programmed that part for you.
                    Next we want to compliment the player for finding a correct letter and we want to print the list `guessed_letters`, so the player can see their progress.

                    The next part we're going to program is what happens when the player has guessed all of the letters. So if their list of `guessed_letters` is the same as our list `answer`.
                    If the lists are the same, congratulate Player 2 with their victory and set the variable `game_over` to `True`.

                    Next we'll program what happens when Player 2 guesses wrong (so the `{else}` command). First, tell the player that their guess was wrong. Then increase the `mistakes_made` variable by 1.

                    For the last part we'll program what happens when Player 2 has made 10 mistakes. We'll print that Player 1 has won the game. Then we'll print the correct answer. And finally, we'll set our `game_over` variable to `True`, so the game stops.

                    ***Go to the next tab*** Amazing work! Your game is playable, but wouldn't it be fun if the hangman was actually drawn when Player 2 makes a mistake..?
                example_code: |
                    ```
                    # Paste your code here

                    # The game
                    {while} game_over _
                        guess = _
                        {if} _
                            {for} i {in} {range} 1 {to} amount_letters:
                                if answer[i] == guess:
                                    guessed_letters[i] = guess
                            {print} _
                            {if} guessed_letters == _:
                                {print} _
                                game_over = _
                        {else}:
                            {print} _
                            mistakes_made _
                            {if} _ == 10:
                                {print} _
                                {print} _
                                _
                    ```
    hangman_3:
        name: Hangman 3
        default_save_name: Hangman_3
        description: Hangman 3
        levels:
            17:
                story_text: |
                    In a game of hangman the mistakes are shown by drawing a part of the hangman each time a mistake has been made.
                    We now add those drawings with our turtle!

                    ### Exercise
                    ***Create a function that draws the hangman*** Create a function that draws the hangman in 10 steps. We have already made step 1 for you.

                    ***Test the function*** Test the function by calling the function with 10. If you are happy with the function, remove the line that calls the function for now. We will call the function when the player makes a mistake.

                    ***Paste your hangman game under your function*** Go back to the previous tab and copy your hangman game. Paste the game underneath your function.

                    ***Call the function when the player makes a mistake*** Under the line `mistakes_made = mistakes_made + 1` we will call the function. We want the turtle to take the same amount of steps as the player has made mistakes, so we call the function with `mistakes_made` as argument.

                    ***Enjoy your game!***
                    <div class="w-full flex flex-row gap-2">
                        The hangman could look like this <img src="https://github.com/hedyorg/hedy/assets/80678586/d385b691-5701-4342-b5d9-dfae1589c129" width="100">
                    </div>
                example_code: |
                    ```
                    # Create a function that draws the hangman
                    {define} draw_hangman {with} step:
                        {if} step == 1:
                            {color} white
                            {forward} -100
                            {turn} 90
                            {forward} -50
                            {color} black
                            {forward} 100
                            {forward} -50

                        {if} step == 2:
                            _
                    # Paste your hangman game here

                    ```
    harry_potter:
        name: Harry Potter
        default_save_name: Harry Potter
        description: Harry Potter adventures
        levels:
            10:
                story_text: |
                    ### Exercise
                    We can also make a Harry Potter themed fortune teller. Fill in blanks such that 9 lines are printed.
                    **Extra** Change the theme of the fortune teller into something else, such as your favorite book, film or tv show.
                example_code: |
                    ```
                    houses = Gryffindor, Slytherin, Hufflepuff, Ravenclaw
                    subjects = potions, defence against the dark arts, charms, transfiguration
                    fears = Voldemort, spiders, failing your OWL test
                    names = Harry, Ron, Hermione
                    _
                    _ {print} name ' is placed in ' houses {at} {random}
                    _ {print} name ' is great at ' subjects {at} {random}
                    _ {print} name 's greatest fear is ' fears {at} {random}
                    ```
    haunted:
        name: Haunted House
        default_save_name: Haunted House
        description: Escape from the haunted house
        levels:
            1:
                story_text: |
                    In this adventure you are working towards making a game in which you have to escape from a haunted house by picking the correct door.
                    If you pick the right door you'll survive, but if not a terrible monster might...

                    In level 1 we start our haunted house game by making up a scary story and ask the player what monster they'll see in the haunted house.
                example_code: |
                    ```
                    {print} How did I get here?
                    {print} I remember my friend telling me to go into the old mansion...
                    {print} and suddenly everything went black.
                    {print} But how did I end up on the floor...?
                    {print} My head hurts like Ive been hit by a baseball bat!
                    {print} What's that sound?
                    {print} Oh no! I feel like Im not alone in this house!
                    {print} I need to get out of here!
                    {print} There are 3 doors in front of me..
                    {ask} Which door should i pick?
                    {echo} I choose door
                    {print} ...?
                    ```
                story_text_2: |
                    ### Exercise
                    Copy the example code to your input screen by clicking the yellow button.
                    Now finish the story by adding at least 5 lines of code.
                    Remember to start each line of codes with a `{print}` command.
            2:
                story_text: |
                    In this haunted house you can choose your monsters with emojis. Of course you could also use words.
                example_code: |
                    ```
                    monster_1 {is} 👻
                    monster_2 {is} 🤡
                    monster_3 {is} 👶
                    {print} You enter the haunted house.
                    {print} Suddenly you see a monster_1
                    {print} You run into the other room, but a monster_2 is waiting there for you!
                    {print} Oh no! Quickly get to the kitchen.
                    {print} But as you enter monster_3 attacks you!
                    ```
                story_text_2: |
                    ### Exercise
                    In the example above the monsters are predetermined. So each time you run your code, the output is the same.
                    Can you add `{ask}` commands to make the haunted house interactive and have the players choose the monsters they come across?
                example_code_2: |
                    ```
                    monster_1 {is} _
                    monster_2 {is} _
                    monster_3 {is} _
                    {print} You enter the haunted house.
                    {print} Suddenly you see a monster_1
                    {print} You run into the other room, but a monster_2 is waiting there for you!
                    {print} Oh no! Quickly get to the kitchen.
                    {print} But as you enter monster_3 attacks you!
                    ```
            3:
                story_text: |
                    In the previous levels you've made an introduction to your haunted house game, but as you might have noticed the story would always have a dreadful end.
                    In this level you can make your story more interactive by changing the outcome of the game; sometimes you'll get eaten, sometimes you'll escape!
                    Let Hedy decide randomly!
                example_code: |
                    ```
                    _ Escape from the haunted house!
                    _ There are 3 doors in front of you...
                    _ _ _ Which door do you choose?
                    _ You picked door ... choice
                    monsters _ a zombie, a vampire, NOTHING YOUVE ESCAPED
                    _ You see...
                    {sleep}
                    _ _ _ _
                    ```
            4:
                story_text: |
                    In this level you learn how to use quotation marks in your games.

                    ### Exercise
                    Can you make your Haunted House level 4 proof?

                    ### Exercise 2
                    Go back to the previous level and copy your haunted house code. Make the code work in this level by adding quotation marks in the right spots.
                example_code: |
                    ```
                    _ Add quotation marks to this code _
                    {print} Escape from the haunted house!
                    {print} There are 3 doors in front of you...
                    choice {is} {ask} Which door do you choose?
                    {print} You picked door ... choice
                    monsters {is} a zombie, a vampire, NOTHING YOUVE ESCAPED
                    {print} You see...
                    {sleep}
                    {print} monsters {at} {random}
                     ```
            5:
                story_text: |
                    Up until this level the haunted house game always asked the player to choose a door, but as you might have noticed, they didn't really have to answer correctly.
                    If the player filled in a completely random answer, the game would still work and the player might even win (despite not picking a door).
                    In this level you can only win the game by picking the same door Hedy picked randomly.

                    ### Exercise
                    Can you find the 4 missing words to complete the code?
                example_code: |
                    ```
                    {print} 'Escape from the haunted house!'
                    {print} 'There are 3 doors in front of you...'
                    doors {is} 1, 2, 3
                    monsters {is} werewolf, mummy, vampire, zombie
                    chosen_door {is} {ask} 'Which door do you choose?'
                    {print} 'You chose door...' chosen_door
                    {sleep}
                    correct_door {is} doors {at} {random}
                    _ _ _ _ {print} 'Great! Youve escaped!'
                    {else} {print} 'Oh no! You are being eaten by a...' monsters {at} {random}
                    ```
            9:
                story_text: "In this level you can use nesting, which allows you to make the haunted house even more interactive!\n\n### Exercise\nNow it's very hard to win this game, can you make it easier to win?\nChange your code so it only has one wrong door and two correct doors instead of one correct door and two wrong ones? \nTip: This means changing the variable correct_door into wrong_door, and switching the `{if}` and `{else}` code.\nAnd of course you may also change the story and make it your own. Change the monsters or make it a happy game show where you get a gift!\n"
                example_code: |
                    ```
                    {print} 'Escape from the Haunted House!'
                    player = alive
                    doors = 1, 2, 3
                    monsters = zombie, vampire, giant spider
                    {repeat} 3 {times}
                        {if} player {is} alive
                            correct_door {is} doors {at} {random}
                            {print} 'There are 3 doors in front of you...'
                            chosen_door = {ask} 'Which door do you choose?'
                            {if} chosen_door {is} correct_door
                                {print} 'No monsters here!'
                            {else}
                                {print} 'You are eaten by a ' monsters {at} {random}
                                player = dead
                        {else}
                            {print} 'GAME OVER'
                    {if} player {is} alive
                        {print} 'Great! You survived!'
                    ```
            11:
                story_text: "In this level we've changed the `{for}` command so we can tell the player where they are. \n\n### Exercise 1\nFinish the program so the player knows which room they are in.\n\n### Exercise 2\nMake the program into an adventure by following these steps:\n\n1. Make a list of choices (like: fight or flight)\n2. Make sure the player can choose an option with `{ask}`\n3. Is answer correct? Then they may proceed to the next monster. Do they give a wrong answer? Let the player know with a `{print}`. \n\n **(extra)** If you make a wrong choice, a monster is still shown! How could you change that?\n"
                example_code: |
                    ```
                    {print} 'Escape from the Haunted House!'
                    monsters = zombie, vampire, giant spider
                    _
                        {print} 'Room ' i
                        monster = monsters {at} {random}
                    ```
            14:
                story_text: |
                    ### Exercise
                    In this level you can use the `<` and `>` symbol to introduce lives to your game.
                    Make sure the player loses a life when they come across the wrong monster and that the game stops if you have no lives left.
                example_code: |
                    ```
                    {print} 'Escape from the haunted house'
                    lives = 3
                    doors = 1, 2, 3
                    monsters = 'the wicked witch', 'a zombie', 'a sleeping 3 headed dog'
                    {for} i {in} {range} 1 {to} 10
                        {if} lives _
                            good_door = doors {at} {random}
                            monster = monsters {at} {random}
                            chosen_door = {ask} 'Which door do you choose?'
                            {if} good_door == chosen_door
                                {print} 'You have chosen the correct door'
                            {else}
                                {print} 'You see...' monster
                                {if} monster == 'a sleeping 3 headed dog'
                                    {print} 'Pffieuw.... Its asleep'
                                {else}
                                    {print} 'You lose one life'
                                    lives = _
                        {else}
                            {print} 'GAME OVER'
                    ```
            16:
                story_text: |
                    ### Exercise
                    This haunted house game uses the connection between the lists you can use in this level.
                    For example: all the properties that belong to the zombie are first in all the lists, witch second and vampire third.
                    Check out the code and fill in  `weapons[i]`, `monsters[i]` , `bad_fate[i]`, `good_fate[i]`, `hint[i]` on the correct blanks to get the code to work!
                example_code: |
                    ```
                    numbers = [1, 2, 3]
                    i = numbers[{random}]
                    hint = ['growling', 'a cackling laugh', 'fluttering batwings']
                    monsters = ['zombie', 'witch', 'vampire']
                    bad_fate = ['Your brain is eaten', 'You are forever cursed', 'You are bitten']
                    good_fate = ['You throw the ham. The zombie is distracted and starts eating it.', 'You set the curtains on fire. The witch flees out of fear for the fire', 'The vampire hates garlic and flees']
                    weapons = ['ham', 'lighter', 'garlic']
                    {print} 'You are standing in front of an old mansion'
                    {print} 'Something is not right here'
                    {print} 'You hear ' _
                    {print} 'You are going to explore it'
                    {print} 'You enter the kitchen and see a lighter, a raw ham and a garlic.'
                    your_weapon = {ask} 'What do you bring with you?'
                    {print} 'With your ' your_weapon ' you enter the living room'
                    {print} 'There you find a ' _
                    needed_weapon = _
                    {if} your_weapon == needed_weapon
                        {print} 'You use your ' your_weapon
                        {print} _
                        {print} 'YOU WIN!'
                    {else}
                        {print} 'You have chosen the wrong weapon...'
                        {print} _
                        {print} 'GAME OVER'
                    ```
    hotel:
        name: hotel
        default_save_name: hotel
        description: hotel
        levels:
            13:
                story_text: |
                    In the previous adventure you have learned how to use an argument in a function, and you've learned how to combine it with an {ask}.
                    You might have wondered why you would use functions, because the functions in the example were only one line of code.
                    Now we will show you what a bigger function looks like and we will use multiple agruments now as well. You'll see how much better it is to use a function once the function gets bigger.
                    Here is an example of a function with arguments combined with {ask} commands.
                example_code: |
                    ```
                    {define} welcome_message {with} title, last_name, country, room_number
                        {print} 'Welcome to Hotel Hedy, ' title ' ' last_name
                        nice_trip {is} {ask} 'Did you have a nice trip from, ' country '?'
                        {if} nice_trip {is} 'yes'
                            {print} 'Lovely!'
                        {else}
                            {print} 'Sorry to hear that.'
                            {print} 'Hopefully you can take a nice rest in you room.'
                        {print} 'Your room number is ' room_number

                    {print} 'Hello. Please fill in your information to check in.'
                    title = {ask} 'What is your title (mr, mrs, ms, dr, etc.)?'
                    name = {ask} 'What is you last name?'
                    homecountry = {ask} 'What country do you come from?'

                    {call} welcome_message {with} title, name, homecountry, 105
                    ```

                    title = {ask} 'What is your title (mr, mrs, ms, dr, etc.)?'
                    name = {ask} 'What is you last name?'
                    homecountry = {ask} 'What country do you come from?'

                    {call} welcome_message {with} title, name, homecountry, 105
    if_command:
        name: '{if} & {else}'
        default_save_name: if_command
        description: Introducing the if command
        levels:
            5:
                story_text: |
                    ## If... else....
                    In level 5 there is something new, the `{if}`! With the `{if}` you can choose between two different options.
                    This code prints nice if you enter Hedy as a name, and boo! if you enter something else.
                    `{ask}` and `{print}` still work like they did in level 4.
                example_code: |
                    ```
                    name {is} {ask} 'what is your name?'
                    {if} name {is} Hedy {print} 'nice' {else} {print} 'boo!'
                    ```
                story_text_2: |
                    Sometimes code with an `{if}` gets really long and does not fit on the line well. <br> You may also divide the code over two lines, starting the second line at the `{else}` like this:
                example_code_2: |
                    ```
                    name {is} {ask} 'what is your name?'
                    {if} name {is} Hedy {print} 'nice'
                    {else} {print} 'boo!'
                    ```
                story_text_3: |
                    ### Exercise
                    Try to create your own code with `{if}` and `{else}`. You can use the example code if you want.
                example_code_3: |
                    ```
                    answer {is} {ask} '2 + 2 = ?'
                    _ _ _ 4 _ 'Great job!'
                    _ _ 'No 2 + 2 = 4'
                    ```
            8:
                story_text: |
                    ## If... Else...
                    You have learned to repeat a block of lines of code after a `{repeat}` command.
                    Now you can also use indentation to make blocks after a {if} or {else} command.
                    Check out the example code.

                    ### Exercise
                    Add an {else} command to the example code. Make a block of line using indentation. You do this by starting each line with 4 spaces.
                example_code: |
                    ```
                    name = {ask} 'What is your name?'
                    {if} name {is} Hedy
                        {print} 'Welcome Hedy'
                        {print} 'You can play on your computer!'
                    ```
            9:
                story_text: |
                    In this level you can also put an {if} command inside another {if} command.
                example_code: |
                    ```
                    continue = {ask} 'Do you want to continue?'
                    {if} continue = yes
                        sure = {ask} 'Are you sure?'
                        {if} sure {is} yes
                            {print} 'We will continue'
                        {else}
                            {print} 'You are not sure'
                    {else}
                        {print} 'You do not want to continue'
                    ```
    in_command:
        name: '{in}'
        default_save_name: in_command
        description: Introducing the in command
        levels:
            5:
                story_text: |
                    ## Lists
                    When we want to check if something is in a list, we can now use the `{in}` command.
                    This code prints pretty! if you choose green or yellow, and meh otherwise.
                example_code: |
                    ```
                    pretty_colors {is} green, yellow
                    favorite_color {is} {ask} 'What is your favorite color?'
                    {if} favorite_color {in} pretty_colors {print} 'pretty!'
                    {else} {print} 'meh'
                    ```
                story_text_2: |
                    ### Exercise
                    Finish the example code by filling in the blanks with commands that you've learned.
                    When you've finished the code, try to create a code of your own and use a question that you've thought of yourself.
                example_code_2: |
                    ```
                    animals is dog, cow, sheep
                    answer is ask 'What is your favorite animal?'
                    _ answer _ animals _ 'Mine too!'
                    _ _ 'My favorite animals are dogs, cows and sheep'
                    ```
    is_command:
        name: '{is}'
        default_save_name: is_command
        description: introducing is command
        levels:
            2:
                story_text: |
                    ## Variables
                    You can name a word with `{is}`. This is called a **variable**. In this example we made a variable called name and a variable called age. You can use the word name anywhere in your code and it will be replaced by Hedy, like this:
                example_code: |
                    ```
                    name {is} Hedy
                    age {is} 15
                    {print} name is age years old
                    ```
                story_text_2: |
                    ### Exercise
                    Time to make your own variables!
                    In the example code we made an example of the variable `favorite_animals`. In line 1 the variable is set, and in line 2 we haved used the variable in a print command.
                    Firstly, finish our example by filling in your favorite animal in the blanks. Then make at least 3 of these codes yourself. Pick a variable, and set the variable with the {is} command. Then use it with a {print} command, just like we did.
                example_code_2: |
                    ```
                    favorite_animals is _
                    {print} I like favorite_animals
                    ```
            6:
                story_text: |
                    We also make a change in storing a word in a variable! You may now use `=` instead of  `{is}` when we store a name or a number in a variable, like this:
                example_code: |
                    ```
                    name = Hedy
                    answer = 20 + 4
                    ```
            14:
                story_text: |
                    We are going to learn more new items. You might know them already from mathematics, the `<` and `>`.
                    The `<` checks if the first number is smaller than the second, for example age `<` 12 checks if age is smaller than 12.
                    If you want to check if the first number is smaller or equal to the second, you can use `<=`, for example age `<=` 11.
                    The `>` checks if the first number is bigger than the second, for example points `>` 10 checks if points is larger than 10.
                    If you want to check if the first number is bigger or equal to the second, you can use `>=`, for example points `>=` 11.
                    You use these comparisons in an `{if}`, like this:
                example_code: |
                    ```
                    age = {ask} 'How old are you?'
                    {if} age > 12
                        {print} 'You are older than I am!'
                    ```
                story_text_2: |
                    From this level on, if you want to compare exactly, you can use two equal signs. This is what most programming languages do:
                example_code_2: |
                    ```
                    name = {ask} 'What is your name?'
                    {if} name == 'Hedy'
                        {print} 'You are cool!'
                    ```
                story_text_3: |
                    You can also compare if something is *not* equal to something else using `!=` like this:
                example_code_3: |
                    ```
                    name = {ask} 'What is your name?'
                    {if} name != 'Hedy'
                        {print} 'You are not Hedy'
                    ```

                    {if} age < 13
                        {print} 'You are younger than me!'
                    {else}
                        {print} 'You are older than me!'
    language:
        name: Language
        default_save_name: Language
        description: Practice words in a foreign language
        levels:
            5:
                story_text: |
                    Make your own program to practice your vocabulary in a new language.

                    ### Exercise
                    Can you make this program for a different language? Or can you add more words to the French one?
                example_code: |
                    ```
                    {print} 'Learn French!'
                    cat {is} {ask} '🐱'
                    {if} cat {is} chat {print} 'Terrific!'
                    {else} {print} 'No, cat is chat'
                    frog {is} {ask} '🐸'
                    {if} frog {is} grenouille {print} 'Super!'
                    {else} {print} 'No, frog is grenouille'
                    ```
            16:
                story_text: |
                    ### Exercise
                    Take a look at the example code. This is a program to practise French vocabulary. Now make your own program to practice your vocabulary in a new language.
                    If you don't know any other languages, you can use Google translate or you can use emojis and your native language.
                example_code: |
                    ```
                    french_words = ['bonjour', 'ordinateur', 'pomme de terre']
                    translation = ['hello', 'computer', 'potato']
                    score = 0
                    {for} i {in} {range} 1 {to} 3
                        answer = {ask} 'What does ' french_words[i] ' mean?'
                        correct = translation[i]
                        {if} answer == correct
                            {print} 'Correct!'
                            score = score + 1
                        {else}
                            {print} 'Wrong, ' french_words[i] ' means ' translation[i]
                    {print} 'You gave ' score ' correct answers.'
                    ```
    maths:
        name: maths
        default_save_name: maths
        description: Introducing maths
        levels:
            6:
                story_text: |
                    In this level you learn something new: you can now also calculate.

                    The plus is easy, you write it like with math: `5 + 5` for example. The minus also works fine, it is `5 - 5`.

                    The times is a bit different, because there is no times symbol on your keyboard. Just search, there really isn't!
                    That is why we multiply with the asterisk above 8: `5 * 5`. Read that as "5 times 5" that helps you remember it best.
                example_code: |
                    ```
                    {print} '5 plus 5 is ' 5 + 5
                    {print} '5 minus 5 is ' 5 - 5
                    {print} '5 times 5 is ' 5 * 5
                    ```
            12:
                story_text: |-
                    **Decimal numbers**
                    So far, Hedy did not allow for decimal numbers like 1.5, but now we do allow that. Note that computers use the `.` for decimal numbers.
                example_code: |
                    ```
                    {print} 'Two and a half plus two and a half is...'
                    {print} 2.5 + 2.5
                    ```
                story_text_2: |-
                    **Maths with words**
                    In this level you can also do addition with words like this:
                example_code_2: |
                    ```
                    a = 'Hello '
                    b = 'world!'
                    {print} a + b
                    ```

                    {print} 2.5 + 2.5
    music:
        name: music
        default_save_name: music
        description: Play a tune!
        levels:
            1:
                story_text: |-
                    In this level you'll learn how to use the `{play}` command to play a tune!

                    Type `{play}` followed by the note you want to play. The scale goes C-D-E-F-G-A-B.
                    As you can see there are 7 different letters, but we can play more than just 7 notes.
                    Type a number between 1 and 10 behind the letter to choose the scale, for example after B4 comes C5.
                    C1 is the lowest note you can play, C10 is the highest.

                    ### Exercise
                    Try out the example code and then play around with it! Can you create your own melody?
                    In the next level you'll learn how to play some existing songs.
                example_code: |-
                    ```
                    play C4
                    play D4
                    play E4
                    play F4
                    play G4
                    play A4
                    play B4
                    play C5
                    ```
            2:
                story_text: |
                    ### Exercise
                    Finish the songs! We have started the codes for some melodies.
                example_code: |
                    ```
                    {print} Old Mac Donald had a farm
                    {play} C5
                    {play} C5
                    {play} C5
                    {play} G4
                    {play} A4
                    {play} A4
                    {play} G4
                    ```
                story_text_2: As you can see, you can also use the `{sleep}` command to add a little pause in the song.
                example_code_2: |
                    ```
                    {print} Twinkle Twinkle Little Star
                    {play} C
                    {play} C
                    {play} G
                    {play} G
                    {play} A
                    {play} A
                    {play} G
                    {sleep} 1
                    {play} F
                    {play} F
                    ```
            3:
                story_text: |
                    Create a random melody!

                    ### Exercise
                    The example code creates a random melody, but it's very short and not many notes are used.
                    Add more notes to the list and create a longer melody by copying the last line a couple more times.
                example_code: |
                    ```
                    notes {is} A4, B4, C4
                    {play} notes {at} {random}
                    {play} notes {at} {random}
                    {play} notes {at} {random}
                    ```
            4:
                story_text: |
                    Use the `{clear}` command to create a karaoke machine!

                    ### Exercise
                    Finish the karaoke version of 'Mary had a little lamb'.
                    Then, create a karaoke version of any song you'd like!
                example_code: |
                    ```
                    {print} 'Mary had a little lamb'
                    {play} E
                    {play} D
                    {play} C
                    {play} D
                    {play} E
                    {play} E
                    {play} E
                    {clear}
                    {print} 'Little lamb, little lamb'
                    {play} D
                    {play} D
                    {play} D
                    {play} E
                    {play} E
                    {play} E
                    {clear}
                    {print} 'Mary had a little lamb'
                    {play} E
                    ```
            5:
                story_text: |
                    You don't always have to use the `{play}` command to play a whole song, sometimes you just want to play one note.
                    For example, if you want to make a quiz, you can play a happy high note if the answer is right and a sad low note if the answer is wrong.

                    ### Exercise
                    Finish the first question by adding a line of code that plays a C3 note if the wrong answer is given.
                    Then think of 3 more questions to add to this quiz.
                example_code: |
                    ```
                    answer {is} {ask} 'What is the capital of Zimbabwe?'
                    {if} answer {is} Harare {play} C6
                    _
                    ```
            6:
                story_text: "Instead of playing notes, you can also play numbers now. Simply type `{play} 1` for the lowest note, `{play} 70` for the highest note, or anything in between.\n\n### Exercise\n This calls for musical maths! Try out the example code a couple of times with different starting numbers. \nThen, see if you can compose a song using the numbers.\n"
                example_code: |
                    ```
                    number = {ask} 'Say a starting number between 1 and 67'
                    {print} number
                    {play} number
                    number = number + 1
                    {print} number
                    {play} number
                    number = number + 1
                    {print} number
                    {play} number
                    ```
            7:
                story_text: |
                    Using the `{repeat}` command can make your codes for melodies a lot shorter!

                    ### Exercise
                    Finish the code for Twinkle Twinkle Little Star by using the `{repeat}`command.
                    Then go back to the songs you've made in the previous levels. Can you shorten those codes too?
                example_code: |
                    ```
                    {print} 'Twinkle Twinkle Little Star'
                    {repeat} 2 {times} {play} C4
                    {repeat} 2 {times} {play} G4
                    _
                    ```
            8:
                story_text: |
                    Now that we can use the `{repeat}` command for multiple lines, we can make songs even more easily!

                    ### Exercise
                    Finish the song of Brother John (Frère Jacques). Don't forget to use `{repeat}`!
                example_code: |
                    ```
                    {print} 'Brother John'
                    {repeat} 2 {times}
                        {play} C
                        {play} D
                        {play} E
                        {play} C
                    {repeat} 2 {times}
                        {play} E
                        {play} F
                        {play} G
                        {sleep} 1
                    ```
            9:
                story_text: |
                    From this level on you can - among other things - use a {repeat} command inside a {repeat} command.
                    That makes songs like 'Happy birthday' even shorter!

                    ### Exercise
                    Finish the song!
                example_code: |
                    ```
                    first_time = yes
                    {repeat} 2 {times}
                        {repeat} 2 {times}
                            {play} C
                        {play} D
                        {play} C
                        {if} first_time {is} yes
                            {play} F
                            {play} E
                            first_time {is} no
                        {else}
                            _
                    ```
            12:
                story_text: |
                    Use functions in your songs! As you can see in the example code, you can make a function for each line of Twinkle Twinkle Little Star. Once you've programmed the first three lines, all you have to do is call the functions in the order you want them played in.

                    ### Exercise
                    Finish the song of Twinkle Twinkle Little Star.
                    Then look back at all the songs you've programmed in the levels before, can you make those codes better and shorter using functions too?
                example_code: |
                    ```
                    {define} first_line
                        {play} C
                        {play} C
                        {play} G
                        {play} G
                        {play} A
                        {play} A
                        {play} G
                        {sleep}

                    {define} second_line
                        {play} F
                        {play} F
                        {play} E
                        {play} E
                        {play} D
                        {play} D
                        {play} C
                        {sleep}

                    {define} third_line
                        {play} G
                        {play} G
                        {play} F
                        {play} F
                        {play} E
                        {play} E
                        {play} D
                        {sleep}

                    {call} _
                    {call} _
                    {call} _
                    {call} _
                    {call} _
                    {call} _
                    ```
            13:
                story_text: |
                    You can use a function with an argument for songs that have line that are almost the same, but slightly different each time.
                    One example is the song 'Yankee Doodle'. The first 4 notes of the first lines are the same, but each time they are followed by a different couple of notes.

                    ### Exercise
                    Can you finish the song of Yankee Doodle?
                    Can you think of another song to program this way?
                example_code: |
                    ```
                    {print} 'Yankee Doodle'
                    {define} _ {with} note_1, note_2, note_3
                        {play} C4
                        {play} C4
                        {play} D4
                        {play} E4
                        {play} _
                        {play} _
                        {play} _

                    {call} line_1 {with} 29, 31, 30
                    {call} line_1 {with} 29, 28, 0
                    {call} line_1 {with} 32, 31, 30

                    {play} C4
                    {play} B3
                    {play} G3
                    {play} A3
                    {play} B3
                    {play} C4
                    {play} C4
                    ```
            14:
                story_text: |
                    You can program music for fun, but you can also use the musical notes to make something useful like a fire alarm!

                    ### Exercise
                    Make sure the fire alarm rings when there is a fire!
                example_code: |
                    ```
                    {define} fire_alarm
                        {print} 'FIRE!'
                        note = 40
                        {for} i {in} {range} 1 {to} 100
                            {if} note _ 50
                                note = note + 5
                                {play} _
                            {else}
                                note = 40

                    fire = {ask} 'Is there a fire?'
                    {if} fire _ 'yes'
                        {call} fire_alarm
                    ```
            15:
                story_text: |
                    **Warning** This adventure can become extremely annoying!
                    We can also use the {while} command to repeat a song forever.

                    ### Exercise
                    Finish the never-ending song.
                example_code: |
                    ```
                    {define} song
                        {play} _

                    yes_or_no = {ask} 'Do you want to hear my never-ending song?'
                    {while} yes_or_no = 'yes'
                        {call} song
                        {print} '🥳'
                    ```
            16:
                story_text: |
                    Upgrade your Old MacDonald code!

                    ### Exercise
                    Take your code from the 'Sing a Song' adventure and add musical notes to it!
                    You can make a function for each line in the song and call that function after the line is printed.
                    We defined the first line for you and called it in the code. Can you finish the whole song?
                example_code: |
                    ```
                    {define} line_1
                        {for} i {in} {range} 1 {to} 3
                            {play} G
                        {play} D
                        {for} i {in} {range} 1 {to} 2
                            {play} E
                        {play} D

                    animals = ['pig', 'dog', 'cow']
                    sounds = ['oink', 'woof', 'moo']
                    for i in range 1 to 3
                        animal = animals[i]
                        sound = sounds[i]
                        print 'Old MacDonald had a farm'
                        call line_1
                        print 'E I E I O!'
                        _
                    ```
            17:
                story_text: |
                    You can use the {elif} to create different options.

                    ### Exercise
                    Firstly, add colons to get the code to work.
                    Then finish this code by adding at least 2 other songs for other moods. For example a happy song and an angry song.
                example_code: |
                    ```
                    {define} scary_song
                        {for} i {in} {range} 1 {to} 3
                            {play} G
                        {play} E
                        {sleep} 2
                        {for} i {in} {range} 1 {to} 3
                            {play} F
                        {play} D

                    mood = {ask} 'Which emotion are you feeling?'
                    {if} mood {is} 'fear'
                        {call} scary_song
                    {elif} _
                    ```
            18:
                story_text: |
                    ### Exercise
                    Even in this last level of Hedy we can make some music! Be careful of all the syntax that is needed now.
                    Take a good look at how the functions are defined and called upon in the example code.
                    Finish the song!
                example_code: |
                    ```
                    {def} line_1():
                        {for} i {in} {range}(1, 5):
                            {play} A
                        {play} D
                        {play} F
                        {play} A

                    {def} line_2():
                        {for} i {in} {range}(1, 5):
                            {play} G
                        {play} C
                        {play} E
                        {play} G

                    {def} line_3():
                    _

                    {print} ('The drunken sailor')
                    {print} ('What shall we do with the drunken sailor?')
                    line_1()
                    line_2()
                    line_3()
                    {print} ('Early in the morning')
                    ```
    parrot:
        name: Parrot
        default_save_name: Parrot
        description: Create your own online pet parrot that will copy you!
        levels:
            1:
                story_text: |
                    Create your own online pet parrot that will copy you!
                example_code: |
                    ```
                    {print} Im Hedy the parrot
                    {ask} whats your name?
                    {echo}
                    {echo}
                    ```
                story_text_2: |
                    ### Exercise
                    Can you make the parrot ask a different question? Fill in the blanks in the example!
                example_code_2: |
                    ```
                    {print} Im Hedy the parrot
                    {ask} _
                    {echo}
                    {echo}
            2:
                story_text: |
                    Create your own online pet parrot that will copy you!
                example_code: |
                    ```
                    {print} Im Hedy the parrot
                    name {is} {ask} whats your name?
                    {print} name
                    {sleep}
                    {print} squawk
                    {sleep}
                    {print} name
                    ```
                story_text_2: |
                    ### Exercise
                    You can use variables to make the parrot say more than only your name. Can you complete this code?
            3:
                story_text: |
                    Teach your parrot a new word with `{add}`.
                    ### Exercise
                    How can you make your parrot say multiple words?
                example_code: |
                    ```
                    words {is} squawk, Hedy
                    {print} Train your parrot!
                    new_word {is} {ask} Which word do you want to teach them?
                    {add} new_word {to_list} words
                    {print} 🧒 Say new_word, Hedy!
                    {print} 🦜 words {at} {random}
                    ```
            4:
                story_text: |
                    In this level we have to use quotation marks with the commands `{ask}` and `{print}`.
                    Can you complete the code by adding quotation marks?
                example_code: |
                    ```
                    words {is} squawk, Hedy
                    {print} _ Train your parrot! _
                    new_word {is} {ask} _ Which word do you want to teach them? _
                    {add} new_word {to_list} words
                    {print} _ 🧒 Say _ new_word _, Hedy!_
                    {print} _ 🦜 _ words {at} {random}
                    ```
            5:
                story_text: |
                    Reward your parrot if it says the correct word!
                    Finish the code by filling in the 4 missing commands.
                example_code: |
                    ```
                    words {is} squawk, Hedy
                    {print} 'Train your parrot!'
                    new_word {is} {ask} 'Which word do you want to teach them?'
                    {add} new_word {to_list} words
                    said_word {is} words {at} {random}
                    {print} '🧒 Say ' new_word ', Hedy!'
                    {print} '🦜 ' said_word
                    _ said_word {is} new_word _ '🧒 Great job, Hedy! 🍪'
                    _ _ '🧒 No, Hedy! Say ' new_word
                    ```
    piggybank:
        name: Piggy Bank
        default_save_name: Piggy Bank
        description: Count your pocketmoney!
        levels:
            12:
                story_text: |
                    In this adventure you learn how to make a digital piggy bank.

                    ### Exercise
                    Finish the code to calculate how much money you have and how long you need to save up to buy what you want!
                    **(extra)** Maybe you have already saved some money? Deduct that from the amount you will have to save up.
                example_code: |
                    ```
                    {print} 'The digital piggy bank'
                    wish = {ask} 'What would you like to buy?'
                    price = {ask} 'How much does that cost?'
                    saved = {ask} 'How much money have you saved already?'
                    allowance = {ask} 'How much pocket money do you get per week?'
                    to_save = price - saved
                    weeks = to_save / allowance
                    {print} 'You can buy a ' _ ' in ' _ ' weeks.'
                    ```
            14:
                story_text: |
                    ### Exercise
                    In this level you can let Hedy tell you if you have saved up enough money!
                    Finish this code by filling in the blanks!
                example_code: |
                    ```
                    _ calculate_budget with wish, money, allowance
                        to_save = wish - money
                        weeks = to_save / allowance
                        {if} wish _ money
                            {print} 'You need to save up some more!'
                            {print} 'Youll need ' weeks ' more weeks.'
                        {else}
                            {print} 'Great! You have enough'
                            {print} 'Lets go shopping!'

                    money = {ask} 'How much money have you saved?'
                    wish = {ask} 'How much money do you need?'
                    allowance = {ask} 'How much pocket money do you get each week?'

                    {call} calculate_budget with _, _, _
                    ```
    pressit:
        name: Key presses
        default_save_name: Pressed
        description: Try linking a keyboard key to a command!
        levels:
            5:
                story_text: |
                    In this level there is another new keyword: `{pressed}`!
                    With `{pressed}` you can use keys on your keyboard to control what lines are used.

                    ### Exercise
                    Look at the example and add one more line of code that reacts to a key press.
                example_code: |
                    ```
                    {print} 'Do you want a good (g) or bad (b) ending?'
                    {if} g {is} {pressed} {print} 'They lived happily ever after ❤'
                    {else} {print} 'The prince was eaten by a hippopotamus 😭'
                    ```
                story_text_2: |
                    You can also link turtle commands to keys.

                    ### Exercise
                    Copy the lines a few times so you can create a larger drawing.
                example_code_2: |
                    ```
                    {if} y {is} {pressed} {forward} 15
                    {else} {turn} 90
                    ```
            7:
                story_text: |
                    Now that you have learned about `{repeat}`, we can press keys multiple times.
                    You can use it to make the turtle walk forward and turn.

                    ### Exercise
                    The code you have seen in level 5 only checks the key once. Copy the example code and add a `{repeat}` to it, so that you can press the keys many times.
                    Use this code to draw something nice.
                example_code: |
                    ```
                    {if} x {is} {pressed} {forward} 15 {else} {turn} 90
                    ```
            9:
                story_text: |
                    Now that you know how to combine statements, you can create a touch type tool with `{pressed}`.

                    ### Exercise
                    Finish the code. Each time a random letter should be chosen, which you have to press. You get a point for a correct press, and and two points deduction for a wrong press.
                    **(extra)** Clear the screen after each letter, and show the user how many points they have scored.
                example_code: |
                    ```
                    points = 0
                    letters = a, b, c, d, e
                    {repeat} 10 {times}
                        letter = _ _ _
                        {print} 'Press the letter ' letter
                        {if} letter {is} {pressed}
                        _
                        _
                        _
                    ```
    print_command:
        name: '{print}'
        default_save_name: print
        description: Introduction print command
        levels:
            1:
                story_text: |
                    ## The print command
                    You can print text to the screen using the `{print}` command.
                example_code: |
                    ```
                    {print} Hi there, programmer!
                    {print} Welcome to Hedy!
                    ```
                story_text_2: |
                    ### Exercise
                    In Hedy you will find exercises in every adventure. An exercise allows you to practise the new commands and concepts, and lets you give your own twist to the example codes.
                    In this exercise you will see a pink blank space. You have to fill something in the place of the blank space before the code can be run.

                    Fill in the `{print}` command in the blank space and then add five more lines of code. Each line has to start with a `{print}` command.
                    Have fun!
                example_code_2: |
                    ```
                    _ Hello!
                    ```
            18:
                story_text: |-
                    We arrived at real Python code! That means we need to use parentheses with `{print}` and `{range}` from now on.
                    It also means you can use Hedy code from this level in any Python environment as long as you use the English commands. If you haven't until now, you can switch the toggle in the commands menu to do so.
                example_code: |
                    ```
                    {print}('Hello!')
                    {for} i {in} {range}(1, 10):
                        {print}('This is line ', i)
                    ```
                story_text_2: If you want to print more than one item, you need to separate them by commas.
                example_code_2: |
                    ```
                    temperature = 25
                    {print}('It is ', temperature, ' degrees outside')
                    ```

                    {print}('My name is ', name)
    quizmaster:
        name: Quizmaster
        default_save_name: Quizmaster
        description: Make your own quiz!
        levels:
            14:
                story_text: |
                    ### Exercise
                    In this adventure you can make your own quiz! Fill in the blanks, add more questions and enjoy your own quiz!
                    You can make a quiz about anything you like: your hobby, your favorite animal, your favorite book or anything at all!
                example_code: |
                    ```
                    {print} 'Make your own quiz'
                    points_a = 0
                    points_b = 0
                    {print} 'Question'
                    {print} 'Answer option A'
                    {print} 'Answer option B'
                    answer = {ask} 'Which answer?'
                    {if} answer == 'A'
                        points_a = points_a + 1
                    {if} answer == 'B'
                        points_b = points_b + 1
                    {print} 'End of the quiz!'
                    {print} 'Lets see the results!'
                    {if} points_a > points_b
                        {print} 'You belong to the A club'
                    {if} points_b > points_a
                        {print} 'You belong to the B club'
                    ```
    quotation_marks:
        name: '''quotation marks'''
        default_save_name: quotation_marks
        description: Introduction quotation marks
        levels:
            4:
                story_text: |
                    ## 'Quotation marks'
                    In level 4 `{ask}` and `{print}` have changed.
                    You must put text that you want to print between quotation marks.
                    This is useful, because now you can print all the words you want. Also the words you used to store something with `{is}`.
                    Most programming languages also use quotation marks when printing, so we are also getting a step closer to real programming!
                example_code: |
                    ```
                    {print} 'You need to use quotation marks from now on!'
                    answer {is} {ask} 'What do we need to use from now on?'
                    {print} 'We need to use ' answer
                    ```
                story_text_2: |
                    ## Contractions
                    Important! Mind that now that we're using quotation marks, Hedy will get confused when you use the apostrophe for contractions like I'm or What's.
                    Make sure to remove those apostrophes and change the spelling to I am or What is.
                    Check out the example code to see the wrong way of using apostrophes.
                example_code_2: |
                    ```
                    _ This is the wrong way of using apostrophes _
                    {print} 'I'm babysitting my sister's kids'
                    {print} 'What's more fun than that?'
                    ```
            12:
                story_text: |
                    **All texts need to be in quotation marks**
                    For this level on you will also have to use quotation marks when storing a text with `=`:
                example_code: |
                    ```
                    name = 'Hedy the Robot'
                    {print} 'Hello ' name
                    ```
                story_text_2: |
                    **All items in lists need quotation marks too**
                    Lists are texts, so they need quotation marks too. Mind that each single item on the list has quotation marks.
                    This allows you to save two words as 1 item on the list, for example 'Black Widow'.
                example_code_2: |
                    ```
                    superheroes = 'Spiderman', 'Batman', 'Black Widow'
                    {print} superheroes {at} {random}
                    ```
                story_text_3: |
                    **All text after `{if}` comparisons need quotation marks too**
                example_code_3: |
                    ```
                    name = {ask} 'What is your name?'
                    {if} name = 'Hedy the Robot'
                        {print} 'Hi there!'
                    ```
                story_text_4: |
                    **Numbers don't need quotation marks**
                    For numbers, you do not use quotation marks in the `=`:
                example_code_4: |
                    ```
                    score = 25
                    {print} 'You got ' score
                    ```
    random_command:
        name: '{random}'
        default_save_name: random_command
        description: introducing at random command
        levels:
            3:
                story_text: |
                    ## At random
                    In this level you can make a list using the `{is}` command. You can let the computer choose a random item from that list. You do that with `{at} {random}`.
                example_code: |
                    ```
                    animals {is} dogs, cats, kangaroos
                    {print} animals {at} {random}
                    ```
                story_text_2: |
                    You can use the `{at} {random}` command in a sentence as well.
                example_code_2: |
                    ```
                    food {is} sandwich, slice of pizza, salad, burrito
                    {print} I am going to have a food {at} {random} for lunch.
                    ```
                story_text_3: |
                    ### Exercise
                    Try out the `{at} {random}` command by making your own gameshow (like the ones on tv) where you choose a door or suitcase and it contains a big price!
                    Can you do it? We have already put the first lines into the example code.
                example_code_3: |
                    ```
                    {print} The big gameshow!
                    {print} There are 3 suitcases in front of you...
                    chosen {is} {ask} Which suitcase do you choose?
                    prices {is} _
                    _
                    ```
            16:
                story_text: |-
                    We are going to make lists the Python way, with square brackets around the lists! We also keep the quotation marks around each item like we have learned in previous levels.
                    We use square brackets to point out a place in a list. For example: `friends[1]` is the first name on the list of friends, as you can see in the first part of the example code. The second part of the example code shows you that we can also match 2 lists using the variable i.
                example_code: |
                    ```
                    friends = ['Ahmed', 'Ben', 'Cayden']
                    {print} friends[1] ' is the first friend on the list.'
                    {print} friends[2] ' is the second friend on the list.'
                    {print} friends[3] ' is the third friend on the list.'
                    #now we will match 2 lists using the variable i
                    lucky_numbers = [15, 18, 6]
                    {for} i {in} {range} 1 {to} 3
                        {print} friends[i] 's lucky number is ' lucky_numbers[i]
                    ```
                story_text_2: |-
                    Now that you've learned to use the brackets in lists, you can also start using the {at} {random} command in the Python way!
                    You simply type the name of your list with `[random]` behind it!
                example_code_2: |-
                    ```
                    fruit = ['apple', 'banana', 'cherry']
                    {print} fruit[random]
                    ```
    repeat_command:
        name: '{repeat}'
        default_save_name: repeat_command
        description: repeat command
        levels:
            7:
                story_text: |
                    ## Repeat! Repeat! Repeat!
                    Level 7 adds the `{repeat}` command.  `{repeat}` can be used to execute one line of code multiple times. Like this:

                    ### Exercise
                    Play around with the repeat command. Can you make the happy birthday song in only 3 lines of code instead of 4 now?
                example_code: |
                    ```
                    {repeat} 3 {times} {print} 'Hedy is fun!'
                    ```
            8:
                story_text: |
                    ### Repeat commands and indentation
                    In this level you can repeat multiple lines of code with only 1 repeat command.
                    You do this by making a block of lines that you want to repeat.
                    The lines in this block will need **indentation** .
                    That means putting four spaces at the beginning of each line. You will also have to indent when you just want to create a block of one line.
                example_code: |
                    ```
                    {repeat} 5 {times}
                        {print} 'Hello everyone'
                        {print} 'This is all repeated 5 times'
                    ```
            9:
                story_text: |
                    Great job! You've reached another new level! In the previous level you've learned to use multiple lines of code in an {if} or {repeat} command. But you can't yet combine the two...
                    Good news! In this level you will be allowed to put an {if} inside an {if}, or inside a {repeat} command. Putting a block of code inside another block of code is called nesting.                     ``` Putting a block of code inside another block of code is called nesting.
                example_code: |
                    ```
                    answer = {ask} 'Are you ready to learn something new?'
                    {if} answer {is} yes
                        {print} 'Great! You can learn to use the repeat command in the if command!'
                        {print} 'Hooray!'
                        {print} 'Hooray!'
                        {print} 'Hooray!'
                    {else}
                        {print} 'Maybe you should practice some more in the previous level'
    repeat_command_2:
        name: '{repeat} 2'
        default_save_name: repeat_command_2
        description: repeat command 2
        levels:
            7:
                story_text: |
                    ## Repeat with other commands and with variables
                    You have practiced the `{repeat}` command in combination with the `{print}` command now, but did you know you could also use other commands with `{repeat}` ?
                    In this example code you can see that `{repeat}` can also be used with an `{ask}`, `{if}` or `{else}` command.
                example_code: |
                    ```
                    {repeat} 2 {times} answer = {ask} 'Did you know you could ask a question multiple times?'
                    {if} answer {is} yes {repeat} 2 {times} {print} 'You knew that already!'
                    {else} {repeat} 3 {times} {print} 'You have learned something new!'
                    ```
                story_text_2: |
                    Another interesting thing you can so with the `{repeat}` command is using variables to set the amount of times something should be repeated. In the example code you can see that we first ask the person how old they are.
                    Then, in line 3, the question is repeated 'age' times. So we have used the variable 'age' with the `{repeat}` command.
                example_code_2: |
                    ```
                    {print} 'Yay! It is your birthday!'
                    age = {ask} 'How old are you now?'
                    {repeat} age {times} {print} 'Hip Hip Hurray!'
                    ```
            8:
                story_text: |
                    ### In the block or not?
                    In this level you have to think carefully which lines of code should be in the block and which shouldn't.
                    For example: If you want to sing the song *the muffin man*. You only want the line with 'the muffin man' to be repeated twice.
                    This means the last line shouldn't start with indentation as it doesn't belong to the block.
                    If you do start the last line with indentation the song will turn out wrong.

                    ### Exercise
                    Each line in the example code starts with a blank. Remove the blanks and try to figure out which line need indentation and which don't to make the muffin man song.
                example_code: |
                    ```
                    _ {print} 'Do you know the muffin man?'
                    _ {repeat} 2 {times}
                    _ {print} 'The muffin man'
                    _ {print} 'Do you know the muffin man, who lives on Drury Lane?'
                    ```
    restaurant:
        name: Restaurant
        default_save_name: Restaurant
        description: Create your own virtual restaurant
        levels:
            1:
                story_text: |
                    In level 1 you can make your own virtual restaurant and take your guests' orders.
                story_text_2: |
                    ### Exercise
                    Copy the example code into your input screen by clicking the yellow button.
                    Firstly, fill in the correct command on the blanks to make to code work properly.
                    Then add at least 4 more lines of code to the restaurant program.
                    Ask the costumer what they would like to drink and ask if they want to pay with cash or card.
                    Lastly, think of a nice way to say goodbye to your costumer.
                example_code_2: |
                    ```
                    {print} Welcome to Hedy's restaurant 🍟
                    _ What would you like to order?
                    {echo} So you would like to order
                    {print} Thank you for your order!
                    {print} It's on its way!
                    ```
            2:
                story_text: |
                    In level 2 you could expand your restaurant by using variables. In level 1 Hedy could only `{echo}` the order once and only remember the last thing that was ordered.
                    Now you can use variables and Hedy can remember both the food and the toppings!
                example_code: |
                    ```
                    {print} Welcome to Hedy's restaurant!
                    {print} Today we're serving pizza or lasagna.
                    food {is} {ask} What would you like to eat?
                    {print} Great choice! The food is my favorite!
                    topping {is} {ask} Would you like meat or veggies on that?
                    {print} food with topping is on its way!
                    ```
                story_text_2: |
                    ### Exercise
                    Copy your own restaurant code from to previous level to the input screen below.
                    Fix the code by replacing the `{ask}` and `{echo}` commands and using variables, like you've learned in this level.

                    Now that your code is working again, it's time to add something more.
                    Look at the last line of the example code: `{print} food with topping is on its way!`
                    In this single line 2 variables have been used to create a summary of the order.
                    Now add your own summary of the food and drinks ordered by the customer.

                    **Extra** Now that you've learned how to use variables, you can use as many variables in one line as you'd like. Can you add more variables to your code, like eat in or take-away, cash or card, with or without a straw etc.?
            3:
                story_text: |
                    Having trouble to decide what you wanna have for dinner? You can let Hedy choose for you!
                    Simply add lists of your favorite (or least favorite) meals and Hedy can randomly choose your dinner.
                    You can also have a bit of fun, by letting Hedy choose the price for your dinner as well! What will you get?
                example_code: |
                    ```
                    dishes {is} spaghetti, brussels sprouts, hamburgers
                    {print} You will have dishes {at} {random} tonight!
                    prices {is} 1 euro, 10 euros, 100 euros
                    {print} That will be prices {at} {random} please.
                    ```
                story_text_2: |
                    ### Exercise
                    Now make your own version of the random restaurant.
                    Make a list of starts, mains, desserts, drinks and prices yourself.
                    Then use `{print}` and `{at} {random}` commands to tell the costumer what will be on their menu tonight.
                example_code_2: |
                    ```
                    {print} Welcome to your own random restaurant!
                    starters {is} _
                    mains {is} _
                    desserts {is} _
                    drinks {is} _
                    prices {is} _
                    _
                    ```
            4:
                story_text: |
                    ### Exercise
                    Add the quotation marks to this code to make it work! Be careful: variables should not be in quotation marks.

                    ### Exercise 2
                    Go back to the previous level and copy your restaurant code. Make the code work in this level by adding quotation marks in the right spots.
                example_code: |
                    ```
                    _ Add the quotation marks to this code _
                    {print} Welcome to Restaurant Chez Hedy!
                    {print} Today we are serving pizza or lasagna.
                    food {is} {ask} What would you like to eat?
                    {print} Great choice! The  food  is my favorite!
                    topping {is} {ask} Would you like meat or veggies on that?
                    {print} food  with  topping  is on its way!
                    drinks {is} {ask} What would you like to drink with that?
                    {print} Thank you for your order.
                    {print} Your  food  and  drinks  will be right there!
                    ```
            5:
                story_text: |
                    In this level the `{if}` command allows you to `{ask}` your customers questions and give different responses to the answers.
                    In the example below, you see that you can `{ask}` the customer `{if}` they want to hear the specials and Hedy can respond accordingly.
                example_code: |
                    ```
                    {print} 'Welcome to Restaurant Chez Hedy!'
                    special {is} {ask} 'Would you like to hear our specials today?'
                    {if} special {is} yes {print} 'Todays special is chicken piri piri and rice.' {else} {print} 'No problem.'
                    food {is} {ask} 'What would you like to eat?'
                    {print} 'One ' food ', coming right up!'
                    drink {is} {ask} 'What would you like to drink with that?'
                    {if} drink {is} cola {print} 'Im sorry, we are out of cola!' {else} {print} 'Great choice!'
                    anything {is} {ask} 'Would you like anything else?'
                    {print} 'Let me repeat your order...'
                    {print} 'One ' food
                    {if} drink {is} cola {print} 'and...' {else} {print} 'One ' drink
                    {if} anything {is} no {print} 'Thats it!' {else} {print} 'One ' anything
                    {print} 'Thank you for your order and enjoy your meal!'
                    ```
            6:
                story_text: |
                    In this level you can use maths to calculate the total price of your customer's order, which can make your virtual restaurant more realistic.
                example_code: |
                    You can make a simple restaurant code, like this:
                    ```
                    {print} 'Welcome to Restaurant Chez Hedy'
                    {print} 'Here is our menu:'
                    {print} 'Our main courses are pizza, lasagne, or spaghetti'
                    main = {ask} 'Which main course would you like?'
                    price = 0
                    {if} main {is} pizza price = 10
                    {if} main {is} lasagne price = 12
                    {if} main {is} spaghetti price = 8
                    {print} 'You have ordered ' main
                    {print} 'That will be ' price ' dollars, please'
                    {print} 'Thank you, enjoy your meal!'
                    ```
            7:
                story_text: |
                    In this level you've learned how to use the `{repeat}` command to repeat a line of code a certain amount of times.
                    You can use that in your restaurant to `{ask}` multiple people what they'd like to eat.

                    ### Exercise
                    Can you complete the code? Hedy needs to repeat this question as many times as there are people. So if there are 5 people, the question needs to be asked 5 times.
                    **(extra)** Expand your code with more questions, for example about drinks or sauce.
                example_code: |
                    ```
                    {print} 'Welcome to Restaurant Chez Hedy'
                    people = {ask} 'How many people are joining us today?'
                    ```
            8:
                story_text: |
                    In this level you can make your virtual restaurant more elaborate by repeating multiple lines of code. Like this:

                    ### Exercise
                    This code can be expanded with more items on the menu, for example offering drinks, and/or multiple courses or desserts. Add at least one more item.
                    **Extra** Add even more items, as many options as you like!
                example_code: |
                    ```
                    {print} 'Welcome to Restaurant Chez Hedy!'
                    people = {ask} 'How many people will be joining us today?'
                    {print} 'Great!'
                    {repeat} people {times}
                        food = {ask} 'What would you like to order?'
                        {print} food
                    {print} 'Thank you for ordering!'
                    {print} 'Enjoy your meal!'
                    ```
            9:
                story_text: "In this level you can use nesting to make your restaurant more realistic and more fun!\n\n### Exercise\nThe indentation was removed in the example code. \nCan you figure out how much indentation each line needs in order for the code to work properly?\nIf the customer orders pizza, Hedy shouldn't ask what sauce the costumer wants.\n\n**(extra)** A restaurant does not stock all sauces. Make a list of available sauces and give a reply with each order whether you sell it. <br>\n**(extra)** Pizzas have toppings. Ask customers what they want.<br>\n**(extra)** Do customers want a drink? Ask them too! <br>                    \n"
                example_code: |
                    ```
                    {print} 'Welcome to Restaurant Chez Hedy!'
                    people = {ask} 'How many people will be joining us today?'
                    {print} 'Great!'
                    price = 0
                    {repeat} people {times}
                    _ food = {ask} 'What would you like to order?'
                    _ {print} food
                    _ {if} food {is} fries
                    _ price = price + 3
                    _ sauce = {ask} 'What kind of sauce would you like with your fries?'
                    _ {if} sauce {is} no
                    _ {print} 'no sauce'
                    _ {else}
                    _ price = price + 1
                    _ {print} 'with ' sauce
                    _ {if} food {is} pizza
                    _ price = price + 4
                    {print} 'That will be ' price ' dollar'
                    {print} 'Enjoy your meal!'
                    ```
            10:
                story_text: |
                    In this level you'll learn how to easily ask orders for different courses.

                    ### Exercise 1
                    Finish the code with an `{ask}` on the blanks such that the customer is asked what they want to eat for each course.
                example_code: "```\ncourses = appetizer, main course, dessert\n{for} course {in} courses\n    {print} 'What is your order for ' course '?'\n    _ \n    _\n```\n"
                story_text_2: |
                    ### Exercise
                    Of course, you could also order for multiple people!
                    Can you add the correct amount of indentation before each line to make the code work properly?
                    Tip: some lines don't need any indentation at all.
                example_code_2: |
                    ```
                    _ courses = appetizer, main course, dessert
                    _ names = Timon, Onno
                    _ {for} name {in} names
                    _ {for} course {in} courses
                    _ food = {ask} name ', what would you like to eat as your ' course '?'
                    _ {print} name ' orders ' food ' as their ' course
                    ```
            11:
                story_text: |
                    We can use the `{for}` with `{range}` to print the orders from multiple customers in an orderly manner.

                    ### Exercise
                    Finish the restaurant code, so that you can ask for the order of multiple people. Print the order number each time: 'Order 1', 'Order 2', etc.
                    Are you not sure how to go about this? Have a peek at your level 8 code.

                    **(extra)** In level 9 the restaurant also used prices. You can add that here too!
                example_code: |
                    ```
                    {print} 'Welcome to Restaurant Hedy!'
                    people = {ask} 'For how many people would you like to order?'
                    {print} 'So you want to order for ' people ' people.'
                    {print} "Let's go!"
                    ```
            12:
                story_text: |
                    From this level on you can use decimal numbers to make you menu more realistic.

                    ### Exercise
                    Can you think of a code to give your friends and family a 15% discount?
                example_code: |
                    ```
                    price = 0.0
                    food = {ask} 'What would you like to order?'
                    drink = {ask} 'What would you like to drink?'
                    {if} food {is} 'hamburger'
                        price = price + 6.50
                    {if} food {is} 'pizza'
                        price = price + 5.75
                    {if} drink {is} 'water'
                        price = price + 1.20
                    {if} drink {is} 'soda'
                        price = price + 2.35
                    {print} 'That will be ' price ' dollar, please'
                    ```
            13:
                story_text: |
                    In this level you will learn new commands to extend your code even further.

                    ### Exercise 1
                    Place a `{and}` and a `{or}` in the logical place in the program.

                    ### Exercise 2
                    Expand your restaurant with at least one more `{and}` and one `{or}`.
                    For example, create a special discount coupon that only applies to pizza, or give your customer a free drink
                    with fries and pancakes. Or something completely different of course!
                example_code: |
                    ```
                    price = 10
                    food = {ask} 'What would you like to eat?'
                    drinks = {ask} 'What would you like to drink?'
                    {if} food {is} 'sandwich' _ drinks {is} 'juice'
                        {print} 'That is our discount menu'
                        price = price - 3
                    {if} drinks {is} 'water' _ drinks {is} 'juice'
                        {print} 'That is a healthy choice'
                    {print} 'That will be ' price ' dollars'
                    ```
            15:
                story_text: |
                    With the `{while}` you can make sure your costumers can keep adding orders until they are done.

                    ### Exercise
                    Correctly add the `{while}` command to this code.
                example_code: |
                    ```
                    {print} 'Welcome at McHedy'
                    more = 'yes'
                    _
                        order = {ask} 'What would you like to order?'
                        {print} order
                        more = {ask} 'Would you like to order anything else?'
                    {print} 'Thank you!'
                    ```
    rock:
        name: Rock, paper, scissors
        default_save_name: Rock
        description: Make your own rock, paper, scissors game
        levels:
            1:
                story_text: |
                    In level 1 you can start with a rock, paper, scissors  game.

                    With `{ask}` you can make a choice, and with `{echo}` you can repeat that choice.
                example_code: |
                    ```
                    {print} what do you choose?
                    {ask} choose from rock, paper or scissors
                    {echo} so your choice was:
                    ```
                story_text_2: |
                    ### Exercise
                    Instead of using words, you could also use emojis: ✊✋✌
                    Can you create a code using emojis?
                example_code_2: |
                    ```
                    {print} what do you choose?
                    {ask} choose from _
                    {echo} so your choice was:
                    ```
            2:
                story_text: |
                    In this level you can practise using the variables, so that you can make the rock, paper, scissors game in the next level!
                example_code: |
                    ```
                    _ {is} {ask} rock, paper, or scissors?
                    {print} I choose _
                    ```
            3:
                story_text: |
                    You can use the `{at} {random}` command to let the computer pick rock, paper or scissors!

                    ### Exercise
                    Finish the code by using the `{at} {random}` command.
                example_code: |
                    ```
                    choices {is} rock, paper, scissors
                    {print} choices {at} {random}
                    ```
                story_text_2: |
                    ### Exercise
                    Now you only have one player, so can you add a second player?
                    You can even use variables to name player 1 and player 2.
                example_code_2: |
                    ```
                    choices {is} rock, paper, scissors
                    {print} player 1 chooses... choices {at} {random}
                    {print} player 2 _
                    ```
            4:
                story_text: |
                    In this level we can further program rock, paper, scissors. But if you want to add text, you have to use quotation marks here too.
                    ### Exercise
                    Fill in quotation marks on the blanks. Mind that the variable `choices` should be outside the quotes.
                example_code: |
                    ```
                    choices {is} rock, paper, scissors
                    {print} _The computer chooses..._ choices {at} {random}
                    ```
            5:
                story_text: |
                    In this level we can determine who won.
                    For that you need the new `{if}` code.

                    Save your choice with the name of choice and the choice of computer as computer choice.
                    Then you can use `{if}` to see {if} they are the same or different.
                    Will you finish the code?
                example_code: |
                    ```
                    options {is} rock, paper, scissors
                    computer_choice {is} _
                    choice {is} {ask} 'What do you choose?'
                    {print} 'you chose ' _
                    {print} 'computer chose ' _
                    {if} _ {is} _ {print} 'tie!' {else} {print} 'no tie'
                    ```

                    Fill in the correct code on the blanks to see {if} it is a draw.
            9:
                story_text: |
                    In this level you can program the whole rock, paper, scissors game by nesting the {if}-commands. Can you finish the code?
                example_code: |
                    ```
                    choices = rock, paper, scissors
                    your_choice = {ask} 'What do you choose?'
                    {print} 'You choose ' your_choice
                    computer_choice = choices {at} {random}
                    {print} 'The computer chooses ' computer_choice
                    {if} computer_choice {is} your_choice
                        {print} 'Tie'
                    {if} computer_choice {is} rock
                        {if} your_choice {is} paper
                            {print} 'You win!'
                        {if} your_choice {is} scissors
                            {print} 'You lose!'
                    # finish this code
                    ```
            10:
                story_text: |
                    Feeling too lazy to play the game yourself? Let Hedy play it for you!
                    You only have to fill in the names of the players.
                example_code: |
                    ```
                    choices = rock, paper, scissors
                    players = _
                    {for} player {in} players
                         {print} player ' chooses ' choices {at} {random}
                    ```
            13:
                story_text: |
                    With the `{and}` command you can shorten your rock, paper, scissors code! Check out the example code below and try to finish it.
                example_code: |
                    ```
                    options = 'rock', 'paper', 'scissors'
                    your_choice = {ask} 'What do you choose?'
                    computer_choice = options {at} {random}
                    {print} 'You choose ' your_choice
                    {print} 'The computer chooses ' computer_choice
                    {if} computer_choice {is} your_choice
                        {print} 'Tie'
                    {if} computer_choice {is} 'rock' {and} your_choice {is} 'paper'
                        {print} 'You win!'
                    {if} computer_choice {is} 'rock' {and} your_choice {is} 'scissors'
                        {print} 'The computer wins!'
                    _
                    ```
            15:
                story_text: |
                    ### Exercise
                    Play until you beat the computer! But first, finish the example code...
                example_code: |
                    ```
                    won = 'no'
                    options = 'rock', 'paper', 'scissors'
                    {while} won == 'no'
                        your_choice = {ask} 'What do you choose?'
                        computer_choice = options {at} {random}
                        {print} 'you chose ' your_choice
                        {print} 'the computer chose ' computer_choice
                        {if} computer_choice == your_choice
                            {print} 'Tie!'
                        {if} computer_choice == 'rock' {and} your_choice == 'scissors'
                            {print} 'You lose!'
                        {if} computer_choice == 'rock' {and} your_choice == 'paper'
                            {print} 'You win!'
                            won = 'yes'
                    _
                    ```
    rock_2:
        name: Rock, paper, scissors 2
        default_save_name: rock_2
        description: Part 2 of rock, paper, scissors
        levels:
            2:
                story_text: |
                    Now that you have learned how to use the `{ask} command, you can make your rock, paper, scissors code interavtive too!

                    ### Exercise
                    Make the rock, paper, scissors code interactive by adding the `{ask}` command and a question to your rock, paper, scissors code.
                example_code: |
                    ```
                    choice is _
                    {print} I choose choice
                    ```
    secret:
        name: SuperSpy
        default_save_name: SuperSpy
        description: Make your own spy code
        levels:
            12:
                story_text: |
                    In this adventure you can create your own super spy code. Encode a message that only the right agent can decipher.
                    If the enemy tries to crack the code, they will get some false info to waste their time.

                    ### Exercise
                    Make your own secret code for your superspy. Can you make it consist of even more variables?
                example_code: |
                    ```
                    name = {ask} 'What is your name?'
                    {if} name {is} '_'
                        a = 'Go to the airport '
                    {else}
                        a = 'Go to the trainstation '
                    password = {ask} 'What is the password?'
                    {if} password {is} _
                        b = 'tomorrow at 02.00'
                    {else}
                        b = 'today at 10.00'
                    {print} _ _ _
                    ```
            13:
                story_text: |
                    Can you fill in the right command on the blank? Mind: The superspy has to answer BOTH questions correctly, before they get the confidential information!
                example_code: |
                    ```
                    name = {ask} 'What is your name?'
                    password = {ask} 'What is your password?'
                    {if} name {is} 'Agent007' _ password {is} 'TOPSECRET'
                        {print} 'Go to the airport at 02.00'
                    {else}
                        {print} 'Go to the trainstation at 10.00'
                     ```
    simon:
        name: Simon Says
        default_save_name: Simon
        description: Make a game of Simon Says
        levels:
            16:
                story_text: |
                    Let's make a game of Simon Says! Simon Says is a memory game in which the player will be given a color. They have to repeat that color back.
                    If they get it right a color is added to the sequence, so they now have to remember 2 colors, then 3, then 4 etc. the game stops as soon as the player makes a mistake.

                    ### Exercise
                    In this first part of the Simon Says adventure, we'll let the computer pick a random color and add it to a list.

                    ***Make 2 lists*** First, make a list called `colors` and fill it with the colors red, yellow, green and blue.
                    Then make a list called `simon_sequence`. This list will be used as the answer.
                    At the start of the game this lists need to be empty. unfortunately, we can't create an empty list (yet), so we'll fill it with the words 'empty' and 'list' and we'll remove them from the list immediately.

                    ***Create a function that adds a color to the sequence*** Now that we have an empty list called simon_sequence, we can start filling it with random colors.
                    We do that with a function, so we can call it everytime there's a new level in our game. Create a function called `add_random_color`.
                    Then create the variable random_color and set it to a random color. Next, add this random color to the simon_sequence.

                    ***Create a function that shows the simon_sequence*** Start by naming the new function `show_simon_sequence` with `level` as an argument. Now we want to show as many colors as the level we are in (in level 1 you see 1 color, in level 2 you see 2 colors etc).
                    So we repeat `level` times, to print the `simon_sequence[i]`. Each time a color is shown, wait for 1 second and then clear the screen.

                    ***Test your program*** Before you go to the next level, test if the functions are working by calling both of the functions. If they're working you should see a random color in your output screen.
                    Remove this testing part of your code, copy the code and continue to the next tab to learn more about the simon says game!
                example_code: |
                    ```
                    # Make 2 lists
                    colors = _
                    _ = ['empty', 'list']
                    {remove} _ {from} simon_sequence
                    {remove} _

                    # Create a function that adds a color
                    _ add_random_color
                        _
                        {add} _

                    # Create a function that shows the simon_sequence
                    {define} _
                        {for} i {in} {range} 1 {to} _
                            {print} _
                            _
                            _

                    # Test your program
                    {call} _
                    {call} show_simon_sequence {with} 1
                    ```
    simon_2:
        name: Simon Says 2
        default_save_name: Simon
        description: Make a game of Simon Says
        levels:
            16:
                story_text: |
                    We'll continue with our Simon Says game!

                    ### Exercise
                    ***Paste your code here*** Paste your code from the previous level here. Don't forget to remove the part that was just used for testing the functions.

                    ***Create a function that creates the player_sequence*** The list `player_sequence` is used to capture the answers of the player. First we define the function with the argument level.
                    Next, we ask level times what the color is that they choose. We call that variable `answer`. Then we add the variable `answer` to the list player_sequence.

                    ***Setting up the game*** Before we program the game in the next tab, we'll need some starting variables. First, we'll set the variable `level` to 1 and the variable `game_over` to False.
                    Then we make an introduction for the game. We'll print 'Welcome to Simon Says!' and clear the screen after 1 second.

                    ***Continue to the next tab to finish the game!**** Don't forget to copy your code and take it with you to the next tab.
                example_code: |
                    ```
                    # Paste your code here


                    # Create a function that creates the player_sequence
                    {define} _
                        {for} _
                            _ 'What is color number ' i '?'
                            {add} answer {to} _

                    # Set up
                    level = _
                    game_over = _
                    {print} _
                    _ 1
                    _
                    ```
    simon_3:
        name: Simon Says 3
        default_save_name: Simon
        description: Make a game of Simon Says
        levels:
            16:
                story_text: |
                    In this tab we'll program the game of Simon Says!

                    ### Exercise
                    ***Paste your code*** Copy your code from the previous tab and paste it here.

                    ***Program the game*** We start by making sure the game goes on while the game isn't over. Then we print what level the player is on, we use the variable level for that. We only show that for 1 second and then we clear the screen again.
                    Now, we have to create the empty list player_sequence. We've already programmed how to fill the list, with our function `player_sequence`, but we never made the list itself. To create the list we use the same trick as we did in the previous tab.
                    We'll make a list with the words 'empty' and 'list' on it, and then we remove both these words. Next, we'll call all of the 3 functions that we've created.
                    Lastly, we'll have to check if the player gave the correct answers (so if the player_sequence and the simon_sequence are the same).
                    If that's the case, we'll compliment the player. Wait for 1 second and increase the level with 1.
                    Did the player give the wrong answer, we'll tell them and end the game by setting game_over to 'True'

                    ***Enjoy your game!*** Great job! Does your game not work? Use the ladybug button to debug your code!
                example_code: |
                    ```
                    # Paste your code here

                    # The game
                    {while} game_over _
                        {print} _
                        _
                        _
                        _ = ['empty', 'list']
                        {remove} _
                        {remove} _
                        {call} _
                        {call} _ {with} _
                        {call} _ {with} _
                        {if} player_sequence == _
                            _
                            _
                            _
                        {else}
                            _
                            game_over = _
                    ```
    sleep_command:
        name: '{sleep}'
        default_save_name: sleep_command
        description: introducing sleep command
        levels:
            2:
                story_text: |
                    ## The sleep command
                    Another new command in this level is `{sleep}`, which pauses your program for a second. If you type a number behind the {sleep} command, the program pauses for that amount of seconds.
                example_code: |
                    ```
                    {print} My favorite colour is...
                    {sleep} 2
                    {print} green!
                    ```
    songs:
        name: Sing a song!
        default_save_name: Song
        description: Print a song
        levels:
            6:
                story_text: |
                    Songs often contain a lot of repetition. Sometimes the repetition is also based on counting.
                    For example, in the well-known song 'Bottles of beer'. You can program that song with a little math.

                    Tip: Use the read aloud function to let Hedy sing the song to you!

                    ### Exercise
                    You can now repeat lines 2 to 7 as many times as you want by copying the lines.
                example_code: |
                    ```
                    verse = 99
                    {print} verse ' bottles of beer on the wall'
                    {print} verse ' bottles of beer'
                    {print} 'Take one down, pass it around'
                    verse = verse - 1
                    {print} verse ' bottles of beer on the wall'
                    {sleep}
                    ```
                story_text_2: |
                    This children's song counts down from 5 little monkeys to 1 monkey.
                    If you copy line 2 - 7 and paste it under the the code, you can sing the whole song!
                example_code_2: |
                    ```
                    number = 6
                    number = number - 1
                    print number ' little monkeys jumping on the bed'
                    print 'One fell off and bumped his head'
                    print 'Mama called the doctor and the doctor said'
                    print 'NO MORE MONKEYS JUMPING ON THE BED!'
                    sleep
                    ```
            7:
                story_text: |
                    Songs often contain a lot of repetition. For example... Baby Shark! If you sing it, you keep singing the same thing:

                    Baby Shark tututudutudu <br>
                    Baby Shark tututudutudu <br>
                    Baby Shark tututudutudu <br>
                    Baby Shark

                    You can make this song much shorter with a `{repeat}`! Can you finish the code?
                example_code: |
                    ```
                    {repeat} _ _ {print} 'Baby Shark tututudutudu'
                    {print} 'Baby Shark'
                    ```

                    After Baby Shark you can of course also program other songs. There are many songs with repetition.
            8:
                story_text: |
                    In a previous level you've programmed the song 'Bottles of beer'. You made one verse and then had to copy the verses 99 times. In this level you can repeat the song 99 times, just by adding one simple line!
                    Do you know which line of code to add on the blanks?
                example_code: |
                    ```
                    verse = 99
                    _ _ _
                        {print} verse ' bottles of beer on the wall'
                        {print} verse ' bottles of beer'
                        {print} 'Take one down, pass it around'
                        verse = verse - 1
                        {print} verse ' bottles of beer on the wall'
                    ```
            10:
                story_text: |
                    In this level you can easily make the childrens' song 'Five little monkeys'. Can you make the last chorus?
                    You can also make the whole baby shark song (including all the other sharks in the family) in only 6 lines, using `{for}`!
                    Or you can make Old MacDonald with all the different animals.



                    ### Exercises
                    Can you add the last verse of the monkeys on the bed, when there is only one monkey left?

                    Can you make the baby shark code even shorter by using a `{repeat}` command?

                    Can you add new animals to Old MacDonald's farm?
                example_code: |
                    ```
                    monkeys = 5, 4, 3, 2
                    {for} monkey {in} monkeys
                        {print} monkey ' little monkeys jumping on the bed'
                        {print} 'One fell off and bumped his head'
                        {print} 'Mama called the doctor and the doctor said'
                        {print} 'NO MORE MONKEYS JUMPING ON THE BED!'
                    ```

                    ```
                    sharks = baby, mommy, daddy, grandma, grandpa
                    {for} shark {in} sharks
                        {print} shark ' shark tututututudu'
                        {print} shark ' shark tututututudu'
                        {print} shark ' shark tututututudu'
                        {print} shark ' shark'
                    ```
                    ```
                    animals = pig, dog, cow
                    {for} animal {in} animals
                        {if} animal {is} pig
                            sound = oink
                        {if} animal {is} dog
                            sound = woof
                        {if} animal {is} cow
                            sound = moo
                        {print} 'Old MacDonald had a farm'
                        {print} 'E I E I O!'
                        {print} 'and on that farm he had a ' animal
                        {print} 'E I E I O!'
                        {print} 'with a ' sound sound ' here'
                        {print} 'and a ' sound sound ' there'
                        {print} 'here a ' sound
                        {print} 'there a ' sound
                        {print} 'everywhere a ' sound sound
                    ```
                story_text_2: |
                    ### Exercise 2
                    Print the song Five little moneys jumping on the bed. Look up the text if you don't remember.

                    **(extra)** Print the song Old MacDonald had a farm, and make sure all animals make a different sound, using an `{if}`.
                example_code_2: |
                    ```
                    monkeys = 5, 4, 3, 2, 1
                    ```
            11:
                story_text: |
                    In this level you can use the `{for} i {in} {range}` command to make songs that use counting, like the 5 little monkeys.

                    ### Exercise
                    Fill in the blanks and make the code work!
                example_code: |
                    ```
                    _ _ _ _ 5 _ 1
                        {print} i ' little monkeys jumping on the bed'
                        {print} 'One fell off and bumped his head'
                        {print} 'Mama called the doctor and the doctor said'
                        {if} i {is} 1
                            {print} 'PUT THOSE MONKEYS RIGHT TO BED!'
                        {else}
                            {print} 'NO MORE MONKEYS JUMPING ON THE BED!'
                    ```
            12:
                story_text: |
                    In this song we can make it even easier to program 'if you're happy and you know it, clap your hands'. Because we can put all of the actions in a variable, check it out:

                    ### Exercise
                    Can you add the right amount of indentation to each line to make the song play correctly?
                    Hint: Not all lines need indentation.
                example_code: |
                    ```
                    _ actions = 'clap your hands', 'stomp your feet', 'shout Hurray!'
                    _ {for} action {in} actions
                    _ {for} i {in} {range} 1 {to} 2
                    _ {print} 'if youre happy and you know it'
                    _ {print} action
                    _ {print} 'if youre happy and you know it and you really want to show it'
                    _ {print} 'if youre happy and you know it'
                    _ {print} action
                    ```
            13:
                story_text: |
                    In the previous adventure you have learned how to use an argument in a function, but did you know that you could combine them with {ask} commands as well?
                    In this example we have changed the 'My Bonnie' program and made it interactive. You are now asked where Bonnie is.
                example_code: |
                    ```
                    {define} song {with} place
                        {print} 'My Bonnie is ' place

                    chosen_place = {ask} 'Where do you want Bonnie to be?'
                    synonym = {ask} 'What is another word for that?'

                    {call} song {with} chosen_place
                    {call} song {with} synonym
                    {call} song {with} chosen_place
                    ```
            16:
                story_text: |
                    In this level, you can program a song like OldMacDonald even more quickly. You can connect the right animal to the right sound by simply putting them in the same place in the list.
                    The Drunken Sailor is also quickly made in this level. You only need 8 lines for the entire song, check it out!

                    ### Exercise
                    Complete the Old MacDonald song by setting the variable `animal` to `animals[i]` and `sound` to `sounds[i]`.
                example_code: |
                    ```
                    animals = ['pig', 'dog', 'cow']
                    sounds = ['oink', 'woof', 'moo']
                    {for} i {in} {range} 1 {to} 3
                        animal = _
                        sound = _
                        {print} 'Old MacDonald had a farm'
                        {print} 'E I E I O!'
                        {print} 'and on that farm he had a ' animal
                        {print} 'E I E I O!'
                        {print} 'with a ' sound sound ' here'
                        {print} 'and a ' sound sound ' there'
                        {print} 'here a ' sound
                        {print} 'there a ' sound
                        {print} 'everywhere a ' sound sound
                    ```

                    ```
                    lines = ['what shall we do with the drunken sailor', 'shave his belly with a rusty razor', 'put him in a long boat till hes sober']
                    {for} line {in} lines
                        {for} i {in} {range} 1 {to} 3
                            {print} line
                        {print} 'early in the morning'
                        {for} i {in} {range} 1 {to} 3
                            {print} 'way hay and up she rises'
                        {print} 'early in the morning'
                    ```
            18:
                story_text: |
                    In level 16 we made songs using lists. These programs however are no longer working properly in this level. The colons from level 17 and the brackets from level 18 still need to be added.

                    ### Exercise 1
                    The Drunken sailor song is given as sample code, but not yet working.
                    Can you make sure everything works again? To help you, we've put _ in the places of _some_ errors.

                    ### Exercise 2
                    Now also look up your Old MacDonald song from level 16, and correct it.
                example_code: |
                    ```
                    lines = ['what shall we do with the drunken sailor', 'shave his belly with a rusty razor', 'put him in a long boat till hes sober']
                    {for} line {in} lines _
                        {for} i {in} {range} 1 {to} 3 _
                            {print} _ line _
                        {print} 'early in the morning'
                        {for} i {in} {range} 1 {to} 3
                            {print} 'way hay and up she rises'
                        {print} 'early in the morning'
                    ```
    songs_2:
        name: Sing a song! 2
        default_save_name: Song 2
        description: Sing a song 2
        levels:
            12:
                story_text: |
                    Songs contain a lot of repetition. We can capture it with a function!
                    ### Exercise
                    Look at the example code with the function. Fill out the two lines so the full song is printed.
                example_code: |
                    ```
                    {define} twinkle
                        {print} 'Twinkle'
                        {print} '...'

                    {call} twinkle
                    {print} 'Up above the world so high'
                    {print} 'Like a diamond in the sky'
                    {call} _
                    ```
            16:
                story_text: |
                    ### Exercise
                    Finish the nursery rhyme!
                example_code: |
                    ```
                    number = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
                    object = ['on his drum', 'on his shoe', 'on his knee', 'on his door', 'on his hive', 'on his sticks', 'up in heaven', 'on his gate', 'on his vine', 'once again']

                    _
                        {print} 'This old man'
                        {print} 'He played ' _
                        {print} 'He played knick-knack ' _
                        {print} 'With a knick-knack paddywhack'
                        {print} 'Give the dog a bone'
                        {print} 'This old man came rolling home'
                        {sleep} 8
                        {clear}
                    ```
                story_text_2: |
                    ### Exersice 2
                    Now create your own code for the nursery rhyme 'The wheels on the bus' on the same way!
                example_code_2: |
                    ```
                    object = ['wheels', 'doors', _]
                    movement = [ 'round and round', 'open and shut', _]
                    ```
    tic:
        name: Tic Tac Toe
        default_save_name: Tic
        description: Play a game of Tic Tac Toe!
        levels:
            13:
                story_text: |
                    In this adventure you can program a game of Tic Tac Toe. You can play with two people. Taking turns, you pick a number of the spot (1 - 9) you want to put your sign (x or o) on.
                    The first player that gets 3 in a row (horizontally, vertically or diagonally) wins!

                    ### Exercise 1
                    The game works, but it has some issues. For example, any player can pick any field, even one already taken! Use an `{if}` whether the spot is taken, and if so, warn the player.

                    ### Exercise 2
                    The game also does not decide who has won. You need to add this by checking whether 3 spots in a row have the same same symbol.

                    ### Exercise 3 (extra)
                    You don't always have a friend to play with. Can you create a computer opponent?
                example_code: |
                    ```
                    player = 'x'
                    field = '.', '.', '.', '.', '.', '.', '.', '.', '.'

                    {for} i {in} {range} 1 {to} 9
                        choice = {ask} 'Player ' player ' what spot do you choose?'
                        field {at} choice = player
                        {clear}
                        {print} field {at} 1 field {at} 2 field {at} 3
                        {print} field {at} 4 field {at} 5 field {at} 6
                        {print} field {at} 7 field {at} 8 field {at} 9
                        {if} player = 'x'
                            player = 'o'
                        {else}
                            player = 'x'
                    ```
            14:
                story_text: |
                    In the previous levels you've made a tic tac toe game. Now you've learned how to use the `=` sign, the `==` sign and the `!=` sign.
                    You can use this knowledge in your new Tic Tac Toe game, like this:
                example_code: |
                    ```
                    sign = 'x'
                    open_spots = 1, 2, 3, 4, 5, 6, 7, 8, 9
                    game = 'on'
                    spot_1 = '.'
                    spot_2 = '.'
                    spot_3 = '.'
                    spot_4 = '.'
                    spot_5 = '.'
                    spot_6 = '.'
                    spot_7 = '.'
                    spot_8 = '.'
                    spot_9 = '.'
                    {print} 'TIC TAC TOE!'
                    {print} spot_1 spot_2 spot_3
                    {print} spot_4 spot_5 spot_6
                    {print} spot_7 spot_8 spot_9
                    {print} ' '
                    {for} i {in} {range} 1 {to} 9
                        {if} game != 'over'
                            choice = {ask} 'Player ' sign ', which spot?'
                            {if} choice {in} open_spots
                                {remove} choice {from} open_spots
                                {if} choice == 1
                                    spot_1 = sign
                                {if} choice == 2
                                    spot_2 = sign
                                {if} choice == 3
                                    spot_3 = sign
                                {if} choice == 4
                                    spot_4 = sign
                                {if} choice == 5
                                    spot_5 = sign
                                {if} choice == 6
                                    spot_6 = sign
                                {if} choice == 7
                                    spot_7 = sign
                                {if} choice == 8
                                    spot_8 = sign
                                {if} choice == 9
                                    spot_9 = sign
                            {else}
                                {print} 'That spot was already taken'
                            {print} spot_1 spot_2 spot_3
                            {print} spot_4 spot_5 spot_6
                            {print} spot_7 spot_8 spot_9
                            {print} ' '
                            winner = {ask} 'Did you win?'
                            {if} winner == 'yes'
                                {print} 'Good job, player ' sign '!'
                                game = 'over'
                            {else}
                                {if} sign == 'x'
                                    sign = 'o'
                                {else}
                                    sign = 'x'
                    ```
            15:
                story_text: |
                    In this level you can improve your Tic Tac Toe game with the {while} loop. With this loop you can combine the `{if} game != 'over'` and the `{for} i {in} {range} 1 {to} 9` into one simple line.
                    Check it out:
                example_code: |
                    ```
                    sign = 'x'
                    open_spots = 1, 2, 3, 4, 5, 6, 7, 8, 9
                    game = 'on'
                    spot_1 = '.'
                    spot_2 = '.'
                    spot_3 = '.'
                    spot_4 = '.'
                    spot_5 = '.'
                    spot_6 = '.'
                    spot_7 = '.'
                    spot_8 = '.'
                    spot_9 = '.'
                    {print} 'TIC TAC TOE!'
                    {print} spot_1 spot_2 spot_3
                    {print} spot_4 spot_5 spot_6
                    {print} spot_7 spot_8 spot_9
                    {print} ' '
                    {while} game != 'over'
                        choice = {ask} 'Player ' sign ', which spot?'
                        {if} choice {in} open_spots
                            {remove} choice {from} open_spots
                            {if} choice == 1
                                spot_1 = sign
                            {if} choice == 2
                                spot_2 = sign
                            {if} choice == 3
                                spot_3 = sign
                            {if} choice == 4
                                spot_4 = sign
                            {if} choice == 5
                                spot_5 = sign
                            {if} choice == 6
                                spot_6 = sign
                            {if} choice == 7
                                spot_7 = sign
                            {if} choice == 8
                                spot_8 = sign
                            {if} choice == 9
                                spot_9 = sign
                        {else}
                            {print} 'That spot was already taken'
                        {print} spot_1 spot_2 spot_3
                        {print} spot_4 spot_5 spot_6
                        {print} spot_7 spot_8 spot_9
                        {print} ' '
                        winner = {ask} 'Did you win?'
                        {if} winner == 'yes'
                            {print} 'Good job, player ' sign '!'
                            game = 'over'
                        {else}
                            {if} sign == 'x'
                                sign = 'o'
                            {else}
                                sign = 'x'
                    ```
            17:
                story_text: |
                    In the previous levels the tic tac toe game had an annoying feature. After every move, you had to fill in yourself if you had won or not.
                    This made the game playable, but also quite slow. In this level we have learned the `{elif}` command, that could solve that problem.
                    To use the `{elif}` to let Hedy check whether or not a player has won is fun, but it also requires a fair amount of extra lines.

                    In the example code you see that we added the requirements to win (3 spots in a row horizontally, vertically or diagonally).
                    You can find them in line 46 to 69. You can see that each time the requirement is met (so if a player has won) the variable game is set to 'over'.
                    This means that the `{while}` loop will be stopped and the game ends.
                example_code: |
                    ```
                    sign = 'x'
                    open_spots = [1, 2, 3, 4, 5, 6, 7, 8, 9]
                    game = 'on'
                    spot_1 = '.'
                    spot_2 = '.'
                    spot_3 = '.'
                    spot_4 = '.'
                    spot_5 = '.'
                    spot_6 = '.'
                    spot_7 = '.'
                    spot_8 = '.'
                    spot_9 = '.'
                    {print} 'TIC TAC TOE!'
                    {print} spot_1 spot_2 spot_3
                    {print} spot_4 spot_5 spot_6
                    {print} spot_7 spot_8 spot_9
                    {print} ' '
                    {while} game != 'over':
                        choice = {ask} 'Player ' sign ', which spot?'
                        {if} choice {in} open_spots:
                            {remove} choice {from} open_spots
                            {if} choice == 1:
                                spot_1 = sign
                            {if} choice == 2:
                                spot_2 = sign
                            {if} choice == 3:
                                spot_3 = sign
                            {if} choice == 4:
                                spot_4 = sign
                            {if} choice == 5:
                                spot_5 = sign
                            {if} choice == 6:
                                spot_6 = sign
                            {if} choice == 7:
                                spot_7 = sign
                            {if} choice == 8:
                                spot_8 = sign
                            {if} choice == 9:
                                spot_9 = sign
                        {else}:
                            {print} 'That spot was already taken'
                        {print} spot_1 spot_2 spot_3
                        {print} spot_4 spot_5 spot_6
                        {print} spot_7 spot_8 spot_9
                        {print} ' '
                        {if} spot_1 == spot_2 {and} spot_2 == spot_3 {and} spot_1 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_4 == spot_5 {and} spot_5 == spot_6 {and} spot_4 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_7 == spot_8 {and} spot_8 == spot_9 {and} spot_7 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_1 == spot_4 {and} spot_4 == spot_7 {and} spot_1 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_2 == spot_5 {and} spot_5 == spot_8 {and} spot_2 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_3 == spot_6 {and} spot_6 == spot_9 {and} spot_3 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_1 == spot_5 {and} spot_5 == spot_9 {and} spot_1 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {elif} spot_3 == spot_5 {and} spot_5 == spot_7 {and} spot_3 != '.':
                            {print} 'Player ' sign ' wins!'
                            game = 'over'
                        {else}:
                            {if} sign == 'x':
                                sign = 'o'
                            {else}:
                                sign = 'x'
                    ```
    turtle:
        name: Turtle
        default_save_name: Turtle
        description: Make your own drawing
        levels:
            1:
                story_text: |
                    You can also use Hedy to draw. By combining turns and lines, you can make a square or stairs!

                    Using `{forward}` you draw a line forwards. The number behind it determines how far the turtle will walk. `{turn} {right}` turns a quarter turn in clockwise direction, `{turn} {left}` turns counter clockwise.

                    If you want to go backwards, you use the `{forward}` command but with a negative number. So for example `{forward} -100`
                example_code: |
                    ```
                    {forward} 100
                    {turn} {left}
                    ```
                story_text_2: |
                    ### Exercise
                    This is the start of a little staircase. Can you make it have 5 steps?
                example_code_2: |
                    ```
                    {forward} 20
                    {turn} {right}
                    {forward} 20
                    {turn} {left}
                    {forward} 20
                    ```
            2:
                story_text: |
                    In this level you can use variables to make the turtle interactive. For example you can ask the player how many steps the turtle must make.
                example_code: |
                    ```
                    answer {is} {ask} How many steps should the turtle make?
                    {forward} answer
                    ```
                story_text_2: |
                    Also, in level 1 the turtle could only turn left or right. That is a bit boring!
                    In level 2 he can point his nose in all directions.

                    Use 90 to turn a quarter. We call this degrees. A full turn is 360 degrees.

                    ### Exercise
                    Can you make a figure with this code? Maybe a triangle or a circle?
                example_code_2: |
                    ```
                    {print} Drawing figures
                    angle {is} 90
                    {turn} angle
                    {forward} 25
                    {turn} angle
                    {forward} 25
                    ```
            3:
                story_text: |
                    In this level you can use use `{at} {random}` with the drawing turtle. A random choice makes the turtle walk a different path each time.
                    Use `{at} {random}` to choose a value from a list.
                    ### Exercise
                    Can you copy and paste lines 2 and 3 to create a longer random path?
                example_code: |
                    ```
                    angles {is} 10, 50, 90, 150, 250
                    {turn} angles {at} {random}
                    {forward} 25
                    ```
            4:
                story_text: |
                    In level 4 you have to use quotation marks with `{print}` and `{ask}`. Also when drawing!
                example_code: |
                    ```
                    {print} _ Drawing figures _
                    angle {is} 90
                    {turn} angle
                    {forward} 25
                    {turn} angle
                    {forward} 25
                    ```
                story_text_2: |
                    You can also change the color of the lines with the command `{color}`. Check out the example.
                    You can also use the command `{color} {white}` to make 'invisible' lines. You could use these white lines to move the turtle anywhere in the screen before you start drawing.
                example_code_2: |
                    ```
                    {color} {white}
                    {forward} -80
                    {color} {green}
                    {forward} 50
                    {color} {yellow}
                    {forward} 50
                    {color} {red}
                    {forward} 50
                    ```
            5:
                story_text: |
                    In level 5 you can make a choice with `{if}`. For example between different types of figures.
                example_code: |
                    ```
                    {print} 'Drawing Figures'
                    figure {is} {ask} 'Do you want a square or a triangle?'
                    {if} figure {is} triangle angle {is} 120
                    {else} angle {is} 90
                    {turn} angle
                    {forward} 25
                    {turn} angle
                    {forward} 25
                    {turn} angle
                    {forward} 25
                    {turn} angle
                    {forward} 25
                    ```
                story_text_2: |
                    ### Exercise
                    Fill in the correct numbers in this code to get it to work.
                    After you've done that, you can try to add the option backwards.

                    **Extra** Instead of using 'left' and 'right', remake the program with North, East, South and West.
                    This way you could add even more directions like Northeast and Southwest etc.
                example_code_2: |
                    ```
                    direction {is} {ask} 'Do you want to go left, right, or straight ahead?'
                    if direction is left turn _
                    if direction is right turn _
                    forward 100
                    ```
            6:
                story_text: |
                    In this level you can use calculations to draw different figures.
                    You may have learned in school that turning a full circle is 360 degrees. If not, now you know!
                    That's why you also use 90 degrees for a square. 360 divided by 4 is 90.
                    Now that we can do math with Hedy, we can draw all the figures we want!
                example_code: |
                    ```
                    angles = {ask} 'How many angles do you want?'
                    angle = 360 / angles
                    {forward} 50
                    {turn} angle
                    {forward} 50
                    {turn} angle
                    {forward} 50
                    {turn} angle
                    {forward} 50
                    {turn} angle
                    {forward} 50
                    {turn} angle
                    {forward} 50
                    {turn} angle
                    ```
            8:
                story_text: |
                    Now that we can repeat several lines, we can make figures more easily.
                    We only have to set the angle once and then use that variable in the `{repeat}`.
                example_code: |
                    ```
                    angle = 90
                    {repeat} 10 {times}
                        {turn} angle
                        {forward} 50
                    ```
                story_text_2: |
                    Also, we can now improve the program that draws different figures.
                    Can you figure out how far the turtle has to turn here? Finish the code and you can draw any polygon you'd like!
                example_code_2: |
                    ```
                    figure = {ask} 'How many angles should I draw?'
                    angle = 360 / figure
                    {repeat} figure {times}
                        {turn} _
                        {forward} _
                    ```
            9:
                story_text: |
                    Now that we can use a `{repeat}` inside a `{repeat}`, we can create more complex figures.

                    ### Exercise 1
                    This code creates three black triangles, change that into five pink squares.

                     **(extra)** Create a figure of your own choosing consisting of at least two different shapes types.
                example_code: |
                    ```
                    {color} {black}
                    {repeat} 3 {times}
                        {repeat} 3 {times}
                            {forward} 10
                            {turn} 120
                        {color} {white}
                        {forward} 50
                        {color} {black}
                    ```
            10:
                story_text: |
                    In this level you can make the turtle draw a figure.
                    The turtle will travel the distances in the list, one by one, making bigger and bigger steps.
                    ### Exercise 1
                    Add a 90 degree turn in the loop, so that a spiral is drawn.
                    Add at least 5 numbers to the list, so the spiral grows larger.
                     **(extra)** can you change the spiral into another shape? Experiment with numbers for the turn!
                    ### Exercise 2
                    The spiral is drawn outwards, make it go inwards?
                example_code: |
                    ```
                    {turn} 90
                    distances = 10, 20, 30, 40, 50, 60
                    {for} distance {in} distances
                        {forward} distance
                    ```
            12:
                story_text: |
                    We can use functions to draw more complex figures with less code.
                    ### Exercise 1
                    Fill the function so that three squares are created. If you want the image to look nicer, you can make the lines between the squares white.

                    ### Exercise 2
                    The code can be made even shorter. Place the final lines into a `{repeat}` so the figure remains the same.

                    ### Exercise 3
                    Create your own drawing with different figures.
                    Change both the number of figures with the `{repeat}` and the shape of the figures in the `{define}`
                example_code: |
                    ```
                    {define} square
                        {repeat} 4 {times}
                            {turn} _
                            {forward} _
                    {call} square
                    {forward} 50
                    {call} square
                    {forward} 50
                    {call} square
                    ```
    turtle_draw_it:
        name: Draw it!
        default_save_name: Draw it
        description: Draw this picture with the turtle
        levels:
            1:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                        Rectangle <img src="https://github.com/hedyorg/hedy/assets/80678586/77aa99d5-cd8f-4969-b49d-e8fed34ac550" width="100">
                        Square <img src="https://github.com/hedyorg/hedy/assets/80678586/03b96c2c-7b94-4032-9f9f-3f3b13573623" width="200">
                        Stairs<img src="https://github.com/hedyorg/hedy/assets/80678586/d4301e62-ec66-4031-827c-7d21f73ba106" width="200">
                    </div>
            2:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                    Triangle <img src="https://github.com/hedyorg/hedy/assets/80678586/e974b62c-f0cf-445a-8bd4-5ad9f1f71204" width="100">
                    Arrow <img src="https://github.com/hedyorg/hedy/assets/80678586/803d8f42-9708-448c-82ea-d035697f08c9" width="150">
                    Boat <img src="https://github.com/hedyorg/hedy/assets/80678586/94ef7189-442a-4c8f-827d-12a69203c2e9" width="150">
                    </div>
            3:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                    Triangle <img src="https://github.com/hedyorg/hedy/assets/80678586/71e04d98-9545-4614-9caf-a5f179b756a1" width="150">
                    Star <img src="https://github.com/hedyorg/hedy/assets/80678586/421c4d28-cb99-424b-be26-dcae30d65c80" width="150">
                    Arrow <img src="https://github.com/hedyorg/hedy/assets/80678586/3cbebcae-5258-47c5-a6ac-e7ee36c1d1ce" width="200">
                    </div>
            4:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                    Colored Star <img src="https://github.com/hedyorg/hedy/assets/80678586/dbe39006-c050-4833-b5c4-f9d1fb1c0781" width="150">
                    Rainbow <img src="https://github.com/hedyorg/hedy/assets/80678586/2728b10f-9f7f-45ea-964e-5b284033e4f0" width="500">
                    Nested squares <img src="https://github.com/hedyorg/hedy/assets/80678586/f013f9fa-bc68-4c60-b778-2c457799d6f7" width="200">
                    </div>
                example_code: |
                    **Extra** Up for a real challenge? Make sure that the colors of these figures are selected randomly, so that each time you run your programs they'll look differently!

                    ```
                    colors {is} red, orange, yellow, green, blue, purple, pink, brown, gray, black
                    color _
                    ```
            5:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    **Extra** Make only one code that lets the player decide which letter they'd like to see! And can you add even more letters?

                    <div class="w-full flex flex-row gap-2">
                    F <img src="https://github.com/hedyorg/hedy/assets/80678586/8a021b76-c24b-4e7c-b960-48d57f3bcb20" width="100">
                    E <img src="https://github.com/hedyorg/hedy/assets/80678586/12821803-6422-416a-8e36-9902d14e57a4" width="100">
                    L <img src="https://github.com/hedyorg/hedy/assets/80678586/3af6f919-7b67-4ee7-b923-11e56f2b6b24" width="100">
                    </div>
                example_code: |
                    Hint:
                    ```
                    chosen_letter {is} {ask} 'Which letter would you like to see? F, E or L?'
                    {if} _
                    ```
            6:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    **Extra** Let the player decide which color the square should be.

                    ***Extra*** Can you make the letter of your own first name and the flag of your own country too?

                    <div class="w-full flex flex-row gap-2">
                    Square <img src="https://github.com/hedyorg/hedy/assets/80678586/03b96c2c-7b94-4032-9f9f-3f3b13573623" width="150">
                    Letters <img src="https://github.com/hedyorg/hedy/assets/80678586/e75f4fa5-f1f5-4b48-806c-916c28e4e8ad" width="100">
                    Flag <img src="https://github.com/hedyorg/hedy/assets/80678586/877fc337-df80-4185-8005-a6c28904f66e" width="300">
                    </div>
                example_code: |
                    Hint for the square:
                    ```
                    chosen_color = {ask} _
                    ```
            7:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                    Hexagon <img src="https://github.com/hedyorg/hedy/assets/80678586/92e492e1-1593-489b-aaf0-51d2a29755f4" width="200">
                    Triangle <img src="https://github.com/hedyorg/hedy/assets/80678586/3629a5e6-1f02-4851-aab9-c5430ba4a1f1" width="200">
                    Fan <img src="https://github.com/hedyorg/hedy/assets/80678586/1ba2ff71-1230-4fe3-8255-b2c504cf1b4e" width="200">
                    </div>
            8:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    **Extra** The number in brackets indicates in how many lines of code this figure can be drawn. Can you do it in the same amount of lines?

                    <div class="w-full flex flex-row gap-2">
                    Square (3) <img src="https://github.com/hedyorg/hedy/assets/80678586/03b96c2c-7b94-4032-9f9f-3f3b13573623" width="200">
                    Randomly colored star (5) <img src="https://github.com/hedyorg/hedy/assets/80678586/dbe39006-c050-4833-b5c4-f9d1fb1c0781" width="150">
                    Randomly colored spiral (7) <img src="https://github.com/hedyorg/hedy/assets/80678586/9bcdb3f1-367d-4ae0-878f-d09005424a35" width="150">
                    </div>
            9:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    **Extra** The number in brackets indicates in how many lines of code this figure can be drawn. Can you do it in the same amount of lines?

                    **Extra** Give the player a choice which country they would like to see the flag of.

                    <div class="w-full flex flex-row gap-2">
                    Cross (7) <img src="https://github.com/hedyorg/hedy/assets/80678586/76e42c76-aa3f-4863-8eee-ead73c09a186" width="150">
                    Randomly colored nested squares (8) <img src="https://github.com/hedyorg/hedy/assets/80678586/17f878cc-e893-4c10-b32e-a09a50bf08de" width="200">
                    Flags <img src="https://github.com/hedyorg/hedy/assets/80678586/877fc337-df80-4185-8005-a6c28904f66e" width="300">
                    </div>
                example_code: |
                    Hint for the nested squares:
                    ```
                    colors = red, blue, orange, yellow, pink, purple, green, brown, black
                    distance = 120
                    repeat 5 times
                    _
                    ```
                    Hint for the flags:
                    ```
                    country = ask 'which country would you like to see the flag of?'
                    if country is 'the Netherlands'
                        color_1 = red
                        color_2 = white
                        color_3 = blue
                    ```
            10:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                    Nested Hexagon <img src="https://github.com/hedyorg/hedy/assets/80678586/3629e908-3cd5-44ac-bbcd-1f1cceb15654" width="150">
                    Traffic lights  <img src="https://github.com/hedyorg/hedy/assets/80678586/edbbb608-5ff8-4349-85a6-e47809adde43" width="100">
                    </div>
                example_code: |
                    Hint Nested Hexagon:
                    ```
                    distances = 100, 80, 60, 40, 20
                    {for} distance {in} distances
                    _
                    ```

                    Hint Traffic Lights:
                    ```
                    colors = red, yellow, green
                    {for} chosen_color {in} colors
                        color _
                        {repeat} _
                    ```
                story_text_2: |
                    Christmas lights <img src="https://github.com/hedyorg/hedy/assets/80678586/9637ea6d-6edc-4d88-a6f7-10271bfc5371" width="500">
                example_code_2: |
                    Hint Christmas Lights:

                    Start by moving to the left side of the screen with an invisible white line. Then hang up the Christmas lights!
                    ```
                    {color} white
                    {turn} -90
                    {forward} 300
                    {turn} 90

                    colors = red, blue, yellow, purple, green, orange, pink
                    {for} chosen_color {in} colors
                    _
                    ```
            11:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    <div class="w-full flex flex-row gap-2">
                    Beehive (6) <img src="https://github.com/hedyorg/hedy/assets/80678586/ec02469c-907b-4695-9382-d39a8f3c00ec" width="200">
                    Fan (5)  <img src="https://github.com/hedyorg/hedy/assets/80678586/a032ab35-c70c-4e67-9b4e-036a03ecce87" width="200">
                    </div>
                example_code: |
                    Hint Beehive:
                    ```
                    {for} amount_of_combs {in} {range} 1 {to} _
                        {for} walls_of_one_comb {in} {range} 1 {to} _
                            {forward} _
                            {turn} _
                        {forward} _
                        {turn} _
                    ```

                    Hint Fan:
                    Start out like the fan you made in level 7. Or take a peak at the hint for the beehive, because the codes are very similar.
            12:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!
                    Hint: Bracelet designing program. Firstly, define a function **for each shape** you want to use on the bacelet. Then, add the shapes to the bacelet like this:
                    </div>
                    Bracelet Designing program <img src="https://github.com/hedyorg/hedy/assets/80678586/549d7f3a-c492-4b4a-b173-746eb3400951" width="500">
                example_code: |
                    ```
                    {define} draw_a_square
                    _

                    {color} white
                    {turn} -90
                    {forward} 300
                    {turn} 180

                    {for} i {in} {range} 1 {to} 5
                        {color} gray
                        {forward} 100
                        shape = {ask} 'What kind of shape would you like next on the bracelet?'
                        chosen_color = {ask} 'In which color?'
                        {color} chosen_color
                        {if} shape = 'square'
                            {call} draw_a_square
                    ```
            13:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    Street in different sizes <img src="https://github.com/hedyorg/hedy/assets/80678586/cdae9d97-d5ef-46f3-8838-24fa7b5b1bec" width="300">
                    Colored street  <img src="https://github.com/hedyorg/hedy/assets/80678586/9893e0bd-c0f8-49bc-a5a7-217182407724" width="300">
                example_code: |
                    Hint Street in different sizes
                    ```
                    {define} draw_a_house {with} size
                    _

                    {call} draw_a_house {with} 90
                    {call} draw_a_house {with} 60
                    {call} draw_a_house {with} 30
                    ```

                    Hint Colored street
                    ```
                    {define} draw_a_house {with} chosen_color
                    _
                    ```
            14:
                story_text: |
                    ### Exercise
                    Create a program that asks the player how many corners their figure should have and then creates that figure.
                    The figure in the image is the output when the player fills in 10.

                    <div class="w-full flex flex-row gap-2">
                     <img src="https://github.com/hedyorg/hedy/assets/80678586/ee32f40e-dea1-4e7c-a813-3ef63671254b" width="300">
                     <img src="https://github.com/hedyorg/hedy/assets/80678586/3621bf77-527d-41e8-a44f-c5a21bb4ffd2" width="200">
                    </div>
                example_code: |
                    ```
                    {define} calculate_degrees {with} amount_of_corners
                        _ 360 / amount_of_corners


                    {define} draw_figure {with} degrees
                        _
                            {forward} 400/amount_of_corners
                            {turn} _

                    amount_of_corners = {ask} _
                    degrees = {call} _ {with} _

                    {call} _ {with}
                    {call} _ {with}
                    ```
            15:
                story_text: |
                    ### Exercise
                    Recreate the drawings with the turtle!

                    Spiral <img src="https://github.com/hedyorg/hedy/assets/80678586/6943223c-018b-435b-a391-23723cc7a6ad" width="150">
                example_code: |
                    Spiral
                    ```
                    distance = 5
                    {while} distance < 200
                        distance = distance + 5
                         _
                    ```
                story_text_2: |
                    Fan <img src="https://github.com/hedyorg/hedy/assets/80678586/cb671065-b47b-49f0-b298-dcbcd2a5e28f" width="150">
                example_code_2: |
                    Fan
                    ```
                    {define} draw_a_square {with} side
                    _

                    i = 100
                    {while} i > 1
                        _ {with} i
                        _
                        i = i - 3
                    ```
                story_text_3: |
                    Star <img src="https://github.com/hedyorg/hedy/assets/80678586/17564e0a-63e1-4794-8d41-15ac8c1a5a93" width="150">
                example_code_3: |
                    Star
                    A star is usually drawn using 144-degree-turns. If you change this slightly to 143 degrees for example and repeat the pattern multiple times with a {while} loop you can make this figure.
    while_command:
        name: '{while}'
        default_save_name: while_command
        description: while
        levels:
            15:
                story_text: |-
                    We are going to learn a new loop, the `{while}` loop! We continue the loop as long as the statement is true.
                    So don't forget to change the value in the loop.

                    In the example code, we continue until a correct answer has been given.
                    If the correct answer is never given, the loop never ends!
                example_code: |
                    ```
                    answer = 0
                    {while} answer != 25
                        answer = {ask} 'What is 5 times 5?'
                    {print} 'A correct answer has been given'
                    ```
    years:
        name: New Year's
        default_save_name: New Year's Countdown
        description: Countdown to the New Year!
        levels:
            11:
                story_text: |
                    In this level you can use the `{for}` number `{in}` `{range}` command to countdown to the New Year.

                    ### Exercise
                    Fill in the blanks and make the code work!
                example_code: |
                    ```
                    {for} number {in} {range} _ {to} _
                        {print} number
                    {print} 'Happy New Year!'
                    ```