## We started with a basic plan:

• 1 Piano Sprite
• 3 Button Sprites
• Record
• Stop
• Play
• A list to store all the possible Piano notes.
• A list to store the tune being played.

Luckily Scratch comes with a Piano Sprite, which we used and expanded it to fill the width of the screen.

Next step was to create the list of all the notes, there are 14 keys on the Piano so we need at least 14 notes in our list.

We found out what notes are possible by using one of the Sound blocks and looking at what was possible

This gave us our list of possible notes:

Now on to the code…

We needed to work out what key on the Piano had been clicked, and convert it to a number between 1 and 14 so we could play the correct note from the list.

This required some tricky calculations, to convert the Mouses “X” position to a positive integer between 1 and 14.

• First we added a number to make X always positive
• Second we divided that by the size of a note.
• And finally we rounded it up, using the ceiling function.

This ended up with the following code and a couple of Variables to store the “Extra” number to make X positive and the size of a note:

Once we had the positive integer we could use it to select the correct note to play from the list:

We did start some of the Buttons, and we will complete them next week. Notes for the buttons will be included then.

## Buttons

In order to make the Piano a bit more usable we added 3 Buttons:

1. Record
2. Stop
3. Play

All three Buttons had two costumes, we used the second costume to change the colour of the Button, this made it easy to see if you had clicked the button or not.

The Record button, simply set a Data Flag to indicate to the Piano code that it should “record” the notes being played in a List variable.

It also flashed while recording was “on”, this is the code for the Record Button:

We also had to add some additional code to the Piano to make sure the notes were recorded:

The Stop button was quite simple, we just set the Data Flag back to 0, and changed the costume for a short while to make it clear that the button had been pressed.

The Play button was a little more complex as it need to read all the items in the List and play the correct notes. It also flashed while playing. This is the code from the Play button:

The Final project looked something like this, you can get a copy from the Scratch Web Site, see the Notes below.

# Notes:

Note: My version of the project has been uploaded to https://scratch.mit.edu you can Sign in using the following details:

• Project Name is : Class-Piano

# Advancers – The Greenhouse Effect

This week in Advancers we looked at the Greenhouse Effect which is a process that occurs when gases in Earth’s atmosphere trap the Sun’s heat. This process makes Earth much warmer than it would be without an atmosphere. The greenhouse effect is one of the things that makes Earth a comfortable place to live.

We started by creating sprites for the Earth, atmosphere, space, the Sun and we used an arrow to represent the flow of heat from the Sun to the Earth and back out to space. We used a costume change on the heat sprite to represent the difference between shortwave radiation from the Sun (yellow) and longwave radiation from the Earth(red).

We made our own blocks so we could reuse some of our scripts and we used the Clone blocks to give the effect of a stream of arrows flowing from the Sun to Earth and back out to space.

Oliver will be back when we return on 09-Nov-2019.

See you all then, happy Halloween!

Declan and Eoin

This week Eoin led the Advancers group, we looked at drawing in Scratch, using the Pen blocks and some simple maths to draw some patterns.

As always, we started with a Plan:

A Plan

1. A Button Sprite – to start the drawing.
2. A Simple Sprite to do the drawing.
3. Some maths to make it draw a Spiral

We started by drawing a square, to draw a square in Scratch we used the Pen down, Turn and Move blocks.

To get a spiral effect we had to make sure that we moved a little bit further each time we drew our square.

We also decided that we should be able to make spirals with different shape so we  needed some variables to help:

• Shape – This would tell us how many sides the Spiral should have
• We made this in to a Slider on the screen so it was adjustable.
• Min value was 3 and Max value was 100
• Degrees – This would tell us how much extra to turn, this made the patterns a lot more interesting.
• Again, we made this one into a Slider so we could adjust it.
• Min value was 0 and Max value was 360
• Size – This was an internal variable, which we used to keep track of how many Steps to move each turn, we also added a little bit to it each turn to make the Spiral pattern.

