Scratch Tutorial – Colliding Clones Tutorial

Posted on July 4, 2024July 4, 2024 by Holly Billinghurst

Alex & Jordan in Computer Science

Scratch Tutorial – Colliding Clones in Scratch Games

& (more) Linear Search

The tutorial below looks at how to create clones in Scratch and detect whether two different clones have collided with each other using a linear search algorithm. This is an extension of the first clones tutorial – I’d recommend following this first!

This tutorial is a step by step guide for students learning independently. A lesson pack for teachers is available here.

To follow more tutorials from my Alex & Jordan in Computer Science series, please click here.

Creating The ClonesMoving and Tracking ClonesDetecting MovementChecking if the Clones Collide

Creating a Clone of a Sprite

A clone of a sprite is a copy of a sprite that you’ve created. Extra code can be added to give the clones code that runs when they’re created.

This tutorial shows how to create two types of clone which will disappear is they collide with each other. This is the type of algorithm that is useful in shooting games like the Bug Spawner Game where the bugs we need to shoot are all clones of a sprite.

In the same way as the first clone program, start by creating a new sprite that is a simple square on the stage.

Then create another sprite which is a circle of a different colour. Place these in different places on the stage.

These are going to act as the original sprites for our program. When the game runs, we’ll hide these sprites and create three clones of each which will move randomly around the screen.

Because we need to know which clone is moving around, we will give each one an ID number. This works a bit like giving each one a name badge so we know which shape is which.

To do this, we need to create a “local” variable in the Square sprite code called “square id”. We do this by clicking on the Square sprite, then the variables menu. In here, we create a variable checking the “For this sprite only” option when we create the new variable.

We’ll repeat this in the Circle sprite to create a local variable called “circle id”.

To make it easier to see which clone is which, we’ll create duplicates of the costumes for both the Circle and the Square sprites giving each duplicate a number from 1 to 3.

Then we’ll rename each of these costumes to a meaningful name like “circle_3”.

This means that we can set the costume to show the clone ID number when the clones are created.

Although this set up is a bit fiddly, it will save time in the long run!

when green flag clicked
hide
set [circle to destroy v] to [0]
set [square id v] to [1]
repeat (3)
create clone of [myself v]
change [square id v] by (1)
end

Before we can start creating the code, we need to create one more variable called “circle to destroy”, this time setting it to be available to all sprites. This variable will let us know which of the circles has been hit.

In the code of the square, create a starting block for when the green flag is clicked.

We hide the original square sprite because it’s the spawns that we want to add the “real” code to.

We’re going to assign the starting value for “circle to destroy” to 0 so that no circle has been selected (yet!), and “square id” to 1 so we’re ready to create the first clone of the square.

By adding a repeat block we can decide how many squares we want to add to the stage. I’ve used 3 here to match the number of costumes with numbers.

We’re going to create 3 clones of the square and each time increase the clone id variable by one – this will give each clone of the square it’s own number and let us check whether that clone has collided with something.

when I start as a clone
if <(square id) = [1]> then
switch costume to [square_1 v]
end
if <(square id) = [2]> then
switch costume to [square_2 v]
end
if <(square id) = [3]> then
switch costume to [square_3 v]
end
“></p>
</div>

<div class=

The “When I start as a clone” starter block will only run if a new clone is created.

By setting an id number for each clone, we can add an IF statement that will check the clone’s “square id” number and set a matching costume.

In a game, it’s unlikely that you’ll need to have this code that shows the number of a clone, but for examples where you’re testing out new ideas in code, being able to see what’s happening by showing it on the screen can be really helpful.

Some very similar code is used for the “Circle” sprite, although when this is started, there is no block setting the value of “circle to destroy” as this only needs to be set once. Click on the Circle sprite and add the code to create the clones and set the costume for each one:

when green flag clicked
hide
set [circle id v] to [1]
repeat (3)
create clone of [myself v]
change [circle id v] by (1)
end

when I start as a clone
if <(circle id) = [1]> then
switch costume to [circle_1 v]
end
if <(circle id) = [2]> then
switch costume to [circle_2 v]
end
if <(circle id) = [3]> then
switch costume to [circle_3 v]
end
“></p>
</div>
</div>

<div class=

when I start as a clone
show
go to [random position v]
point in direction (pick random (1) to (360))
forever
move (4) steps
if on edge, bounce
end

Before we can test the code, we need to make our clones move around the screen. To do this, we’ll use the same block of code in the Square and Circle sprites.

Because we hid the original sprite, we need to make sure that the clone is visible when it starts.

Just like in our original clones program, to make the random movement easier, we can send each new clone to a random position, then point in a random direction so that when it starts moving, they’re all bouncing in different random directions.

There’s no real end to our simulation (apart from clicking stop), so a forever loop lets the movement & bouncing off the walls just go on forever.

At this point, you should be able to run your code and see your three clones labelled and moving around the screen:

Tracking The Clones

Before we can start detecting whether they’ve collided, we need to store some important information about each clone: the x and y coordinates of each circle.

Because we have more than one circle clone, we need to track each one. We can do this with a list.

In the Variables menu, create a new “global” list called “circle x”. We make this global by selecting “For all sprites” when the list is created.

Repeat this, and create another list called “circle y”.

When you’ve created the lists, make sure that you have the visible on the screen checkbox selected.

When you can see the lists on your screen, click the + icon at the bottom to add three items to each list. Each item will match a clone, so if you have chosen a different number of clones, the number of items in your list must match the number of clones you chose to create.

The final part for tracking is to add two extra blocks of code into just the Circle clone’s movement loop.

This will save the x and y coordinates for each Circle clone into its place in the list (circle 1 will store it’s x & y coordinates in place 1, circle 2 will store it’s x & y coordinates in place 2… etc.).

We use the replace block because we want to constantly track each clone’s position as it moves.

The round block makes sure that we’re storing whole numbers so to make checking the position easier.

Checking if the Clones Collide

The collision block uses some big IF statements, so we’re going to break down building this section into smaller stages!

The algorithm that we’re using to check each circle to see if it’s collided with a square is called linear search. This is a computer science algorithm that looks at each item of data along a list, starting from the beginning and checking each one in turn until the data we’re looking for (a collision) is found, or the end of the list is reached.

Unlike the movement code, we only need to add this to the Square Sprite.

If you’ve already completed the single clone collision program, you’ll notice that this is very similar. In Computer Science, this ability to solve new problems using methods that we’ve used before is called pattern recognition (and it’s why practicing code is so important).

when I start as a clone
forever
set [check for circle v] to [1]
repeat (length of [circle x v])

change [check for circle v] by (1)
end
end

We’ll start by adding another starting “When I start as a clone” block to the Square Sprite code. You may want to put this underneath your other code blocks as some of the lines end up quite long!

We want this to be checking for collisions all the time that the program runs, so a forever loop will go around all of the code.

We’re going to check all of the circles in our list, so we need to create a new variable called “check for circle”. This will start at 1, then count through each circle clone’s id number.

Then add a repeat block which will loop as many times as the circles in your lists. Inside this, we’ll increase the “check for circle” variable by one to look at the next circle.

Our two long IF statements will check that the circle’s coordinates for both x and y are inside the square.

If only one (x or y) matches, then the two sprites haven’t collided. Because of this, we need two IF statements: one to check for the X coordinates, and another for the Y coordinates.

The first of our long IF statements goes inside the repeat block. This checks to see if the X (left and right) coordinates of the circle are in the same range as the square.

Over in the code for the circle sprites, we need to add one final block of code to destroy the circle when it’s hit.

when I start as a clone
forever
if <(circle to destroy) = (circle id)> then
replace item (circle to destroy) of [circle x v] with (1000)
replace item (circle to destroy) of [circle y v] with (1000)
delete this clone
end
end

“></p>
</div>

<div class=

We’ll start by adding another starting “When I start as a clone” block to the Circle Sprite code.

We also want this to be checking all the time to see if it was hit, so a forever loop will go around all of the code.

We’re going to check if the current circle’s ID is the one that’s been hit. We’ll know this if the variable “circle to destroy” is the same as the circle’s id.

If it is, we’ll update the x & y coordinates in the list to a number that can’t be on the stage (this stops the squares from hitting ghosts of the circles), and destroy the circle sprite.

At this point, we’re ready to test that the coordinates are working by running the program and watching the data in the two lists:

And now, you should have a clone experimenter program that lets you detect other types of clone on the screen.

What did you do with your clone program? Let me know below!

Scratch Tutorial – Using Clones in Games

Posted on June 27, 2024July 4, 2024 by Holly Billinghurst

Alex & Jordan in Computer Science

Scratch Tutorial – Using Clones in Scratch Games

& Linear Search

The tutorial below looks at how to create clones in Scratch and detect whether they have collided with each other using a linear search algorithm.

This tutorial is a step by step guide for students learning independently. A lesson pack for teachers is available here.

