# Creators – Week 3

This week we continued our project from last week, looked at three main topics:

1. Frame rate independence
2. Creating our own properties on our components
3. The Input Manager and getting and using user input

## Frame Rate Independence

We covered how to make our actions independent of frame-rate. The code:

```transform.Translate(Vector3.forward, 20.0f);
```

moves the object 20m in every frame. As we know, frame-rate isn’t generally consistent between machines. On my powerful laptop, I was getting up to 1400 frames per second at fastest. Most ninjas were getting a few hundred frames per second on theirs.

On the other hand, the code here:

```transform.Translate(Vector3.forward, Time.deltaTime * 20.0f);
```

moves the object at a consistent 20m per second on everyone’s machine. The magic is that Time.deltaTime variable. It is the time, in seconds, since the last frame was drawn. The faster the frame-rate, the smaller this number gets and the result is a consistent 20m per second movement.

## Creating Properties on our Components

We can add properties, variables where we can hold and values that we can then use, to our classes by typing a single line into our class definition:

```class MyBehaviour : MonoBehaviour
{
// The new property
public float myProperty = 1.0f;

void Start()
{
}
void Update()
{
}
}
```

Looking at the bits of the line in turn:

• public – The access modifier. Can be private, internal (which we won’t use) or public. If it’s public we can see it in the inspector, and from other classes. If private we can only see and use it within the class itself.
• float – The type of value we are storing. A float is a number with a decimal point. An int (short for integer) is a number without one. We might use an int for counting things, but we use floats for real world measures like speeds and positions, etc.
• myProperty – the name of the variable
• = 1.0f – Assigning a default value to this property. This portion is optional. the ‘f’ after the number is just a hint to the computer that this is a float value.
• ; – The standard semicolon to end the line of code.

## The Input Manager and Using User Input

Unity’s Input Manager contains the definition of input “Axes”. These can contain many ways of doing the same thing.

The default definition of the “Horizontal” axis means it can be triggered by the keys A and D, or the Left and Right arrow keys or by the joysticks or d-pad on a game controller.

This means input is “abstracted”; we can write our script to respond to input, without worrying how that input is generated.

To get the value of input on an access we need to use code like this:

```forwardInput = Input.GetAxis("Vertical");
```

Here we’re getting the value of the axis called “Vertical” and storing it in a variables called forwardInput.

The value of the vertical axis goes between -1 and 1. Minus one means fully down, zero means no input and one means fully up. Because of this range, we can use this value like a switch, multiply it with other numbers. When there’s no input, it’s zero which will zero out the expression it’s part of.

Here’s the fully updated code for our PlayerController.cs:

```using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
public float speed = 20.0f;
public float turnSpeed = 50.0f;
private float horizontalInput;
private float forwardInput;

// Start is called before the first frame update
void Start()
{

}

// Update is called once per frame
void Update()
{
// Get the player input
horizontalInput = Input.GetAxis("Horizontal");
forwardInput = Input.GetAxis("Vertical");

//  Move our vehicle forward
transform.Translate(Vector3.forward * Time.deltaTime *
speed * forwardInput);

// Rotate our vehicle
transform.Rotate(Vector3.up, turnSpeed * Time.deltaTime *
horizontalInput);
}
}

```

## Code for this Week

Updated code is on our GitHub repo: https://github.com/coderdojoathenry/Creators-2022

# Modellers – Game Controller Part 2 – Week 3

Hi folks, thanks again for another fun session today. We continued working on our game controller, moving the thumbsticks into place and creating a D-pad and template button. Here are my video notes:

Here’s a link to the folder where all our files. You’ll find a new file in there called controller_2.blend, containing everything we did this week.

# Explorers Week 3 – Storytelling

We had a great day in Scratch Beginners on Saturday! We created a project in which the Sprites communicated with each other to tell some sort of a story or bad joke, Like I did!

Timing was very important, each sprite had to wait for the other sprite to have their say.

Here are the notes from this week CDA-S9-Week-3-StoryTelling.pdf

We are going to do a great Maths Game this Saturday so we look forward to seeing all there.

Martha

Ruaidhri, Julie, Iseult and Eoin

# Modellers – Week 3

This week we quickly introduced a number of techniques and then had an open session where people were free to create their own projects. Our lead mentor Declan got some video showing a few of the projects in progress:

Super work from everyone!

CoderDojo Boo

If anyone is interested in entering the CoderDojo Boo Challenge with one of their Halloween themed Blender creations, the link to enter can be found is here:

https://coderdojo.com/2019/10/01/show-us-what-boo-can-do-its-the-coderdojo-boo-challenge/