## The drawing Sprite

This was the Sprite that did all the work. To work out how far we should Turn each time, we divided 360 by the number of Sides, we then added the degrees value to get the strange effects working.

The code ended up looking like this:

## The Button Sprite

We used this sprite to start drawing, we used a broadcast so out button sprite could “talk” to out drawing sprite.

Oliver will be back next Saturday.

See you all then Declan and Eoin

# Rock-Paper-Scissors for 1 and 2 Players

## The Plan

Michael led the Advancers group this week, as Oliver was unavailable. Our plan was to work on 3 versions of Rock-Paper-Scissors:

1. A one-person version where you play against the computer
2. A two-person version where you and a friend play against each other on one computer
3. A two-person version where you and a friend play against each other on different computers, using cloud variables (we did not get around to this)

We began by thinking about how the game works, and what we would need.

In our design, we need three sprites:

1. My Player
2. Opponent (either another player or the computer, depending on the version)
3. Controller (a sprite that displays instructions, does the countdown, and uses broadcasts to sync the start and end

We also need several variables, the most important of which are:

• my-pick: what I pick (rock/paper/scissors)
• other-pick: what the opponent picks
• result: based on the picks, will be set to “I win”, “I lose”, or “Draw”
• number: a random number in the range 1-3 that the computer picks, which we translate into either a value for other-pick of “rock”, “paper”, or “scissors”

## One-Person Version

Here is the logic:

The controller has 5 costumes: one with instructions and four with big numbers 3,2,1,0 for the countdown.

The controller looks after the countdown, and broadcasts messages at the start and end of the countdown. Here is the controller’s code:

My sprite takes my keyboard input. When the countdown is over, it calculates who wins (result). Also, when the countdown is over, it says what I picked, waits 3 seconds, and then says who won.

Here is the start of its code – you will have to figure out the other combinations yourself!

The opponent sprite is the computer. Its sprite picks a random number 1-3 and converts it into a word rock/paper/scissors. It also says what it picked when the time is up. Here is the code:

## Two-Person Version

Here is the design:

In this version, the Controller and My Sprite are the same as in the one-player version, except you might want to change My Sprite to use keys 1,2,3 for Rock, Paper, Scissors.

The Opponent Sprite code is different than before, but it is simpler: the opponent is your friend who will press 7, 8, 9 for Rock, Paper, Scissors, so you just need the code to read those key-presses:

## Possible Enhancements

Here are some ideas:

• You could add sound effects, celebrations, and different costumes
• You could find the rules for a more complex version and implement it: Rock-Paper-Scissors-Lizard-Spock
• You could figure out cloud variables!

# Introduction

This week we built a Mad House with different rooms that you could go into and if you found the right place to click something would happen.

The coding for this project shows how you can re-use code, this has 2 benefits, it makes coding quicker and it also makes all the code consistent, so it all looks the same.

## The Plan

As always, it’s best to have a little bit of a plan.

We decided on the following:

• 4 Rooms – each room would have 2 Sprites
• Clicking a room would make it large
• Clicking the Space key would make the room small again
• We would build one room first so we could copy the code.

## The Code

The first room we created was the Kitchen, the plan was when you clicked on the saucepan, it would boil over.

The Sprites need to fill the whole screen and also need a coloured background to ensure that the Mouse Click is recognised by the code.

These are the 2 Sprites that I built:

It’s not easy to see, but the “On” Sprite has some flames coming out of the pot.

Because we are having 4 Sprites, when the program starts we need to make the Sprite a quarter of it’s full size and move it to one of the corners of the Screen. We also discovered that we would need a variable (a flag) to indicate if the room was Large (1) or Small (0). We did this in the GreenFlag code like this:

We moved to top left corner.
we set the size to 50% (this makes it fill a quarter of the screen
We set the variable to 0 (0 = small, 1 = large)
We set the start costume to the Off costume.

Next step was to write the code for when the Sprite was clicked, this would make the Sprite fill the screen, slowly! It would also set the flag to say that the Sprite was large.

The biggest piece of the code was making the Sprite grow slowly, we did it in 50 steps, changing the size was easy as it just changed by 1 each step, but the X and Y positions were a little trickier as we needed to make sure they were going in the right direction and also changing by the right amount to reach the full size in 50 steps.

Only run this code if we are small (0)
Make we can’t run again set the flag to 1.
Make sure we are in front of the other Sprites

X needed to go from -120 to 0, 2.4 each time
Y needed to go from 90 to 0, so -1.8 each time
Size was simple, 1 each time
And to make it nice and smooth, we wait for .1 of a second in each step.

We then moved on to the code that should run when the Space key is pressed, this would reverse what happened when the Sprite was clicked.

Again, we only run if we are large (1)

The X and Y changes are the reverse of the ones above.

And finally we set the size back to small again (0)

Now we can move on to the code that changes the costume if the user clicked on a certain spot on the screen.

We decided that the user should click on the pan for the costume to change, so first we needed to work out where the pan is on the screen (It’s X and Y positions). This is easy in Scratch 2, when you move the mouse across the Stage the X and Y position is shown at the bottom of the screen, so you just need to place the Mouse on the 4 sides of the Pan and make a note of the X and Y values. X values for the min and max left/right positions, Y values for the min and max up/down positions. Hopefully this picture will help:

\$

We needed to place the Mouse on each of the positions indicated, which then gave use the correct values to place in the code.

The code then looked like this:

We loop forever
Only check X and Y if we are large (1) and the Mouse is clicked. Then check where the Mouse is. This where we use the values we got when checking where the Pan was on the screen.

And that is it for the first Room.

## The Second Room.

Now that all the code is written for the first Room, the second Room becomes a lot easier, we simply duplicate the first Room Sprite and then make the following changes to the code:

• Change the 2 Costumes to something else for this new Room.
• Add a new Variable for this Room
• Update all the places where the Variable is set to this new one.
• Update the starting X and Y positions to one of the other corners of the Stage.
• Update the X and Y changes when the Room grows and shrinks to make sure it is going to the centre of the screen correctly and also back to it’s own corner.
• Update the X and Y values to a new location on the Screen, depending on what you have drawn on your new Costumes.

## The Finished Program

I only got 3 Rooms finished and this what it looked like at the end:

## Next Steps

If you want to improve the program you can look at adding the following:

• The final Room to make it 4 rooms.
• Extra code change the Costume back to normal if the item is clicked again, this would check what Costume is currently, this can be done using the “costume #” from the Looks blocks.

# Notes

The one I did in the class is available on the Scratch Web Site:

# Demos and Pizza – Christmas 2018

Here are photos from our Christmas party and Show & Tell day at CoderDojo Athenry on 08 December 2018.

This slideshow requires JavaScript.

It was fantastic to see the things that our young people had created.

We are very grateful to our supporters in the community around Athenry:

• Clarin College and Principal Ciaran Folan, who are so generous with their space every week
• Galway & Roscommon Education & Training Board, who provide us with an annual Youth Club Grant
• HEA (Higher Education Authority) and NUI Galway School of Computer Science, who provide us with funding towards equipment.
• Medtronic and Declan Fox, who have provided us with a grant linked to Declan’s volunteering
• Hewlett Packard Enterprise and Mark Davis, who provide us with loaner laptops
• Boston Scientific and Kevin Madden, who provide us with the loan of 3D printers.
• Supermacs, who gave us a great deal on the food for the Christmas party

And of course, we are eternally grateful to our wonderful mentors, and to the parents who come along with their children every week. Thank you!

# Introduction

This week we looked at both the Progam project and the Recursion (Branching) project. with a plan to get the output of the Recursion project be the input of the Program project.

## The 2 Projects

### Program Project

The Program project that we did a couple of weeks ago can read a list of commands and get Scratch to perform those commands. We programmed it to be able to:

• Put the Pen Up or Down (P:0 or P:1)
• Move some steps (M:100, where 100 is the number of steps)
• Turn in a different direction (T:90, where 90 is how far to turn)

Each Command was identified by the First Letter.

### Recursion Project

The Recursion project that we did last week can draw a branching Tree pattern. The commands it uses to draw the Tree are:

• Pen Up and Down
• Move some steps
• Turn in a different direction.

## Joining them together

### The Recursion Project changes

You can see that the Recursion project using the same commands as the Program project, but in order to get the commands from the Recursion project to the Program project we have to add some code to the Recursion project.

First job is to create a List, we called it Commands as it will store all the commands that we have run.

We then need to read through the code and wherever there is a Pen Up, Pen Down, Move or Turn we need to add an item to the Commands list.

This is the code and I have highlighted where

You can see that I have marked 7 places where we need to add code to Insert into commands.

When the Inserts are added the code will look like this, just remember that the Insert has to put in the Command letter that Progam needs Joined to the same action that the Recursion code is doing. All the entries go in the last place in Commands.

You can see that we have added a delete all to start and then after the Pen down we have added a P:1 to the last place in Commands.

On the Pen up we have added a P:0 to the last place in Commands.

Then we did the same to the Code that did the drawing of the Branches.

Notice that all the Inserts use a JOIN block, the first section is the Command letter that the Program project is expecting, the second section is the exact same code from the code block above.

For example when the code turns Degrees * -2 the insert also has Degrees * -2 in the second section of the JOIN.

If we run the Recursion Program now, the Commands list will end up with lots of commands, if you have 10 Branches it creates 5117 Commands!

You can see that Commands starts with a Pen Down (P:1) and then starts all the Moves (M:…) and Turns (T:…) and when the Tree is finished there are 5117 items in Commands.

Next step is to Export the Commands to a file. This is simply a case of Right Clicking on the Commands List and selecting Export, just make sure you add a .txt to the file name and also remember where you saved it!

### The Program Project changes

Now we switch projects and open the Program Project.

First thing we changed was to remove all the test code, add some instructions and move the broadcast Play to when the space key pressed.

Next step, click the green Flag and follow the instructions.

So right click on the Program List and Import the file that you Exported from the Recursion Project. And then press the Space key…

Hmm, not quite what we were expecting, but close, the Tree is on it’s side and the drawing has started in the centre of the screen rather than at the bottom.

This test has highlighted a number of problems with our Program Project. We don’t have any code to set the Direction of the Sprite or the X and Y Positions.

Well that is easy to fix, we just add some more Command Letters to our Programming code:

• D:nnn – This will set the Direction to point in, where nnn is the Direction to point in.
• X:nnn – This will set the X Position, where nnn is the X position.
• Y:nnn – This will set the Y Position, where nnn is the Y Position.

This gave us 3 more IF sections in our code like this:

You can see that the new commands are almost the same as the old ones, we just change the letter we are looking for and the code block that gets run if we find one of the New letters.

So D:0 for example will run the Point in Direction code with the value 0 (Up).

### The Recursion Project – more changes

Now this where we have to jump back to the recursion project and add some more Inserts so we can set the correct direction and the correct X and Y positions. Again this is not too difficult, we just look for code that sets the direction or X and Y Positions and add some Inserts into the Command list.

You can see 3 extra insert code blocks, 1 for the point in direction code and 2 for the go to x: y: code block. We have to add 2 here because our Program project is very basic and doesn’t know how to do a Go To…

The Commands List will now get 3 new entries at the beginning and have a total of 5120 commands now. Don’t forget to Export this new list to test the Program project again.

And Finally

### Program Project – test 2

Now that we have the Recursion project writing out the extra Direction and X and Y commands we can test again in the Program project.

And, test 2 is a little better than test 1.

It’s still not perfect, the line is all the same thickness and the colour is always the same.

But you could easily add some more Program letters to add this extra functionality.

# Notes:

As always the code is on the Scratch web site, I have added 2 projects that should produce the results you see above:

• ClassVersion-Program
• ClassVersion-Recursion

# Introduction

This week we created another drawing program using recursion, code that calls itself.

This drawing program will draw a Tree with 2 number of Branches, each Branch will split in 2 and be a little smaller than the previous Branches, The Branches will split X number of times. The finished picture will look something like this when X = 5:

You can see that each branch splits into 2 new branches which are a little thinner and a little shorter than the previous branches, just like a real tree.

## The Plan

Very simple plan for this one, we wanted to be able to control:

1. the amount of branches
2. how many degrees the split should be
3. and what size the first branch would be

So we created a variable for each of these and left them on the Screen as a Slider. We set some minimum and Maximum values as well.

1. Branches (1-10)
2. Degrees (0-180)
3. Size (30-100)

## The Code

As always we have some code that initialises everything when the Green Flag is clicked.

We point upwards, we go to the middle of the bottom of the screen, clear everything, set the Pen colour and then call our code with the values from the Sliders.

Improvement : This should be “When Spacebar Pressed”, then we could just adjust the Sliders and then click the Spacebar to see the next tree.

## The recursive code

This is the code that calls itself, because the Branching code is just the same thing repeated over and over again, but with slightly different values (the branches are getting smaller) it is ideal to use recursive code. You just need to remember that the code next to be able to finish.

The code has two values sent in the number of branches and the size of the branches.

First thing we do is check to see if the number of branches is > 0 otherwise we exit, this is our way to finish the code.

We move (draw the branch), turn and then call ourself with slightly different values.

Just for a bit of variety we change the Pen colour each time as well.

Note: The code for 2019 is slightly different, the middle “turn” code is slightly simpler, we turn anticlockwise and we multiply by 2 not -2, so like this:

Both will work as they both do the same thing.

This results in some quite nice Trees 🙂

## Notes

The project that we built is available on the Scratch Web Site:

Project : ClassVersionRecursion (2018) and Tree-ClassVersion (2019)

Remember, you can put your own projects up there as well if you want.

# Introduction

Todays project is a Calculator that will be able to do simple addition, subtraction, multiplication and division.

There will be a Sprite for each number button and for each type of sum, plus an equal and a clear button, so lots of Sprites. The finished Calculator might look something like this:

## The Plan

As always, it’s a good idea to have a think about what Sprites, Variables and Code you might need, having a think about the Calculator, we came up with the following list:

• Sprites
• 1 Sprite for each number button and one for the decimal point, so 11 in total.
• 1 Sprite for each of the sum buttons, +, -, X and / so 4 in total.
• 1 Sprite for the equals button.
• 1 Sprite for the clear button.
• Variables
• 2 Variables, one for each number in the sum.
• 1 Variable for the sum type.
• 1 Variable for the full sum being calculated.
• 1 Variable for the answer.
• 1 Variable to indicate which number variable we should use.
• Code
• Code for a number buttons.
• Code for the sum type buttons.
• Code for the equal button.
• Code for clear button.

We also thought that it would be a good idea to complete only 1 number button and 1 sum type button and make sure that was all working before adding the rest of the buttons.

## The Variables

We created all the variables we would need first:

• Variables
• NumberOne – this is for the first number in the sum
• NumberTwo – this is for the second number in the sum
• Flag – this is to indicate which number we should be using when a button is pushed.
• Operator – this is to indicate what sum, + – X or / we should be doing.
• Question – this is to hold the complete sum, e.g. 10+23

## The First 3 Sprites

To get things started we created a number Sprite, a plus (+) Sprite and an equal Sprite

All the Sprites are very simple, just a square with text in the middle, just remember to make sure that there is a background colour as well, so the When Clicked code will work correctly.

The code for the Number Sprite looks like this:

The code will check the Flag variable and then add 1 to either the NumberOne or NumberTwo variable, it will also add 1 to the Question variable.

Note that the number 1 is added to whatever is already in the number or question variables.

The code for the + Sprite is very simple:

We just set the Flag to indicate that we should move on to NumberTwo, we set the Operator to + and finally we put the + in the Question as well.

The code for the equal Sprite again is quite simple as we only have one sum type.

We check the value of the Operator and if it is + we add the NumberOne and NumberTwo variables together and put the result in the Answer Variable.

## The other Numbers and Sum types

Once we had the number one, the + and the equal Sprites working it was quite simple to copy and create the other number Sprites. The process was:

• Right click on the Number One Sprite and Copy it.
• Change the Costume of the Sprite to the next Number.
• Change the code of the new Sprite to the next Number.

The bits of the code that we changed are circled in red here:

The other sum types we did the same way, copy the + Sprite and adjust the code circled in red:

As we added the different sum types we also had to add more code to the Equal Sprite, which ended up looking like this, where there is one IF for each sum type:

## The Clear Button

In order to do more sums we also added a clear button, again it is a simple Sprite with some text on it, the code looked like this:

This code was placed on the Stage, as we needed to run it when we clicked on the Green Flag as well as when we clicked on the Clear Sprite.

Notice that most of the variables start with nothing in them, so they are blank, it is only the Flag that needs to have 0 in it.

## Notes

The project that we built is available on the Scratch Web Site:

Project : Class-Calculator

Remember, you can put your own projects up there as well if you want.

# Introduction

We used Scratch to build our own Programming Language

Scratch used different blocks for different commands, so we decided to write our own Programming Language that would then call the different blocks. This may sound strange, but what it means is that we can have a simple and generic Scratch Program that can run code written in a simple file.

## The Plan

• Describe how our language would work.
• Create a List variable to hold all our commands.
• Create a variable to hold the parameter value.
• Write some test commands to the List variable.
• Write some code to get the parameter from our commands.
• Write some code to translate our commands to Scratch commands.

First job was to describe how our language would work with Scratch, we decided that our Programming Language would be able to Draw pictures using the Pen Down, Move, Turn and Pen Up controls.

So we needed 4 commands in our Language, we decided that all the commands would use the same format:

• First Letter would indicate the command
• Second Letter would be a colon “:”
• The rest of the command would be the parameter to use with the corresponding Scratch command.

For example to Move the Sprite 10 steps we would use:

M:10

To Turn the Sprite 90 degrees we would use

T:90

To put the Pen Up or Down we would use:

P:1 for Pen Down
P:0 for Pen Up

And then we wrote some test code to put some of these commands in to our list variable.

If you look closely you can see that the commands should draw a square, Pen down, Move 100, Turn 90 and so on until we have the square drawn.

This code was put under a When Green Flag temporarily for testing.

We then moved on to the code that would get the parameter value from the command, for example the command M:100 the Parameter is the 100 part. We used a Custom Block for this called P1. Which looked like this:

We send in the full command (M:100 for example) and then we read each letter and if we are on the 3rd letter or more, we add the letter to the P1 Variable, this is similar to what we did for the Calculator numbers.

The last piece of the puzzle was to add some code to read every item in the List and process each command, again this was very similar to the Calculator where we have an IF block for each possible command. Something like this:

We read all the items in the Program List and we check the first Letter, this will tell us what Scratch block that we need to use to run the code.

You can see for each item in the Program List we call the P1 block to get the Parameter value, which we then use in the Scratch Block.

This is what the project looks like when you run the Test Program:

## Notes

The project that we built is available on the Scratch Web Site, note that I added a couple more commands Pen Colour and Pen Width as we may need these at some point.