To follow more tutorials from my Alex & Jordan in Computer Science series, please click here.

Creating a CloneMoving and Tracking ClonesChecking if the Clones Collide

Creating a Clone of a Sprite

A clone of a sprite is a copy of a sprite that you’ve created. Extra code can be added to give the clones code that runs when they’re created.

This tutorial shows how to create an example of simple clones that move around the screen and recognise when they collide with each other.

In more complex games like the Bug Spawner Game, you may need to have clones of two different sprites looking out for each other. But let’s start slowly!

Start by creating a new sprite that is a simple square on the stage.

when green flag clicked
hide
set [clone id v] to [1]
repeat (6)
create clone of [myself v]
change [clone id v] by (1)
end

In the code of the square, create a starting block for when the green flag is clicked.

We hide the original square sprite because it’s the spawns that we want to add the “real” code to.

Before we can create this code, we need to create a “local” variable called clone id. We do this by checking the “For this sprite only” option when we create the new variable.

We start by setting the value of clone id to one because we want it to start counting once we start creating our clones.

By adding a repeat block we can decide how many squares we want to add to the stage. I’ve used 6 here, but you can choose any number (I’d recommend less than 10 though!).

We’re going to create 6 clones of the square and each time increase the clone id variable by one – this will give each clone it’s own number and let us check whether that clone has collided with something.

Moving The Clones

Once a clone is created in our loop, we want it to move around the stage and bounce off the edges.

when I start as a clone
show
go to [random position v]
point in direction (pick random (1) to (360))
forever
move (4) steps
if on edge, bounce
end

The “When I start as a clone” starter block will only run if a new clone is created.

Because we hid the original square sprite, we need to make sure that the clone is visible when it starts.

To make the random movement easier, we can send each new clone to a random position, then point in a random direction so that when it starts moving, they’re all bouncing in different random directions.

There’s no real end to our simulation (apart from clicking stop), so a forever loop lets the movement & bouncing off the walls just go on forever.

At this point you will be able to run your code and see your clones squares bouncing around the screen.

Tracking The Clones

Before we can start detecting whether they’ve collided, we need to store some important information about each clone: the x and y coordinates.

Because we have more than one clone, we need to track each one. We can do this with a list.

In the Variables menu, create a new “global” list called “square x”. We make this global by selecting “For all sprites” when the list is created.

Repeat this, and create another list called “square y”.

When you’ve created the lists, make sure that you have the visible on the screen checkbox selected.

When you can see the lists on your screen, click the + icon at the bottom to add six items to each list. Each item will match a clone, so if you have chosen a different number of clones, the number of items in your list must match the number of clones you chose to create.

The final part for tracking is to add two extra blocks of code into the clone’s forever loop which saves the clone’s x and y coordinates into it’s place in the list (clone 1 will store it’s x & y coordinates in place 1, clone 2 will store it’s x & y coordinates in place 2… etc.).

We use the replace block because we want to constantly track each clone’s position as it moves.

The round block makes sure that we’re storing whole numbers so to make checking the position easier.

If you keep your lists displayed on the stage and run your code, you should see the numbers in the lists constantly updating as the circles move around the stage.

If everything is working, uncheck the boxes next to each list so that your lists are hidden on the stage (this makes the shapes easier to see and you can always make them visible again if you want to test the code).

Note: if the numbers don’t update when you run the code, you may not have set the clone id to “for this sprite only” (local). The easiest way to fix this at this point is to delete the variable and recreate it making sure it is local.

Checking if the Clones Collide

The collision block uses some big IF statements, so we’re going to break down building this section into smaller stages!

when I start as a clone
forever
set [color v] effect to (0)
set [check for square v] to [1]
repeat (length of [square x v])

end
end

Add another starting “When I start as a clone” block. You may want to put this underneath your other code blocks as some of the lines end up quite long!

We want this to be checking for collisions all the time that the program runs, so a forever loop will go around all of the code.

Setting the colour effect to 0 keeps the square at the original colour we designed (remember “color” because Scratch is built in the US).

We’re going to check all of the cloned squares in our list, so we need to create a new variable called “check for square”. This will start at 1, then count through each clone’s id number.

Then add a repeat block which will loop as many times as the items in your lists. Because the square x & square y lists are the same size, it doesn’t matter which one you add here.

when I start as a clone
forever
set [color v] effect to (0)
set [check for square v] to [1]
repeat (length of [square x v])
if <not <(clone id) = (item (check for square) of [square x v])>> then
end

end
end”></p>
</div>

<div class=

Inside the repeat block, we’re going to add an IF block.

This checks to see if the clone we’re looking at is the same as the one we’re testing for collision with (we don’t need to check if it collides with itself!).

So this will only run if the block to check isn’t the current clone.

Inside the IF block we just placed, we’re going to add the first of our really long IF conditions. This will check if the x coordinate of the current clone is in the same range (about 20 x 20 pixels in size) as the x coordinates in the list of the clone to check.

In the example below, the lower square clone would be a collision as its x co-ordinate is 115 which is between the 105 plus 20 (for the width).

Inside this long IF block is another which is very similar, but checks for the Y coordinates of each clone. If we only had the first long IF block, any time the square clones were at the same point left to right, a collision would be detected (even if they were at the top & bottom of the stage).

So if the IF block for the IF finds a collision, we need to go on and check the y coordinate too.

What did you do with your clone program? Let me know below!

Scratch Tutorial – Bug Spawner Game

Posted on June 25, 2024July 11, 2024 by Holly Billinghurst

Alex & Jordan in Computer Science

Scratch Tutorial – Bug Spawner Game

The Scratch tutorial below will show you how to create a bug shooter game in Scratch. This uses clones and a computer science algorithm called Linear Search to find and splat the bugs using our player character (and a few well aimed shoes).

I have created some beginner tutorials which you may find useful to work through before starting your full game: There’s A single clones tutorial which shows how to make clones detect each other, and The Colliding Clones Tutorial which shows how clones of two types can detect each other.

This tutorial is a step by step guide for students learning independently. A lesson pack for teachers is available here.

To follow more tutorials from my Alex & Jordan in Computer Science series, please click here.

Creating The Player SpriteSetting Up The Player ScriptCreating The Bug SpawnersCreating The BugsSpawning Bugs!Creating & Shooting Bugs!Tracking Bugs!Shooting Bugs!Hitting a BugGame Over!Extensions

Creating a Top Down Player Sprite

Start with a blank Scratch project and name it “Bug Spawner game” (or something similar).

Create a new sprite by choosing to draw your own sprite.

Start by adding a coloured circle for the top of the player’s head (this acts like the top of a hat).

Next, add another smaller circle overlapping the right of the first one in another colour. This will act like the peak of a cap to show which way the player character is facing.

Once the shape is in the right position, use the “Back” button to send the peak of the cap to the back of the drawing to create an image that looks like a hat.

Once you’ve drawn your sprite, give it a name of “player”.

Set the size of your sprite to 20. This will reduce the size from 100% to 20% and make it small enough to be a small player on the screen.

Set the X and Y coordinates to 0 (zero) to place the sprite in the middle of the screen.

Setting Up The Player Script

Click on the player sprite & go into the code area.

Create a new variable called “lives”.

In the code area, move the sprite to the centre of the screen (0,0) and set the lives to the starting value of 5.

Creating The Bug Spawners

Imagine the spawners like boxes that our bugs are created in and will be released from. If you’ve used a spawner in Minecraft, this is is a similar object. In our game, these won’t actually be the objects that spawn the bugs, but it will look like it!

Start by drawing a Sprite as a box or square. Alternatively, you can download the Spawner Box image below and upload this as a sprite:

spawner_costume_1 Download

Once you’ve created your sprite, set the name to “Spawner Yellow”.

Set the size to 30 (or about the same size as your player sprite).

Place it in the top right corner of the stage.

The game uses four spawner boxes, but we’ll make sure the first one works before creating any more.

Creating The Bugs

Create a new sprite using the “Beetle” sprite in the Scratch menu.

In the Costumes tab, use the paint fill tool to change the colours of the beetle to Yellow to match the yellow bug spawner.

This is a much quicker way of changing an image that using the paintbrush!

Give the beetle sprite a name of “Yellow Beetle”.

Set the size to 50 (or just smaller than the spawner box).

Move the yellow beetle sprite so it is on top of the yellow spawner box.

Finally, click on direction and use the wheel to rotate the bug so it’s facing the player.

Spawning Bugs!

It will actually be the Yellow Beetle sprite that spawns the other bugs, called “clones”. This helps to keep things simple, so while it might look like an image on the box, this is where all the exciting stuff happens.

Select the Yellow Beetle sprite and click on the code tab.

when green flag clicked
create clone of [myself v]

When the game starts, we want to start with just one new bug that will appear under the spawner box and move towards the player.

The Yellow Beetle sprite does this by creating a “clone” of itself. This uses all the same code as the original yellow beetle without us needing to write extra code for the new bug!