Best of luck!

Mirror Modifiers

The mirror modifier saves us time when working on a symmetrical model (that is, a model that is a mirror image of itself across the X, Y or Z axis).

3D Cursor and Adding New Meshes in Edit Mode

The 3D cursor is the point in our scene where new content is added. We can move the 3D cursor easily by selecting one or more parts of the model, pressing SHIFT-S and then choosing “Cursor to Selection”. If more than one thing is selected, the cursor will be in the middle of the selection.

A reference image can be very useful when modelling. One can be inserted from the Add menu (look for Image|Reference). It is a good idea to untick “Align to View” most of the time. You can rotate the image to the orientation you want, or move it and/or scale it once it’s imported.

# Explorers – Week 3 – 2018, Your First Game!

Hi everyone!

Wow! what a fantastic turnout on Saturday again, 79 ninjas in the room! plus a few adults!

I hope you had a good time, I know that I really enjoyed it. There was a really great atmosphere and energy in the room.

A special thank you to Mentor Julia for getting 14 loaner laptops working for us this week, so that everyone that wanted to participate, could. Another thank you to the other Mentors in the room, Eoin and Ruaidhrí, it makes my job easy when they can get around the room and help out when needed. You are doing a great job.

One of the first things we must do before we start anything is make a plan.

We quickly learn when we begin our coding that it is very important to test our code as we go along. Making mistakes is good, but we must learn from them by spotting them (testing) and fixing them.

I am attaching my notes in PDF for you. CDA-S7 Week_03-FeedingtheFish.pdf

We will continue to add to the game next week but don’t worry if you weren’t here this week, I will have a copy of the game so that you can join in.

See you all nest week!

Martha and the Explorers Mentors, Julia, Eoin and Ruaidhrí

# Creators – Basic Scripting

This week we were joined by some additional ninjas, welcome! We had to do a little revision of the first week’s content and probably didn’t manage to get quite a much done as I’d hoped.

Let’s review what we did manage to get done.

Embed a simple script in a web-page

The first thing we did was to create our folders for this week and then create a brand new HTML file called index.html. We then embedded a simple script in our html file using the tag, like this:

`window.alarm("I'm alarmed");`

When we opened our page in Chrome, our message popped up as an alert.

Seperate that script into its own file

We then created a new file in our folder called script.js. We cut out everything from in between our and tags and pasted it into this new file:

`window.alarm("I'm alarmed");`

and in our HTML file we gave the tag the name of this file instead, using the src= attribute (short for “source”) :

Our script continued to work as before, as we’d hoped.

The advantage of moving scripts into their own files is that as we get more scripts and these scripts get more complex, keeping them all within the HTML file gets messy and difficult to work with.

Developer Tools

The developer tools build into Chrome, and some other browsers, help us see what is happening with our pages and scripts and helps us to fix them when they’re not working correctly.

To open the developer tools, open the menu in Chrome (the three dots in the upper-right of the program) and select More Tools | Developer Tools.

The console, part of the developer tools, is a place for us, as programmers, to write out things that will help us check if our script is doing what we want it to do. Ordinary users never see what developers write to the console.

To write to the console, we changed our script.js to read:

`console.log("I'm alarmed");`

The message box stopped appearing and this message could only be seen by looking at the console.

Basic Script Concepts

The most important basic concept in programming is that of a variable. A variable is just a place to store something and a name to refer to it by. We can make a new variable, in this case called a, like this:

`let a;`

The first word, let, is known as a keyword and tells JavaScript “we’re going to make a new variable”. The name of the variable, in this case a, comes next and finally a semi-colon (;) to show that this line is finished. The semi-colon is how we mark the end of a command in JavaScript and it’s an easy thing to forget.

We quickly made this example more complex:

```let a = 4;
let b = 5;
let c = a + b;

console.log("c");
console.log(c);```

In this extended example we defined three variables called a, b, and c respectively. Not only do we define them, we also assign them a value (using the operator =) at the same time. The first two are just given a simple value, but c has a value calculated from adding a and together.

The two console.log() line are to show the difference between actually writing the letter c to the console (as in the first line) and writing the value of the variable called c to the console (as in the second line).

Strings

Strings are how we hold a piece of text in a program. Strings are surrounded by quotations marks:

`"This is a string"`

I didn’t mention the last day, although I mean to, that JavaScript also allows strings with single quotes, which many other programming languages do not:

`'This is also a string'`

We experimented with changing our script so that instead of numbers we set our variable to strings:

