Ashi's Synth Quest

Mission goal: Unity installed, a project called SynthQuest created, and you can name the four main panels without looking.

Unity is a game engine — the professional version of what pygame was doing for you, plus a full visual editor. You'll write C# scripts, and Unity runs them inside its scene.

Step 1 — Unity Hub. Go to unity.com/download and install Unity Hub. Make a free Unity account when it asks (choose the free Personal licence).

Step 2 — the Editor. Inside the Hub: Installs → Install Editor and pick the newest Unity 6 LTS version (6.3 or later — LTS means "long-term support", the stable one). It's a big download; let it run.

Step 3 — the project. Hub → New project → choose the Universal 3D template → name it SynthQuest → Create. (Universal = the URP renderer. We pick it now because in Module 8 it gives us the glow.)

Step 4 — the tour. When the editor opens, find these four panels. Say what each one is out loud — really:

Step 5 — first object. In the Hierarchy: right-click → 3D Object → Cube. Select it and, in the Inspector, set its Position to (0, 0, 0). Press ▶ Play at the top. Nothing moves yet — that's correct. Press ▶ again to stop.

Mission goal: Attach a C# script to the cube, print a message to the Console, and make the cube spin on its own.

In the Project panel (bottom): right-click → Create → MonoBehaviour Script (older versions say C# Script), name it Spinner. Double-click to open it in your code editor, and make it this:

using UnityEngine;

public class Spinner : MonoBehaviour
{
    void Start()
    {
        Debug.Log("Hello from Ashi's first script!");
    }

    void Update()
    {
        // 90 degrees per second, around the y axis
        transform.Rotate(0f, 90f * Time.deltaTime, 0f);
    }
}

Save the file, go back to Unity, and drag the script from the Project panel onto the Cube in the Hierarchy. (A script does nothing until it's attached to an object — remember that; it's the #1 "why isn't it working" of all time.) Press ▶ Play.

Mission goal: Write C# variables of each type, print them, and expose one in the Inspector.

In Python a variable could hold anything. In C# you declare the type and it's locked in:

int score = 0;              // whole number        (score = 0)
float speed = 4.5f;         // decimal — note the f!  (speed = 4.5)
string name = "Ashi";       // text                (name = "Ashi")
bool playing = true;        // true/false — lowercase!  (playing = True)

score += 1;                 // exactly the same as Python
Debug.Log("Score is " + score);   // print("Score is", score)

Why bother with types? Because if you write score = "banana", Python happily lets you and crashes later, somewhere confusing. C# refuses to even run — it underlines the mistake while you type. Armour.

Now the Unity twist. Make a field public and put it outside the methods, at the top of the class:

public class Spinner : MonoBehaviour
{
    public float speed = 90f;   // public + outside methods = visible in the Inspector

    void Update()
    {
        transform.Rotate(0f, speed * Time.deltaTime, 0f);
    }
}

Do it: upgrade your Spinner with a public speed. Then add an int, a string and a bool to Start() and Debug.Log a sentence using all three.

Mission goal: Drive a cube left and right with the arrow keys, at a speed that's frames-per-second-proof.

C# if is Python if with brackets and braces instead of a colon and indentation:

if (Input.GetKey(KeyCode.LeftArrow))
{
    transform.position += Vector3.left * speed * Time.deltaTime;
}
if (Input.GetKey(KeyCode.RightArrow))
{
    transform.position += Vector3.right * speed * Time.deltaTime;
}

Three new words. Input.GetKey(...) is your pygame keys[pygame.K_LEFT]. transform.position is the object's (x, y, z) — a Vector3, which is just three floats in a trench coat. Vector3.left is shorthand for new Vector3(-1, 0, 0).

Do it: new script Mover on a fresh cube (remove/disable Spinner). Arrow keys steer it left and right; give it a public speed and find a value that feels good. Then stop it escaping the camera's view — you know this move from the cat (Mathf.Clamp is your friend, nudge 3).

Mission goal: Turn an object into a prefab and spawn copies of it from code.

A prefab is a saved blueprint of an object — its shape, colour, scripts, everything. Make one by dragging an object from the Hierarchy down into the Project panel. It turns blue. Now you can stamp out copies, by dragging it into the scene or from code:

public GameObject balloonPrefab;   // an empty slot, shown in the Inspector

void Start()
{
    // stamp a copy at (2, 4, 0), with no rotation
    Instantiate(balloonPrefab, new Vector3(2f, 4f, 0f), Quaternion.identity);
}

That public GameObject field shows up in the Inspector as an empty slot. Drag your prefab from the Project panel into the slot. This drag-to-connect move is half of Unity development.

Do it: make a sphere, colour it (right-click in Project → Create → Material, pick a colour, drag the material onto the sphere), prefab it, delete the scene copy, and write a Spawner script on an empty object (right-click Hierarchy → Create Empty) that Instantiates 5 balloons at random x positions in Start(). Random in C#: Random.Range(-7f, 7f).

Mission goal: Detect two objects touching and prove it with a Console message.

In pygame you asked every frame: cat.colliderect(balloon). Unity flips it around — you don't ask, Unity tells you, by calling a specially-named method on your script the moment contact happens:

void OnTriggerEnter(Collider other)
{
    if (other.CompareTag("Player"))
    {
        Debug.Log("Caught by the player!");
    }
}

Three switches have to be on for this to fire — memorise this checklist, it's the eternal trigger recipe:

1️⃣ Both objects have a Collider component (cubes and spheres come with one).  2️⃣ The trigger object's collider has Is Trigger ticked in the Inspector.  3️⃣ At least one of the two has a Rigidbody component (Add Component → Rigidbody) — tick Is Kinematic so gravity doesn't yank it away.

Tags: select your player object, and at the top of the Inspector set its Tag to Player (it's a built-in tag). That's what CompareTag checks.

Do it: put a trigger + Debug.Log on your balloon prefab, tag your Mover cube as Player, drive into a balloon, and watch the Console. Don't move on until the message prints — this recipe must be solid before the build.

Mission goal: The full game: balloons fall, you catch them, the score climbs on screen.

One last piece of vocabulary — text on screen. Unity UI lives on a Canvas: right-click Hierarchy → UI → Text (TextMeshPro) (click Import TMP Essentials if a window pops up — one-time thing). Position the text in a corner. Then from a script:

using TMPro;                      // at the top, next to using UnityEngine

public TMP_Text scoreText;        // Inspector slot — drag the text object in

scoreText.text = "Score: " + score;   // update it whenever the score changes

Mission goal: Design and write — yourself — the data class the entire visualiser will be built on.

First, meet MIDI's one big idea: every piano key has a number. The lowest key on your piano (A0) is 21, middle C is 60, and the top (C8) is 108. Hold that thought — you'll need it in a minute.

Now the C# vocabulary: a plain data class — no using, no MonoBehaviour, never attached to an object. Here's one that has nothing to do with music, on purpose:

public class Wizard
{
    public string name;
    public int level;

    public Wizard(string name, int level)   // the constructor — runs on "new"
    {
        this.name = name;
        this.level = level;
    }
}

And typed lists — Python's [] in armour:

using System.Collections.Generic;             // unlocks List — top of the file

List<Wizard> party = new List<Wizard>();      // party = []
party.Add(new Wizard("Gandalf", 20));         // party.append(Wizard(...))

foreach (Wizard w in party)                   // for w in party:
{
    Debug.Log(w.name + " is level " + w.level);
}

Mission goal: A hardcoded melody appears in the scene as blocks — pitch decides where, timing decides how high up, length decides how tall. This is a freeze-frame of your final visualiser.

This mission is two puzzles, and you're unusually qualified for both.

Puzzle 1 — transcription. Turn Hot Cross Buns into a List of your NoteData objects. You need exactly one anchor: middle C = 60, and each piano key up or down is +1 or −1. You know the tune's three notes; work out their numbers from the anchor. Then decide timing yourself — pick a beat length (something like half a second is comfortable) and write each note's start and length. This is literally you doing sheet-music → data, and no programmer without your piano training gets to skip the hard part like you do. Format, so you're not guessing syntax (one note only — the other sixteen are yours):

song.Add(new NoteData(64, 0.0f, 0.4f));   // one note: pitch, start, length

Puzzle 2 — the mapping. Each block needs a position from its data. You must invent two conversions: pitch → x (so different keys stand in different columns, in keyboard order) and start → y (so later notes sit higher). How is entirely your call — sketch both conversions on paper before you code them.

Mission goal: A full piano keyboard across the bottom of the screen, built by a loop, where any key can light up by pitch number.

This build gets a toolbox, not a recipe. Five new C# tools below — some are exactly what you need, and at least one is a red herring. Which tool fits which part of the problem (and whether you need it at all) is yours to decide. That decision is the mission.

//                                Mon   Tue   Wed    Thu   Fri   Sat    Sun
static readonly bool[] IS_OPEN = { true, true, false, true, true, true, false };

bool wednesday = IS_OPEN[2];   // look an answer up by index

int r = 27 % 10;            // 10 goes in twice (20), remainder 7 -> r is 7
int hour = 31 % 24;         // 31 hours after midnight -> 7 o'clock: % "wraps around"

using System.Collections.Generic;

Dictionary<int, string> squad = new Dictionary<int, string>();
squad[23] = "Ashi";           // store under any number
Debug.Log(squad[23]);         // find it again instantly, from anywhere

float gap = Mathf.Abs(3f - 8f);   // 5 — how far apart, ignoring direction

Last tool — changing a colour from code:

Renderer rend = GetComponent<Renderer>();     // the component that draws this object
rend.material.color = Color.cyan;             // recolour it, live

Mission goal: Hot Cross Buns rains down onto your piano; every note lands on its key exactly on time, and the key lights while the note is "sounding".

One new piece of vocabulary — a clock you own:

float songTime = -3f;          // field: where we are in the song (negative = lead-in)

void Update()
{
    songTime += Time.deltaTime;    // ticks forward in real seconds
}

Now the design decision the whole mission hangs on — and it's yours. The spec: notes must land exactly on time, stay in sync for an entire song, and (dream feature) survive pause and even rewind. You've moved things one way your whole programming life: Pong-style — give it a velocity, add it on every frame, and position is wherever it ended up. Two design questions, on paper:

Q1. Suppose Pong-style movement is off by a tiny amount each frame — a rounding crumb, a stuttered frame. What does minute three of the song look like? And what would "rewind" even mean?

Q2. What do you know on every single frame — the clock, the note's own data — that could pin down where a note should be, so that being wrong is impossible? (Nudge 1 checks your answer.)

Once Q2 is settled, derive the placement itself: given songTime and a note's data, where is the note's bottom edge? One anchor is non-negotiable: at the exact moment songTime == n.start, the bottom must touch the keyboard (y = 0). Do it on paper, and test your candidate expression three ways: plug in "5 seconds before it plays", "the moment it plays", "1 second after". High, zero, below — if your expression says that, you've got it.

One geometric wrinkle you met in Module 3: a cube's position is its centre. If a note is h tall, where must its centre sit for its bottom to sit at your computed y? (You half-solved this at the note wall; now it has to be exact.)

Mission goal: Your visualiser plays a real MIDI file — a song you chose — with hundreds of notes you never typed.

What's in a .mid file? Exactly your NoteData idea: which key, when, how long — plus tempo info, tracks and channels. It's a 40-year-old format and every piano video you've watched runs on it. You could decode the raw bytes yourself (the format is public), but professionals reach for a tested library first. Ours is DryWetMIDI.

Install: the docs live at melanchall.github.io/drywetmidi — find "Using in Unity". Short version: grab the DryWetMIDI.Nativeless release zip from the GitHub releases page and unzip it into Assets/Melanchall/DryWetMIDI. When Unity finishes importing with a clean Console, you're in. Reading install docs and following them is the skill being trained here — it's how you'll add every tool for the rest of your life.

The new vocabulary — a foothold into someone else's classes, which is the point. Here's the way in, plus one worked example — converting a note's start moment into real seconds:

using Melanchall.DryWetMidi.Core;
using Melanchall.DryWetMidi.Interaction;

MidiFile midi = MidiFile.Read(path);        // the whole file, parsed
TempoMap tempoMap = midi.GetTempoMap();     // the tick<->seconds converter

foreach (var note in midi.GetNotes())       // every note in the file
{
    var t = note.TimeAs<MetricTimeSpan>(tempoMap);   // its start, as real time
    float startSec = t.TotalMicroseconds / 1000000f;
    // Each "note" also knows which key it is and how long it lasts.
    // Finding those two is YOUR job — the library's docs list everything
    // a Note can tell you, and the length conversion rhymes with the
    // one above. Welcome to the real skill: reading docs.
}

Where do files go? Make a folder in your Project panel named exactly StreamingAssets — Unity copies whatever's inside it next to the built game. Get the path with System.IO.Path.Combine(Application.streamingAssetsPath, "song.mid"). Free .mid files are everywhere — search "free piano midi" (bitmidi, mutopia…); start with something you can hum.

Mission goal: Every key you physically press lights its on-screen twin, instantly.

Hardware first. Plug the piano into the computer over USB (if it only has round MIDI sockets you need a cheap USB-MIDI adapter). No driver drama on a modern keyboard — the OS just sees a MIDI device. Close any other program that might grab it (only one app can own a MIDI device at a time — future debugging gold).

Install Minis — a small library that feeds MIDI into Unity's Input System. The install teaches a new trick: a scoped registry. In Unity: Edit → Project Settings → Package Manager, add a registry — Name Keijiro, URL https://registry.npmjs.com, Scope jp.keijiro — then in Window → Package Manager → My Registries, install Minis. It pulls in the Input System package; when Unity asks to enable the new input backend and restart, say yes — then go to Project Settings → Player → Active Input Handling and set it to Both, or your Input.GetKey code from earlier modules dies. (That trap costs real developers an afternoon. It just cost you one sentence.)

The vocabulary. Minis is event-driven — remember triggers? The device calls you:

using UnityEngine.InputSystem;   // plus: using Minis; if you name its types

InputSystem.onDeviceChange += (device, change) =>
{
    if (change != InputDeviceChange.Added) return;
    var midi = device as Minis.MidiDevice;
    if (midi == null) return;

    midi.onWillNoteOn += (note, velocity) =>
    {
        // note.noteNumber = the same 21..108 you've used all course
        // velocity        = how hard, 0..1
    };
    // Fingers also LIFT. This event has a twin — you'll want it
    // for checkpoint 5. Guess its name, or skim Minis' README.
};

That (a, b) => { ... } shape is a lambda — a tiny function with no name, defined right where it's handed over. You've been writing named functions since Code Quest Module 3; this is the same thing, minus the name.

And one new tool for the box — whether and where you need it is your call:

using System.Collections.Generic;

Queue<string> letters = new Queue<string>();
letters.Enqueue("first");            // put at the back
letters.Enqueue("second");
string next = letters.Dequeue();     // take from the front -> "first"

Mission goal: Notes and lit keys genuinely glow, and landing notes throw sparks.

How glow works — two halves that must both be on:

1️⃣ Bloom (the camera side): a post-processing effect that makes very bright pixels bleed light. Hierarchy → right-click → Volume → Global Volume → in its Inspector, Add Override → Post-processing → Bloom; set Intensity ≈ 1, Threshold ≈ 1. On your Main Camera, tick Post Processing. (This is why we chose the Universal template in Module 0 — long game.)

2️⃣ Emission (the object side): a material can emit light instead of just reflecting it. Tick Emission on the material, and push the emission colour's Intensity above 1 — that's what makes pixels bright enough for bloom to grab. From code:

rend.material.EnableKeyword("_EMISSION");
rend.material.SetColor("_EmissionColor", litColor * 3f);   // >1 intensity = bloom fuel

Particles: Hierarchy → Effects → Particle System. It's a toy box — play with Start Speed, Start Size, Emission rate, Shape, and Color over Lifetime until you have a spark burst you like. Untick Looping, tick Play On Awake off, prefab it, and fire it from code:

public ParticleSystem sparkPrefab;

ParticleSystem s = Instantiate(sparkPrefab, position, Quaternion.identity);
s.Play();
Destroy(s.gameObject, 2f);     // clean up after itself, 2s later

Mission goal: One app, two modes, your aesthetic — captured on video with real music.