Stay in the Yellow Beetle sprite and click on the code tab.

“When I start as a clone” will run when a new version of the yellow beetle is created by the spawner.

Start the bug in the same position as the Yellow Beetle sprite.

Point the new bug towards the player sprite.

Create a loop that will move the bug 3 steps towards the player until they collide.

Once they collide, delete the new bug from the game.

Shooting Bugs!

To shoot the bugs, we need to start by turning our player around. One of the easiest ways to do this is to use the mouse.

Select the Player sprite and open the code tab.

Add another starting block for when the green flag is clicked.

Create a loop that continues for the whole game that points the player sprite in the direction of the mouse.

Test out your code to see if your player rotates with your mouse.

Creating New Bugs

Because we’re going to have more than one bug to shoot, and we can shoot more than once, we need to be able to keep a track of which bug is which. (If you’ve not completed the Colliding Clones tutorial yet, it’s a good idea to pause and look at this as you’ll be able to see this in a more simple program).

Select the Yellow Beetle sprite and open the code tab.

We’re going to create a new variable for each Yellow Beetle to give it it’s own number. A bit like the little flags our beetles are carrying below, these will be hidden numbers that help us to identify a beetle. We’ll call these IDs.

Because each new bug needs it’s own ID (number), when we need to create a “local” variable in the Yellow Beetle sprite code called “yellow bug id”.

We do this by clicking on the Yellow Beetle sprite, then in the variables menu. In here, we create a variable checking the “For this sprite only” option before clicking OK.

We need to repeat this for a second variable called “max yellow bugs”, but this time, check the “For all sprites” option. This variable will tell the program how many yellow bugs we want to spawn.

We’re now ready to create more bugs!

when green flag clicked
set [max yellow bugs v] to [3]
set [yellow bug id v] to [1]
create clone of [myself v]

Click on the Yellow Beetle sprite, then in the code screen, add two new blocks at the start of the When the Flag is clicked block.

Under here, we’re going to set the starting “max yellow bugs” to 3 so we start with a low number (it will get bigger!). Then, set the yellow bug id to 1 so the first yellow bug has the number 1.

when green flag clicked
set [max yellow bugs v] to [3]
set [yellow bug id v] to [1]
repeat (max yellow bugs)
create clone of [myself v]
wait (1.5) seconds
end

Finally, we’re going to update the code at the end to add a repeat block that will repeat the same number as the max yellow bugs variable.

Adding a wait block after each creation of the clone stops them from arriving on the screen too fast (you can change this to any speed you like, or even set it as a speed variable).

We can test the code at this point to check that our spawner is creating three bugs that appear, move towards the player, then vanish when they reach the player sprite.

Tracking The Bugs

At this point, we can’t tell which bug is which, so we’re going to store them into a list.

We’re going to use this list to track the position of each bug using its X and Y coordinates.

We’ll start by tracking the X (left & right).

With the Yellow Beetle sprite selected, in the Variables menu, create a new “global” list called “yellow x”. We make this global by selecting “For all sprites” when the list is created.

This will appear on the stage as an empty box. Don’t worry that it takes up a lot of space, because we can hide it as soon as we’ve checked that it works.

Lists are like variables, but they can hold more than one piece of data. The data is then found using the position that it is in the list. For our yellow bugs, bug clone number 1 will be saved at position 1, bug clone number 2 will be saved at position 2… etc.

In the code screen of the Yellow Beetle we’re going to create a special block called a Procedure. This is a block of code that can be reused more than once – in this case, all of the code to set up and spawn the yellow bugs!

In the “My Blocks” menu, select “Make a Block” and give it the name “spawn yellow beetles”.

Before you click ok, click on “Add an input” for number so we can tell it how many to spawn. We’ll call this “number of bugs”.

define spawn yellow beetles (number of bugs)
repeat until <(length of [yellow x v]) = (number of bugs)>
add [2000] to [yellow x v]
end
repeat (number of bugs)
create clone of [myself v]
wait (1.5) seconds
end

“></p>
</div>

<div class=

Your new clode block will now show with the word “define” next to it. This means that anything under this block is what happens when the block runs.

With this new clode block, we can make some changes to the Spawner Yellow code to make things more efficient (writing less code is always good!)

We’ll start by adding a repeat block under the spawn procedure that will keep adding new items to the yellow x list until it’s the same length as the number of bugs that we want to create.

These items are given the value 2000 so that they can’t be mistaken for an actual X coordinate (2000 would be waaaaay off the screen!).

You might have noticed that we’re using the pink “number of bugs” instead of the variable “max yellow bugs”. That is because number of bugs is a parameter – that means it’s data that’s passed into the procedure block and often has a different name. When we call this block, we’ll give it (pass in) the value of our “max yellow bugs”.

After the repeat block, we’re going to move the repeat block from under the When the flag is clicked and change the “max yellow bugs” variable for our new “number of bugs” parameter. This means that this code can be run at the start of the game or for a new round later on.

when green flag clicked
set [max yellow bugs v] to [3]
set [yellow bug id v] to [1]
delete all of [yellow x v]
spawn yellow beetles (max yellow bugs)

Finally, under the When the flag is clicked block, we’re going to add two more blocks.

We want to start each new game by clearing the list so it’s ready for our new bugs, then calling the “spawn yellow beetles” procedure giving it the value of “max yellow bugs”.

When we’re using procedure blocks, calling is like shouting over to the block that it’s time to do your thing! As programmers, this means that we can write the code in a block just once and use a single block to run it more than once – less work for us!

The final piece of our yellow bug puzzle is to give each new yellow bug an ID and save where it is inside the list.

We’re going to add one final block to the “spawn yellow beetles” procedure. This increases the yellow bug id by 1 so that each new bug is created with a new id number.

when I start as a clone
forever
replace item (yellow bug id) of [yellow x v] with (round (x position))
end

Add another When I start as a clone block to the Yellow Beetle sprite. In here we want to use a forever block to repeat adding the X coordinate into our list all the time that the sprite clone is on screen.

The “yellow bug id” that we gave our clone helps to find the place in the list to save the data. Rounding the x position makes this easier to see.

when I start as a clone
go to x: (207) y: (163)
point towards [Player v]
repeat until <touching [Player v]>
move (3) steps
end
replace item (yellow bug id) of [yellow x v] with [3000]
delete this clone
“></p>
</div>

<div class=

In the original When I start as a clone block, we also want to update the list when we delete the clone. This helps to prevent “ghosts” on the stage where the X coordinate is still being tracked.

Using 3000 helps to set this outside of the stage, but also lets us know that this is a bug that is deleted (as we set it to 2000 when we created the list).

Running your game now, you’ll be able to see the list track the X coordinates of each bug, then set them to “3000” as they disappear.

Because we need to track both X and Y coordinates, we need to repeat this process using a list for “yellow y”.

Create a new list called “yellow y”
When the flag is clicked, delete everything from the list
In the define procedure add a block inside the first repeat to add “2000” to the “yellow y” list
Inside the forever loop, replace the item as “yellow bug id” in “yellow y” with the rounded y position
When the bug is destroyed, replace the item as “yellow bug id” in “yellow y” with “3000”

Your final Yellow Beetle sprite code, should look like this:

Create a Sprite to Shoot

Create a new sprite using the “Shoes” sprite in the Scratch menu.

In the costumes, select the shoes-a and delete one of the shoes.

Move the remaining shoe into the middle of the screen so it lines up with the middle “target” icon.

Repeat this for all of the shoe costumes so that there is just one shoe in each.

Click on the Code tab for the shoe sprite.

When the game starts, set the original sprite to hidden. This will let us create clones to throw at the bugs, but we won’t see the original.

When the player shoots (throws), a clone will be created of the shoe sprite. The new clone needs to be visible, and if we place this at the back “layer” of the stage, it will look like it’s appearing from under the hat of our player.

The clone of the shoe needs to start at the same position as the player and be facing in the same direction.

As the player faces the mouse, we can set the shoe to do this too.

After this, the shoe will keep moving in that direction until it reaches the edge of the screen.

We also want it to disappear if a bug is hit, but we will create that from the bug’s code.

Finally, click on the “Player” sprite and select the code tab.

Add blocks so that when the space key key pressed, a clone of the shoe is created (which will run the code above).

Hitting a Bug

The final thing that we need to do in this section is to check if the shoe has hit a bug. If it has, we want to remove both sprites.

This requires a long IF statement to check each bug so we’ll break this down, step by step.

We’ll start by creating a new “local variable” called “check yellow”. This will be used to check each possible yellow bug by creating a loop for each yellow bug id.

Remember to check “for this sprite only” because we can fire more than one shoe.

This means that each shoe will check separately for the possible bugs to hit.

We’ll also create a global variable “for all sprites” called “yellow bug to destroy” which will tell the correct yellow bug that it’s been hit.