```let a = "4";
let b = "5";
let c = a + b;

console.log("c");
console.log(c);```

and in the console saw the perhaps surprising result:

```c
45```

We determined that when we have two number variables the operator + does normal addition but when one or both are strings it makes a new string with the two stuck together (this is often called “concatenation”).

We introduced the following four mathematical operators:

• + : Plus does addition
• – : Minus does subtraction
• * : Asterix does multiplication
• / : Forward-slash does division  (don’t confuse with back-slash \)

Conditions

We looked at a simple condition. This allows us to choose between two options based on whether a check was true or not:

```if (c < 1){
console.log("c is less than one")
}
else {
console.log("c is greater than one")
}```

The keyword if  starts this check. The thing we’re testing is then inside roundy brackets (). Here we’re checking “is c less than one?”. After this we get a block of code (contained in the curly brackets {}) to do if it is true. Here we’ve also added (which is optional, you don’t have to have this if you don’t need it) the keyword else and another block of code to do if it is not true.

Basic Functions

Functions perform an action. They contain a bunch of commands to run together.

They’re great where we’re doing the same thing repeatedly but from different places and they help to logically break-up and organise our scripts.

Here’s a basic function that just writes to the console:

```function SayHi(){
console.log("Hi");
}```

The keyword function indicates that we’re going to define a function. Next comes the function name, SayHi in this case, followed by roundy brackets (), followed by a block of code surrounded by curly brackets {}. Inside the curly brackets are the commands that make up this function.

To make this function actually run we need this in our script:

`SayHi();`

Without this the function would never run. Functions only run when we “call” them.

Function Arguments

Sometimes it’s nice to be able to give a function more information about what we want to do. A function can take several values as input, these are called arguments.

Let’s imagine we don’t want our function to log the same thing to the console every time. We want to tell it what to write. Let’s see what that looks like:

```function MyFunction(what){
console.log(what);
}

MyFunction("Testing the function");```

Here our function is defined as before, but we have a name, what, inside the roundy brackets. Firstly, this means that when you call the function, you’re expected to provide a value. Secontly, inside MyFunction(), we have a new variable, here called what, containing the supplied value and usable like any normal variable.

Finally here’s a more complex example with two arguments:

```function Divide(m, n){
return m / n;
}```

There’s a new keyword here, return. This means “send back this value to the place that called me”. Let’s see how we might use it:

```let a = 4;
let b = 5;
let c = Divide(a, b);```

The third line here both calls the Divide() function and stores the value sent back.

P5.js

We had the briefest of introductions to P5.js and a flying visit to the new P5.js web editor. We’ll follow up properly on these next week.

Files from this week can be found on our GitHub page.

# Explorers – Week 3 2018- Maths Game

Another great week, a lot of work was done in the Explorers room. Hope you all had fun making our Maths game!

A player picks a level of difficulty and the computer chooses 2 random numbers to add (subtract or multiply- whichever you choose!) together and show the numbers to the player. Fr this we needed 2 SPRITES and 4 VARIABLES called SCORE, LEVEL, NUMBER1 and NUMBER2 as well as 2 BACKDROPS.

The player then has to enter an answer to the equation and the computer tells them whether they are wrong or right.

We repeated the ask/answer questions 5 or 10 times. Can you figure out where the REPEAT loop fits?

We also had a second sprite who reacted positively to correct answers BROADCAST and negatively to wrong answers BROADCAST. You can use whatever sprites you like and change their look whatever way you like. One coder added a puppy as their second and had him bark whenever an answer was correct.

After all the questions were asked we had the 1st Sprite SAY – Game Over! and BROADCAST Game over so that the backdrop changed and music played. There are two ways to change the backdrop- see below! Here are this weeks notes in PDF CDA-S7-Week_3_18-MathsGame.pdf

Also I have uploaded the finished game to the www.Scratch.mit.edu website, just use the login details in the notes.

See you next week

Martha

# Explorers Week 3 – Improving last Weeks Game!

Hi everyone,

Can you believe the crowds we had again last week, another record 251 Ninjas and Parents attended Coderdojo Athenry last week.

We were adding to and improving our game from last week. We added a sprite that would catch the fish and decided what could or would happen when this occurred.

We discussed how to make a game more fun we have to add some complexity to it….we need to make it harder to play!! so to this end we used some code from our operator palette to add some randomness.

I also introduced Variables and how we can use them to keep track of things like Score or Lives.

I am attaching the notes from last week as PDF CDA-S6-Week_03-FirstGame_Part2

See you all this Saturday again. We will be starting a new game and Ill need your help.

Martha