The algorithm that we’re using to check each bug to see if it’s collided with a shoe is called linear search. This is a computer science algorithm that looks at each item of data along a list, starting from the beginning and checking each one in turn until the data we’re looking for (a collision) is found, or the end of the list is reached.

when I start as a clone
forever
set [check yellow v] to [1]
repeat (max yellow bugs)
change [check yellow v] by (1)
end
end

Start by adding another When I start as a clone block. This will mean that each shoe is checking for collisions.

All the time that the shoe is on the screen, we want to repeat a check for every bug.

Set “check yellow” variable to 1 to start at the first bug, then use a repeat block to increase the “check yellow” variable by 1 until all yellow bug ids have been checked.

Using the “max yellow bugs” variable for this means that no matter how many bugs have been created, it will check all of them.

Our two long IF statements will check that the yellow bug’s coordinates for both x and y are inside the shoe sprite. The + and – 30 in here are the width of the bug (for your code, you may need to adjust this a little bit to match the width of your bug sprites).

We can break this code down into pieces:

IF…
The x position of the shoe is less than…
… the x position that’s stored in the list at the position of the current bug we’re checking…
… plus it’s width
AND
The x position of the shoe is more than…
… the x position that’s stored in the list at the position of the current bug we’re checking…
… minus it’s width
THEN
… we might have a collision!

If only one (x or y) matches, then the two sprites haven’t collided. Because of this, we need two IF statements: one to check for the X coordinates, and another for the Y coordinates.

Our two long IF statements will check that the yellow bug’s coordinates for both x and y are inside the shoe.

The second IF statement checks the Y coordinates and goes inside the first – we only need to run this block If there is a collision for X. If there isn’t a collision for the X co-ordinates, there’s no need to check Y because there wasn’t a collision as both must be true.

If the second IF statement also finds a collision, then we can set the variable “yellow bug to destroy” to the ID of the current bug (check yellow).

Waiting a short time gives the program time to destroy the right bug, then we can delete the shoe too.

The final piece of code to add is an extra IF statement to the Yellow Beetle sprite.

Inside the When I start as a clone loop, the IF statement checks to see if the current yellow bug to destroy is the same as the yellow bug id (it’s ID number). This is like the bug asking “is it my turn?”.

If it has been hit, then just like when the bug reaches the player, the coordinate list is set to 3000, then the bug is deleted.

Game Over

The game will be over, when all the bugs are gone, or when the player runs out of lives.

when green flag clicked
go to x: (0) y: (0)
set [lives v] to [5]
forever
if <touching [Yellow Beetle v]> then
change [lives v] by (-1)
wait (0.5) seconds
end
end

“></p>
</div>

<div class=

In the Player sprite, update the When the flag is clicked block to add a loop at the end to look for collision.

This is much more simple than our shoe & bug collision as there’s only 1 player.

If the player is touching a bug, then reduce the lives variable by 1.

The wait block allows the bug to disappear (otherwise more than one life will be removed).

On the Stage, create a new backdrop for your end screen that will show your player that the game is over.

when green flag clicked
switch backdrop to [backdrop1 v]
forever
if <(lives) < [1]> then
switch backdrop to [backdrop2 v]
stop [all v]
end
end

“></p>
</div>

<div class=

In the code area of the backdrop, add a new When the flag is clicked block.

At the start of the game, set the backdrop to be your original game backdrop, so it always starts with the play screen.

Add a loop to check through the game to see if the player’s lives have run out (are less then 1).

If the player has run out of lives, switch the backdrop to the end screen and stop all scripts to end the game.

Extension: New Rounds

Coming soon!

Alex & Jordan in Computer Science – Pseudocode / Programing Challenge 3

Posted on June 19, 2024June 19, 2024 by Holly Billinghurst

Alex & Jordan in Computer Science – Pseudocode / Programing Challenge 3

Alex is setting up their next storytelling game for game night, writing an epic adventure filled with monsters and magic, and characters that are inspired by their friendship group. Except Alex is stuck. Naming the characters is really hard, so he turns to an algorithm to help devise a method for naming them. They plan to create the names by merging parts of their friends’ real names, using a bit of coding magic to turn them into something new.

Your Task: Crafting Character Names

Alex presents you with a challenge of strings: write a program that

generates character names for each of their friends.
Names are created by:
- combining the first three letters of their first name and last three letters of their surname to create the forename
- combining the first two letters of their last name with a random ending of “ill”, “tal”, or “tye”
Output the created name for each friend along with their original name.

Friend’s Names:

First Name	Last Name
Aria	Patel
Liam	O’Connor
Mei	Zhang
Carlos	Rivera
Fatima	Al-Farsi
Ethan	Johnson
Sofia	Rodriguez
Jayden	Kim

If you’re trying out your code in Python, you can create your code using the editor below. To save your code, click the three bars on the left & select “Download”.

Answers

Click To See Pseudocode Answer

The answer below isn’t the only solution to this problem, but is one solution.

DECLARE firstNames : ARRAY OF STRING // for the whole answer this is 8 names
DECLARE lastNames : ARRAY OF STRING
DECLARE i, newName, newLastName : STRING

firstNames ← ["Aria", "Liam", "Mei"...]
lastNames ← ["Patel", "O'Connor", "Zhang"...]
ending ← ["ill", "tal", "tye"]

FOR i ← 0 TO LENGTH(firstNames) - 1 DO
    newName ← SUBSTRING(firstNames[i], 1, 3) + SUBSTRING(lastNames[i], LENGTH(lastNames[i]) - 2, 3)
    end ← ROUND(RANDOM() * LENGTH(ending)-1,0)
    newLastName ← SUBSTRING(lastNames[i], 1, 2) + ending[end]
    OUTPUT firstNames[i] + " " + lastNames[i] + " is now: " + newName + " " + newLastName
NEXT i

Markdown

Click To See OCR Reference Language Answer

The answer below isn’t the only solution to this problem, but is one solution.

array firstNames[3] of STRING // for the whole answer this is 8 names
array lastNames[3] of STRING

firstNames = ["Aria", "Liam", "Mei"]  
lastNames = ["Patel", "O'Connor", "Zhang"] 
ending = ["ill", "tal", "tye"]


for i = 0 TO firstNames.length -1 do
    
    newName = firstNames[i].left(3) + lastNames[i].right(3)     
    end_index = random(0,ending.length -1)  
    newLastName = lastNames[i].left(2) + ending[end_index]    

    print(firstNames[i], " ", lastNames[i], " is now: ",newName, " ", newLastName)

Markdown

Click To See Python Answer

The answer below isn’t the only solution to this problem, but is one solution.

import random

# Declare the arrays of strings
firstNames = ["Aria", "Liam", "Mei"]  
lastNames = ["Patel", "O'Connor", "Zhang"] 
ending = ["ill", "tal", "tye"]


for i in range(len(firstNames)):
    # this uses slicing to get the substrings of each name
    newName = firstNames[i][:3] + lastNames[i][-3:] 
    
    end_index = round(random.random() * (len(ending) - 1))
  
    newLastName = lastNames[i][:2] + ending[end_index]
    

    print(firstNames[i], " ", lastNames[i], " is now: ",newName, " ", newLastName)

Python

To study with me, you can join me on my iGCSE/GCSE Computer Science, iMedia Games Design, or A Level Computer Science courses.

Alex & Jordan Design An Adventure - The Ultimate iGCSE Computer Science Guide

The practice questions here are extra questions linked to my Pseudocode study book, “Alex & Jordan Design An Adventure” published in May 2024.

The book includes 20 coding problems to solve in pseudocode alongside answers with step by step explanations of how the pseudocode answer solves the problem and what each part means.

There are two editions of the book which follow the pseudocode in the Cambridge iGCSE & AQA GCSE Computer Science specifications, and OCR Reference Language for GCSE Computer Science.

Alex & Jordan in Computer Science – Pseudocode / Programming Challenge 2

Posted on June 19, 2024June 19, 2024 by Holly Billinghurst

Alex & Jordan in Computer Science – Pseudocode / Programming Challenge 2

Jordan has stumbled upon a practical challenge while lending a hand in the kitchen, and they’re inviting you to help out! Instead of helping them clean up, they want you to calculate how long it will take them.

The kitchen floor is made up of tiles which are either green, blue, or red, each requiring a specific amount of time to clean. Green tiles take a minute, blue tiles need a minute and a half, and the red tiles can be sparkling clean in just thirty seconds.

The tiles are shown in a table which Jordan has saved as a 2D array called tiles representing the kitchen’s floor. Help Jordan apply some algorithmic thinking to this everyday task, so they can get back to their game!

Your task: Calculating Cleaning Time

The kitchen tiles are set out using this pattern:

Green	Blue	Red
Blue	Red	Green
Red	Green	Blue

Write an algorithm that:

looks at each of the tiles in the 2D array
calculates the total cleaning time based on the colour of each tile
outputs the total time required to clean the entire kitchen floor

If you’re trying out your code in Python, you can create your code using the editor below. To save your code, click the three bars on the left & select “Download”.

Answers

Click To See Pseudocode Answer

The answer below isn’t the only solution to this problem, but is one solution.

DECLARE tiles : ARRAY[0..n][0..m] of STRING
DECLARE totalTime : FLOAT

tiles ← [["green", "blue", "red"], ["blue", "red", "green"], ["red", "green", "blue"]]
totalTime ← 0.0

FOR i ← 0 TO LENGTH(tiles) - 1 DO
    FOR j ← 0 TO LENGTH(tiles[i]) - 1 DO
        IF tiles[i][j] = "green" THEN
            totalTime ← totalTime + 1.0
        ELSE IF tiles[i][j] = "blue" THEN
            totalTime ← totalTime + 1.5
        ELSE IF tiles[i][j] = "red" THEN
            totalTime ← totalTime + 0.5
        ENDIF
    NEXT j
NEXT i

OUTPUT "Total cleaning time: " + totalTime + " minutes."

Markdown

Click To See OCR Reference Language Answer

The answer below isn’t the only solution to this problem, but is one solution.

array tiles [3][3] of STRING

tiles = [["green", "blue", "red"], ["blue", "red", "green"], ["red", "green", "blue"]]
totalTime = 0.0

for i = 0 TO tiles.length - 1 do
    for j = 0 TO tiles[i].length - 1 do
        if tiles[i,j] = = "green" then
            totalTime = totalTime + 1.0
        else if tiles[i,j] = = "blue" then
            totalTime = totalTime + 1.5
        else if tiles[i,j] = "red" then
            totalTime = totalTime + 0.5
        end if
    next j
next i

print("Total cleaning time: " + totalTime + " minutes.")

Markdown

Click To See Python Answer

The answer below isn’t the only solution to this problem, but is one solution.

import random
# Define the 2D array of tiles
tiles = [
    ["green", "blue", "red"],
    ["blue", "red", "green"],
    ["red", "green", "blue"]
]

# Initialize the total time
totalTime = 0.0

# Iterate over the tiles
for i in range(len(tiles)):
    for j in range(len(tiles[i])):
        if tiles[i][j] == "green":
            totalTime += 1.0
        elif tiles[i][j] == "blue":
            totalTime += 1.5
        elif tiles[i][j] == "red":
            totalTime += 0.5

# Print the total cleaning time
print("Total cleaning time: " + str(totalTime) + " minutes.")

Python

To study with me, you can join me on my iGCSE/GCSE Computer Science, iMedia Games Design, or A Level Computer Science courses.

The practice questions here are extra questions linked to my Pseudocode study book, “Alex & Jordan Design An Adventure” published in May 2024.

The book includes 20 coding problems to solve in pseudocode alongside answers with step by step explanations of how the pseudocode answer solves the problem and what each part means.

There are two editions of the book which follow the pseudocode in the Cambridge iGCSE & AQA GCSE Computer Science specifications, and OCR Reference Language for GCSE Computer Science.

Alex & Jordan in Computer Science – Pseudocode / Programing Challenge 1

Posted on June 19, 2024June 19, 2024 by Holly Billinghurst

Alex & Jordan in Computer Science – Pseudocode / Programming Challenge 1

Alex & Jordan Design An Adventure: Alex Pointing Right

Alex has created a new game called “The Guessing Game.” It’s a quick maths game where the player must uncover a secret number that Alex has chosen between the numbers 1 to 100 (inclusive). As the player guesses, Alex will guide them, indicating whether your guess is correct, too high or too low, repeating this until they’ve guessed correctly.

Alex would like to create an algorithm for other people playing the game in pseudocode to make sure that the game is always played fairly and follows the same rules.

Your task:

Develop a program where

A secret number is generated between 1 to 100 inclusive.
the user inputs their guess between 1 and 100.
If their guess is out of range, an error message is shown.
If their guess is correct, the message “You guessed Right!” is output and the game ends.
Otherwise, the program will indicate whether the guess is too high, too low..
The game continues until the user guesses the secret number.

If you’re trying out your code in Python, you can create your code using the editor below. To save your code, click the three bars on the left & select “Download”.

Answers

Click To See Pseudocode Answer

The answer below isn’t the only solution to this problem, but is one solution.

DECLARE secretNumber, userGuess : INTEGER

secretNumber ← ROUND(RANDOM()* 100,0)  
userGuess ← 0

WHILE userGuess < > secretNumber
    OUTPUT "Guess the number (1-100):"
    INPUT userGuess
    
    IF userGuess < secretNumber THEN
        OUTPUT "Too low. Try again."
    ELSE IF userGuess > secretNumber THEN
        OUTPUT "Too high. Try again."
    ENDIF
END WHILE

OUTPUT "Congratulations! You guessed the number."

Markdown

Click To See OCR Reference Language Answer

The answer below isn’t the only solution to this problem, but is one solution.

secretNumber = RANDOM(1,100)  
userGuess = 0

while userGuess ! = secretNumber
    userGuess = input("Guess the number (1-100):")
    
    if userGuess < secretNumber then
        print("Too low. Try again.")
    else if userGuess > secretNumber then
        print("Too high. Try again.")
    end if
end while

print("Congratulations! You guessed the number.")

Markdown

Click To See Python Answer

The answer below isn’t the only solution to this problem, but is one solution.

import random

secretNumber = random.randint(1,100)  
userGuess = 0

while userGuess ! = secretNumber:
    userGuess = input("Guess the number (1-100):")
    
    if userGuess < secretNumber:
        print("Too low. Try again.")
    elif userGuess > secretNumber:
        print("Too high. Try again.")


print("Congratulations! You guessed the number.")

Python

To study with me, you can join me on my iGCSE/GCSE Computer Science, iMedia Games Design, or A Level Computer Science courses.

The practice questions here are extra questions linked to my Pseudocode study book, “Alex & Jordan Design An Adventure” published in May 2024.

The book includes 20 coding problems to solve in pseudocode alongside answers with step by step explanations of how the pseudocode answer solves the problem and what each part means.

There are two editions of the book which follow the pseudocode in the Cambridge iGCSE & AQA GCSE Computer Science specifications, and OCR Reference Language for GCSE Computer Science.

Using PEEL to Write Assignments

Posted on March 1, 2024March 1, 2024 by Holly Billinghurst

When you’re working or studying in the areas of games design, animation, or computer science, being able to communicate your ideas clearly and effectively is just as important as your technical skills. After all, whether you’re designing the characters for the next Fortnite, creating animations to demonstrate planetary motion, or developing the next big piece of software that hundreds of thousands of people use, your assignments or documentation are the canvas by which you can show your understanding and creativity to your teachers and peers.

That’s where the PEEL technique can come in. PEEL stands for Point, Evidence, Explanation, Link, and it’s a writing strategy that can help you structure your assignments more effectively so that they are well-written and more persuasive, and therefore easier for readers to understand.

POINT

Begin with a clear and concise statement that explains the main idea or argument of your paragraph. For games design, animation, or computer science, this could be a specific feature, technique, or concept you have used in your project. Often, this is a statement of fact.

“I created a sprite using Krita using a pixel art style as the main character of my game.”

EVIDENCE

After providing your point, present the evidence that supports it. For assignments in our fields, this often involves a screen capture of your work. These visuals are more powerful tools to get your point across than words.

This evidence can be improved by annotating your screen captures – perhaps with comments in the code, or by adding call outs to an image.

EXPLAIN

Following your evidence, you can explain how the evidence you’ve given supports the point you’ve made (or why you chose to do a particular thing). This is also your chance to create a deeper understanding of your work for whoever grades your work and to show how your work meets the assignment objectives or mark scheme.

If you’re unsure of how to start this section of writing, think about using the following link words:

“I used four frames in the sprite design BECAUSE this allowed me to create a smoother walking animation showing both feet and arms moving.”

“I chose the Gamemaker software for my project AS it offers extensive support for 2D and 3D game development, enabling more complex scene constructions and character animations.“

“I implemented a binary search algorithm INSTEAD OF a linear search TO reduce the search time complexity from O(n) to O(log n), which improved the efficiency of the program.“

“I applied principles of traditional animation to the character’s run cycle, SUCH AS anticipation and follow-through, RESULTING IN more dynamic and fluid motion.“

LINK

Finally, link back to the assignment question or criteria that you were given for your project. This helps show how your paragraph forms part of your to your assignment’s overall argument or narrative. Linking back to the criteria or the mark scheme will help you to signpost to the marker or examiner that you are aiming for marks in a particular areas and draws their attention to that.

By using the PEEL structure you ensure that every paragraph you write on your assignment is purposeful, coherent and compelling and in so doing, you will not only make your work more readable, but you’ll also develop better, more critical and more analytical projects.

Writing assignments in game design, animation, and computer science can feel like a long process with constant requests to “do more”, but in reality, they are an opportunity for you to show your knowledge outside of an exam in a format where you get to show off your creativity and technical skills.

Using the PEEL technique in your writing can make your arguments stronger and your evidence more compelling.

PEEL in Practice

Imagine that you’re writing an assignment explaining how you learnt to develop Python Turtle code that draws a flower using polygons using an array to hold each shape.

Start each paragraph with a clear statement of what you will discuss.

Point

First of all, start by stating your central idea clearly.

“I learned to develop Python Turtle code to draw a flower using polygons, using an array to hold each petal’s shape, size, and angle. This allowed me to construct the flower by iterating over each petal in the array to draw each shape one after the other.”

This lets the reader know where you are going.

Evidence

Then, use screen captures of your program outputs and code to illustrate your point visually. If you are presenting a feature of the program, show a screen capture that clearly depicts that feature you are discussing. These captures must be crisp and directly related to the main idea that you are explaining.

*This is what my flower looked like once I had entered the data for the first four petals. Each petal is drawn on top of the other so it creates an overlapping effect.*

This code shows the array that holds the data for each petal. The FOR loop iterates through each petal and calls the draw_polygon() subroutine to give the program the co-ordinates of the shape to draw.

Explain

Now explain how your evidence supports your central idea. Tell your viewer (reader) how this feature came into being and just what sheer thought, code, and process of design went into making the logic and features of the solution.

“Creating the code involved defining a subroutine that takes parameters such as the number of sides and length of each side to draw a polygon. This function was used for creating the petals of the flower. By storing each petal’s configuration in an array (e.g., petals = [[5, 100], [4, 80], ...], where the first number represents the number of sides and the second the length of each side), I could use a loop to iterate through this array, drawing each polygon shape on the screen.”

This explanation should make it clear that the evidence presented is your proof of the point.

Link

Finally, explain how the code you have created meets the criteria set. In this example, what part of drawing a flower in Python Turtle have you solved?

“My program solved the challenge of drawing a flower using Python Turtle by breaking down the complex image into simpler polygon shapes. The use of an array to store the configurations of each petal allowed for a dynamic and flexible approach to drawing various polygon shapes...”

If you state your Point, back it up with compelling Evidence and give a thorough Explanation, while always returning to the broader Context, you’ll find your work is clearer, more coherent and more persuasive overall. Remember, the aim is to communicate your ideas effectively: with PEEL you have a structured approach to help you to do exactly that. Adopt the technique and watch as your good assignments become great ones.

How To Write An Assignment Document

Posted on October 9, 2023October 25, 2023 by Holly Billinghurst

Working with wordprocessed documents is something that almost every student will need to know how to do at some point. These are required for coursework for both iMedia and A Level Computer Science, and used in assignments to show our work.

In the following tutorial, I have shown the process of creating an assignment containing elements of a long document, images, and exporting to a PDF.

Instructions for WordInstructions for Google DocsInstructions for Pages

Creating A Document With Headings
Adding Images
Downloading Images from Canva
Adding a Contents Page
Compressing Your Document (reducing file size)
Saving to PDF

Creating A Word Document With Headings

Start by opening a new document in Word. Make sure that the assignment title is at the top with your name. Start by adding in your titles like the image shown below:

Select the text that you want to turn into a heading, then select the type of heading you want from the style menu.

Adding Images From Your Computer

If you have taken a screen capture from your computer, you can paste this straight into your document using Ctrl + V (or Cmd + V on Mac), but if you have a picture saved on your computer, go to Insert –> Pictures –> This Device then select a picture from your folders.

Adding Images From Canva

To add an image from your Canva account, you will need to download a copy to add to your document. To download an image, click Share –> Download.

In the download menu, select .jpg as your download (unless you need transparent areas, in which case use .png). Bring the size down to between 500 – 1000px and set the quality to “small”.

Click on download, then add the image from your Downloads folder using the instructions above for adding a file from your Device.

Adding A Contents Page (for long coursework documents)

These are only needed if you are writing a long piece of coursework or assignment of 10 pages of more – these aren’t needed for weekly assignments!

As you have already followed the instructions above for setting up your headings, your document will be ready to add an automatic table of contents. Click on References –> Table of Contents –> Select your preferred style.

Compressing Your Document

Sometimes you’ll find that your document is too large to upload. Word includes an image compression tool to help make your document smaller.

Once you have added an image to your document, click on the image, then select the blue “Picture Format” menu –> Compress Pictures.

In the pop up menu that appears, uncheck the “Apply only to this picture” so all images are compressed, but leave “delete cropped areas” checked. Select the smallest resolution of Email (96dpi) –> click OK.

Don’t forget to save after compressing!

Exporting Your Document to a PDF

To save your document as a PDF, click File –> Export –> Create PDF. Choose where to save your PDF version to & your document is ready to upload!

Creating A Document With Headings
Adding Images
Downloading Images from Canva
Adding a Contents Page
Compressing Your Document (reducing file size)
Saving to PDF

Creating A Google Doc With Headings

Start by opening a blank document in Google Docs. Make sure that the assignment title is at the top with your name. Start by adding in your titles like the image shown below:

Select the text that you want to turn into a heading, then select the type of heading you want from the style menu.

Adding Images From Your Computer

If you have taken a screen capture from your computer, you can paste this straight into your document using Ctrl + V (or Cmd + V on Mac), but if you have a picture saved on your computer, go to Insert –> Image –> Upload from computer then select a picture from your folders.

If you’re using a tablet or mobile device, Google Docs also allows you to add pictures using your device camera. This is particularly useful for adding hand drawn diagrams or sketches.

Adding Images From Canva

To add an image from your Canva account, you will need to download a copy to add to your document. To download an image, click Share –> Download.

In the download menu, select .jpg as your download (unless you need transparent areas, in which case use .png). Bring the size down to between 500 – 1000px and set the quality to “small”.

Click on download, then add the image from your Downloads folder using the instructions above for adding a file from your Device.

Adding A Contents Page (for long coursework documents)

These are only needed if you are writing a long piece of coursework or assignment of 10 pages of more – these aren’t needed for weekly assignments!

As you have already followed the instructions above for setting up your headings, your document will be ready to add an automatic table of contents. Google Docs will already have a navigation panel to the left, so this is more useful for printed or exported documents.

Click on Insert –> Table of Contents (at the bottom of the menu) –> Select your preferred style.

As you write your document, you can update your contents page by clicking on the table of contents & clicking the refresh icon that appears to the left.

Compressing Your Document

Google Docs automatically compresses any image that you upload to your document, so you’ll have the most optimised version already.

If you want to make any adjustments to your images once you have added an image to your document, click on the image, then select the three dots on the right of the format bar, next select All image options.

Exporting Your Document to a PDF

To save your document as a PDF, click File –> Download –> PDF Document. Your document will be saved in your Downloads folder – don’t forget to move this into a folder on your device. Once downloaded, your assignment document is ready to upload!

Although my courses are run on the understanding that all instructions are provided for Windows & Office, I do understand that not all learners will have access to this.

For ICDL courses, Windows is a prerequisite and other operating systems cannot be used.

For iMedia courses, I strongly recommend that students are using Windows and a Graphics Tablet as this is the standard for all tutorials.

I have included a detailed help video below that covers the same topics as I have written about in the previous tutorials – I’d recommend using the bookmark links on the video as it’s quite long!

Equality and Social Justice in Education

Posted on October 5, 2023November 16, 2023 by Holly Billinghurst

Equality and Social Justice in Education

Much like my post on Open Education & Practice, this is less a blog post, and more a learning journal. As many of you are aware, I’m currently completing a Masters degree in Online Teaching. As part of my second year, I am studying Equality & Justice in education. Part of this is to create a reflective learning journal.

These are my candid reflections on my own practice and thoughts. Unlike my classroom teaching, this will include personally held beliefs & political opinions, however whilst I do not bring these to my classes they do form my ethical base as both an educator and business owner.

Right to Education

Exploring Equality & Equity

Social Justice & Me

The Right to Education?

The Right To Education

Part A

Q1. To what extent do you feel that the ‘universal primary education’ (UPE) right should be upheld as a universal right for all individuals in the world? Why?

I strongly believe this should be a universal right, but feel that “education” isn’t defined clearly enough. For me, this raises the question, “what is a suitable primary education?”.

Testing primary children provides us with data, but is numeracy & literacy enough? My own lived experience is that primary education has changed dramatically over the past 40 years from creating a broad foundation of skills to build upon when I was in primary school in the early 1980s, to a focus on core subjects and high stakes testing which has increased further since my own children attended primary. I certainly don’t remember being stressed about exams and requiring specialist tutors in order to access the “best” schools.

As someone whose children didn’t really fit the mould in secondary and chose to home educate, I believe that there is inherent privilege in being able to educate your children without school: although school isn’t childcare, it does provide parents with the ability to work outside of the home. However, this doesn’t mean that a universal school education is the only source of a suitable education – with that said, I do think that without foundations of education at primary, we don’t learn how to learn independently (or it’s more difficult when learning becomes more formal)

Q2. When could it be problematic? For example, is it still applicable to all educational systems? Should everyone be able to attend primary school? What would happen if there were only one faith-based school available or only a school with a particular political orientation?

– I believe that access to a suitable education for the individual child should be a fundamental right, but the one solution doesn’t fit all.

– I think that everyone should have the opportunity to attend primary school in a place suitable for the child. I don’t believe that this should be legally enforced as it creates a negative attitude towards education.

– where parent educational or religious philosophies don’t align with the single state educational option, having alternative options such as independent schools and home education is important to ensure that education is suitable for the individual. This does create it’s own issues as exposure to other cultures and backgrounds creates empathy. However, if the only option is religious rather than one secular option, that has the potential to skew the education rather than expand it. An example of this being the current educational reforms in Florida where extreme Christian values are restricting access to subjects, books, and open discussion.

Q3. Does a universal right apply equally to primary, higher, technical and professional education in every context? How would you support your decision on this?

This is something that as a concept I do support, which seems at odds with working as a private educator. From a realistic perspective, it’s unlikely that as a society that we will return to the days where education from primary to university was available free at source, and certainly not in my lifetime.

I do, however believe that there should be a universally accessible option for education at all levels. Where parents or learners choose not to follow the universally available path, then much like home education the cost would fall to the learner. However, when the only option is to create lifetime debt in order to access education that ultimately benefits more than just the individual, something has gone wrong in the wider societal context.

Part B

What do you consider to be the broad learning outcomes for all of these learners in your educational setting or in a community with which you are familiar or in which you live? By this, we mean the longer-term impact on these learners, their lives, well-being and livelihood.

Motivation to learn more deeply than just my courses
I’d like to think that for some, this has an impact on their choice of career
Self-confidence to enjoy a subject & be unabashedly nerdy
- This is something that I struggled with. I enjoy learning & that was seen as “uncool” – as an adult, I’ve made peace with this and hope that I show others that it’s ok to enjoy learning.

Are there groups of learners who should have different learning outcomes because it would be problematic to cater for their particular needs within a universal statement of broad learning outcomes?

I don’t believe in a one size fits all approach. Much like the cockpit of the WWII fighter plane, the “average” isn’t fully suitable for anyone.
A universal education doesn’t need to have the same learning outcomes for all.
I strongly hold to the social model of accessibility: an environment can be disabling, but given appropriate access and adaptions, for most people the learning outcomes will be similar. There will always be outliers on either end of the academic scale, but neither should be discouraged from making their own personal progress.

To what extent is there a need for universal learning outcomes or adaptation for diversity and difference amongst the learners you work with?

My learners come from a range of diverse backgrounds, learning needs, and disabilities.
There are universal outcomes in the format of sitting specific exams or externally set assessments.
The default position is to design with universal accessibility in mind, but individuals may require specific adaptations.

Exploring Equality & Equity

In exploring the concept of equity in education, I hold a firm belief that it goes beyond simply providing equal opportunities. This area provides a challenging conversation as tuition is considered a luxury service rather than a fundamental right. It is difficult to reconcile private education with strongly held beliefs on Equality. However, I have chosen to personally earn less as a tutor than as a classroom teacher in order to maintain my own educational philosophy, and protect my physical health.

What ‘equality’ in education means to me

To me, equality in education means ensuring that every individual, regardless of their background or circumstances, has access to the same resources and opportunities. However, equity in education takes this idea further by recognizing that individuals may require different levels of support and resources in order to achieve the same outcomes which I feel is a more important concept.

Equality in education could present as free access to a state agreed curriculum, equal funding for schools, and an equitable distribution of resources such as textbooks, technology, and qualified teachers. Although this may seem sufficient in ensuring equal access, it fails to consider the unique needs and circumstances of each individual student which is where equity comes in.

Dimensions of Equality Relevant To My Practice

As a private tutor working mainly with home-educated learners and private candidates, I have firsthand experience with the unequal distribution of resources in education. I am acutely aware that in order to access my services, students need to have the financial means and support from their families. This creates a barrier for those who come from disadvantaged backgrounds and may not have the financial resources to afford private tutoring.

Another aspect is the digital divide. I operate solely online with a mobile learning platform to deliver asynchronous learning which allows for flexibility and personalized learning, but creates a barrier to access for those who do not have reliable internet connections or access to devices.

What Achieving Equity For Learners Looks Like in My Context

As a small business owner, it is not currently possible for me to provide education free at source as I do not have access to the funding available to state managed schools. However, I engage with open learning by providing self-paced courses in the form of MOOCs and a scholarship place in each class to help mitigate the financial barrier for some students. I am actively exploring the use of AI to maintain personalised feedback for individual learners whilst reducing the cost of delivering my services. At present, it is the personalised feedback that provides value to my students, so I am reticent to remove the “human” aspect.

Perceptions of Equality

My notes on the two broad approaches to eqality:

I read a little further to give myself some context for the reflection:

I think my original ideas closely aligned with equality of opportunity and reading through this section does highlight that removing barriers doesn’t necessarily remove an inability to engage when there are wider societal pressures and issues. As somebody who works in stem I have witnessed the encouragement of girls into computing where barriers are ignored in favour of making resources pink and sparkly (which certainly would not have encouraged me, and did little for the girls that I was working with).

As somebody engaged in home education the equality of outcome appeals in terms of radical change, however positive action is something that I would like to explore more to consider whether the backlash was from a group that was disadvantaged and ignored through the positive action or a group that was no longer the “privileged default”.

I came across this whilst looking for some information Raewyn Connell’s work (particularly after seeing the anger generated in the video comments. What was really interesting was the first reaction was to refer to her as “manly” or gender non-conforming, which largely proved her point).

Social Justice & Me

The context of the word social justice has been co-opted politically to create an image of extremist protestors or ill-informed “hippies”. When presented in different terms such as “teaching for diversity” or “culturally responsive pedagogy”, the politicised imagery is removed.

The quote from EE814 giving an introductory definition of social justice, does make me wonder what underlying beliefs would lead someone to find this objectionable:

” In everyday terms, social justice might be understood as the actions in support of a more just, fairer and more equitable society and education as a site for the enhancement of social justice.”
Unit 3 Introduction – EE814 Open University

In attempting to identify five examples of social justice, I have drawn from current and past experiences:

Example 1 – Respecting Personal Descriptors

Many Inclusivity procedures include a language guide, particularly around disability. The language used within disabled communities changes and not all policies are written with direct input from disabled employees or students.

A personal example of this, is that I describe myself as a “wheelchair user” and a “disabled person”. Both of these are examples of identity first language, where part of who I am is defined by these things. Being corrected by an able bodied person to person first language eg. “no, you are a person with a disability” removes my autonomy to refer to myself in the language most comfortable to me.

I’m also just one individual, so asking an individual how they would prefer specific terms around disability and neurodiversity to be used is important.

Example 2 – Pronouns & Names

As politicised as this is currently, this extends from the point above. Confirming pronouns and preferred names at the start of a course or contact assists everyone. To ensure that learners and their wider contacts are aware that my learning space is a safe place to share this information, I list my own pronouns in my email footer and social media profiles.

As a cis woman, this is not to reaffirm my own gender, but to state clearly that there will be no tolerance of discrimination. I am entirely at peace with having lost clients to this as it is not something I am willing to compromise on.

Example 3 – Dress Codes in School

This is an area where I can draw on from both student and teacher. In high school during the mid-90s, we campaigned for a change in uniform to allow longer skirts (those after us won the right to wear trousers for a short time in the early 2000s), and a change to a PE kit that to a teenager, felt overly exposed. At the time, attitudes towards feminism were changing and our concerns were considered and a compromise was reached.

Later, as a teacher in the early 2010s, a school changed its stance on uniform. They moved towards a much more formal dress code and brought in a teacher & student dress code which was highly gendered. Statements were made about length of skirts and height of buttons to “prevent unwanted attention”.

Subsequently, teachers spent more time addressing uniform infractions than addressing wider issues. In this circumstance, we were required to highlight the length of skirts and my refusal to do so and insistence on highlighting inappropriate behaviour was my stance towards social justice.

Example 4 – Critical Thinking & Misinformation

With the expansion of technology and ability to access information at our fingertips at any time of the day, understanding how to discern factual information from misinformation (or simply poorly researched information) is far more important than it was for previous generations.

In the example below, young learners were using AI generated videos to learn about science and believing this misinformation to be factual.

Whilst embedding critical thinking into the curriculum from a young age will lead to young people challenging the current world views (which is not seen as beneficial by everyone), it also equips them with tools to protect themselves from misinformation and propaganda. The ability to critically analyse a source as an adult is particularly important to enable them to make educated choices within a democratic society.

Example 5 – Facilitating Learning, Not Demanding

Since leaving the traditional classroom, I have created a different identity for myself as an educator. I am no longer referred to as “Mrs Billinghurst”, but as “Holly”, and whilst I create the resources as an instructional designer, and for most learners lead a live online session, the learning that takes place is for the most part as a facilitator with the focus on the learner being engaged. I set homework which is marked, but this is optional and not chased.

My current work uses a connectivist approach with the provision of tools and support from a mentor, but with the learning taking place in a wider context as learners complete practical & theory tasks more independently. It’s certainly not dissimilar to this approach where my learning comes from how deeply I engage with the set tasks – I could choose to skip them and no-one would know, but that would remove a tool from my toolkit when the time for higher stakes assessment arrives.

Philosophy and Discourses

Egalitarianism

This is a useful online video with some useful notes on the concept.

Neoliberalism

I’ve used the same video channel to explain Neoliberalism as the notes are quite detailed.

Normative Theories

Normative Theories in My Setting

If I’m entirely honest, these notes took far longer than simply writing things out as a mindmap, but post-covid I’m not at my best and this really helped to give me space to think about what was being asked.

As an adult who has to keep the brain bees entertained, assumptions on ability are really interesting to me. As a professional, I maintain huge amounts of organisation whilst surrounded by physical chaos. This isn’t something I can “unlearn”, but it is something I employ strategies to cope with (which are mostly effective). There is a dominant neurotypical theory that organisation just takes habit and trying harder – the reality for me is that I’ve spent all of my talent points and forgot to leave any for executive functioning outside of work & study!

Annotated Bibliography

Hidden content

How I Unlocked My Productivity with Flow Club: Online Body Doubling and Its Benefits for Neurodiverse Learners (& Tutors!)

Posted on July 28, 2023July 28, 2023 by Holly Billinghurst

Some of the links provided in this blog post are affiliate links. This means that I may earn a discount for my own flow membership, at no extra cost to you, if you decide to make a purchase after clicking through the link. Any blog with a recommendation, is written with my honest opinions.

As an online tutor and a lifelong learner, I’m always on the lookout for tools that can help me be more productive. If we’re honest, anything that excites the brain bees gets a trial, so recently, I decided to try Flow Club. Usually, these things are great, then fizzle, but this week I attended my 50th session on Flow, so now that I know it works, I wanted to share with you how it has transformed my work and study habits.

What is Flow Club?

Flow Club is a platform that uses the body doubling technique to help individuals focus on their tasks. It’s a virtual space where you can work alongside others in a structured, timed manner. Think of it like a Zoom call with a set of other people who want to get on with some work & will hold you to account if you just sit there and faff!

As someone who mainly works from home, it can get lonely, but when I’m in the office being “in a flow meeting” also stops people from quite literally interrupting my flow. The platform allows you to schedule focused work sessions, making it easier to stay on task and get things done.

What is Body Doubling?

Body doubling is a technique often used to help people with neurodiversity, particularly those with ADHD, to focus better. The concept is simple: the presence of another person working silently alongside you can create a calming effect, helping to increase focus and productivity.

Imagine you’re in a room with a friend, both of you working quietly on your own tasks. Even though you’re not interacting, the mere presence of your friend can make it easier for you to concentrate on your work. This is the essence of body doubling and its effects are exponentially more powerful if you struggle with focus or anxiety.

Body Doubling and Neurodiverse Learners

For neurodiverse learners, particularly those with ADHD, body doubling can be a game-changer. ADHD can make it challenging to focus on tasks, especially those that require sustained attention like revision or completing assignments and homework. Body doubling can help create a sense of calm and focus, making it easier to stay on task and get things done.

For example, a student with ADHD might find it easier to concentrate on their homework if they’re in the same room with a friend who’s also working quietly. This isn’t dissimilar from going to a library to do your homework (fond memories of the late 1980s & 90s there!) – you’re not directly interacting with others studying in the library, but because you all have a similar focus, it’s easier to get into the flow of studying.

How I Use Flow Club

I’ve found Flow Club to be incredibly helpful when I need to focus on longer tasks, such as marking student work or updating my website. The platform’s structure of timed work sessions helps break down large tasks into manageable chunks, making it easier to stay focused and make progress. In fact, this blog was finished thanks to me joining a 60 minute pomodoro session.

In the session we:

join and type in a short list of what we want to get done in that hour
take 5 minutes for everyone to say what their session goals are & say hi (this might be verbal or typed)
work quietly for 20 minutes while the host shares music which can be muted if you want
take a 5 minute optional break for water & a stretch
work quietly for another 20 minutes
take 5 minutes at the end to say what we achieved (there’s the accountability!)

… then join another!

Flow Club has also been instrumental in helping me complete assignments for my postgraduate course with the Open University. With several 4000 word assignments to complete alongside running a company, and wrangling my own home ed teens, Flow’s structure of timed work sessions helps break down large tasks into manageable chunks, making it easier to stay focused and make progress. It’s also nice seeing familiar faces in some groups and no matter what weird & wonderful time I’m working, there’s a flow session running.

Flow Club for Students

It’s important to be aware that these are video calls with strangers, so like any platform, if you’re under 18 these should be used with a parent / guardian with you at all times, and I would recommend with your camera off. Consider this similar to an open Discord call & take the same safety precautions.

For learners, particularly for A Level and beyond, Flow Club can be a game-changer. Because the platform was built for professional people working from home, there’s an automatic expectation that everyone will be working and supportive of each other. This not only helps with focus and productivity but also aids in time management. By scheduling work sessions, studying becomes a concrete plan rather than an abstract idea. This can be particularly helpful during exam periods when managing study time effectively is crucial. For me, it also means that I get a regular reminder to stop & drink some water – without pomodoro I’d be more dehydrated than my house plants!

The Flexibility of Flow Club

One of the features I love about Flow Club is the option to join sessions with or without verbal communication. This means you can choose a session that suits your preference or your current environment. I’ve even joined a session from my garden while updating my calendar!

Another great feature is the music played by hosts during sessions. This can help create a conducive work environment and further enhance focus. You can listen to my current “Eat the Frog” host playlist here. Not everyone plays music with lyrics – my sessions tend to run on a Friday afternoon as I attack the distance learning marking, so upbeat helps, but others use lo-fi, classical, or bring your own.

Get Extra Freebies

As I host sessions, you can use my affiliate link, this will let you try Flow Club for 14 days for free, instead of the usual 7-day trial. Whether you’re a tutor, a student, or anyone looking to improve their focus and get more done, I highly recommend giving Flow Club a try.

Karen Plant

February 13, 2022.

My Y10 son is studying Computer Science as an extra GCSE via online 1:1 tuition with Holly. He finds the lessons really engaging and is definitely getting more than enough from them to achieve a high GCSE grade when he sits the exam. Holly provide parents with feedback after every lesson and virtual parents evenings are also held. I know I can ask a question at any time and Holly will quickly get back to me. I would definitely recommend TeachAllAboutIt as a private tutor provider.

armyrlc1

February 12, 2022.

I would recommend this company to anyone - when I first got in contact Debbie was so accommodating with all my questions and wanted to do the very best in placing my son asap. Zach's teacher Carly & Paul have supported Zach tremendously over the last couple of terms. Setting homework if wanted and feeding back by email to me, I felt that Zach has really been listened too and the tutors really think about their students individually. Anne from finance was very helpful when I didn't understand the invoice and took the time to go over it with me. Teach all about it is somewhere I would recommend without hesitation everyone is very helpful and Zach has jumped two grades since being there and now tells me he loves math. Thank you all so much - we really do appreciate it.

Leila W

Holly is an experienced, dedicated, hardworking, kind, supportive, knowledgeable and encouraging Computer science teacher. My daughter enjoys her lessons and her progress is impressive. Many thanks and all the best! Leila

The Raven Queen

August 6, 2021.

My children have attended online coding workshops with Holly and her colleagues throughout lockdown and my son was lucky enough to attend the DnD club during our recent holiday to England. The staff are always friendly and professional both online and in person. They managed to engage 5 very bored children remotely (which is, frankly, a miracle) and my son enjoyed the DnD club immensely and wants us to move so he can go every week!

Darren Gearing

July 16, 2021.

Attended the Google Analytics training coordinated with the Worthing Chamber of Commerce, a great morning of learning & discussion, well arranged, a very good presentation & appropriately put together. Highly recommend. Thank you.

Magyck

June 15, 2021.

TeachAllAboutIt provided excellent 1-1 tuition to help get me through my A-levels. The tutors were excellent all around and tailored my course content to suit my needs / styles of learning / interests. I would thoroughly recommend them to anyone who wants to further their learning!

Ali Rose

June 10, 2021.

My Year 12 son has received a year of 1-1 A level Computer Science tuition with Holly and her colleague. He has enjoyed the course immensely, established great relationships with his tutors, who combine professionalism with friendly approachability. He is already achieving his A grade and is aiming for A*. I have every confidence he can achieve it through Teach All About It.