Instructor Guide & Answer Key

say("Hello Class");

Challenge needs at least two say() lines. Any strings are correct.

say("My first JavaScript challenge:");
say("I can make the computer show my words.");

let heroName = "Mia";
let power = "moon jump";

say(heroName);
say(power);

Builder:

let playerName = "Ari";
let score = 10;
let badge = "Star Coder";

say(playerName + " earned " + score + " points.");
say(playerName + " unlocked: " + badge);

Challenge needs two variables used in say():

let petName = "Pixel";
let petPower = "laser purr";

say(petName);
say(petPower);

let hasKey = true;

if (hasKey) {
  say("Open the treasure door.");
}

Builder uses a comparison:

let playerScore = 12;
let hasEnoughPoints = playerScore >= 10;

say("Score: " + playerScore);

if (hasEnoughPoints) {
  say("Unlock the rainbow shield.");
}

Challenge:

let hasMagicMap = true;

if (hasMagicMap) {
  say("Show the secret path.");
}

for (let i = 1; i <= 5; i++) {
  say("Jump number " + i);
}

Challenge needs a loop that prints ≥ 3 messages:

for (let step = 1; step <= 3; step++) {
  say("Robot step " + step);
}

function cheer() {
  say("You can code!");
}

cheer();
cheer();

Builder with parameters:

function introduce(name, power) {
  say(name + " uses " + power);
}

introduce("Nova", "spark jump");
introduce("Milo", "shield glow");

Challenge: any function called twice:

function celebrate(item) {
  say("The robot found " + item + "!");
}

celebrate("a star");
celebrate("a badge");

let backpack = ["map", "snack", "flashlight"];

say(backpack[0]);
say(backpack[1]);
say(backpack[2]);

Builder:

let badges = ["helper", "debugger", "builder"];

for (let i = 0; i < badges.length; i++) {
  say("Badge " + (i + 1) + ": " + badges[i]);
}

Challenge: own array, show ≥ 3 items:

let missionItems = ["star", "key", "rocket"];

for (let i = 0; i < missionItems.length; i++) {
  say("Pack the " + missionItems[i]);
}

let robot = {
  name: "Bolt",
  power: "star scanner",
  score: 10
};

say(robot.name);
say(robot.power);
say(robot.score);

Builder passes the object to a function:

let hero = {
  name: "Nova",
  tool: "debug wand",
  level: 3
};

function showHero(character) {
  say(character.name + " carries a " + character.tool);
  say("Level " + character.level);
}

showHero(hero);

Challenge: own object, ≥ 3 properties:

let game = {
  title: "Star Rescue",
  goal: "pick up the star",
  lives: 3
};

say(game.title);
say("Goal: " + game.goal);
say("Lives: " + game.lives);

class Robot {
  constructor(name, power) {
    this.name = name;
    this.power = power;
  }

  introduce() {
    say(this.name + " uses " + this.power);
  }
}

let helper = new Robot("Bolt", "star scanner");
helper.introduce();

Builder — two objects from one blueprint:

class Character {
  constructor(name, tool, level) {
    this.name = name;
    this.tool = tool;
    this.level = level;
  }

  showCard() {
    say(this.name + " carries a " + this.tool);
    say("Level " + this.level);
  }
}

let nova = new Character("Nova", "debug wand", 3);
let milo = new Character("Milo", "loop boots", 4);

nova.showCard();
milo.showCard();

Challenge:

class GameLevel {
  constructor(title, goal) {
    this.title = title;
    this.goal = goal;
  }

  start() {
    say("Level: " + this.title);
    say("Goal: " + this.goal);
  }
}

let levelOne = new GameLevel("Star Rescue", "pick up the star");
levelOne.start();

class Player {
  constructor(name) {
    this.name = name;
    this.items = [];
  }

  collect(item) {
    this.items.push(item);
    say(this.name + " collected " + item);
  }
}

let player = new Player("Bolt");
player.collect("star");
player.collect("key");

Builder adds score + status:

class Player {
  constructor(name) {
    this.name = name;
    this.score = 0;
    this.inventory = [];
  }

  collect(item, points) {
    this.inventory.push(item);
    this.score = this.score + points;
    say(this.name + " found " + item);
  }

  showStatus() {
    say("Score: " + this.score);
    say("Items: " + this.inventory.join(", "));
  }
}

let explorer = new Player("Nova");
explorer.collect("star", 10);
explorer.collect("badge", 5);
explorer.showStatus();

class Player {
  constructor(name) {
    this.name = name;
    this.items = [];
  }

  collect(item) {
    this.items.push(item);
  }

  hasItem(item) {
    return this.items.includes(item);
  }
}

let player = new Player("Bolt");
player.collect("star");

if (player.hasItem("star")) {
  say("Mission complete!");
} else {
  say("Keep searching for the star.");
}

Challenge — win rule with two requirements:

class Game {
  constructor(title) {
    this.title = title;
    this.score = 0;
    this.items = [];
  }

  earn(item, points) {
    this.items.push(item);
    this.score += points;
  }

  checkWin() {
    if (this.items.includes("star") && this.score >= 10) {
      say(this.title + " won!");
    } else {
      say("Keep playing.");
    }
  }
}

let game = new Game("Star Rescue");
game.earn("star", 10);
game.checkWin();

function canWin(items, score) {
  return items.includes("star") && score >= 10;
}

say("Test 1: " + canWin(["star"], 10));
say("Test 2: " + canWin(["key"], 10));
say("Test 3: " + canWin(["star"], 5));

Challenge:

function canFinishLevel(items, score) {
  return items.includes("star") && items.includes("key") && score >= 15;
}

function check(name, actual, expected) {
  if (actual === expected) {
    say(name + ": pass");
  } else {
    say(name + ": needs debugging");
  }
}

check("all requirements", canFinishLevel(["star", "key"], 15), true);
check("missing key", canFinishLevel(["star"], 15), false);
check("low score", canFinishLevel(["star", "key"], 5), false);

class MiniGame {
  constructor(title) {
    this.title = title;
    this.score = 0;
    this.items = [];
  }

  collect(item, points) {
    this.items.push(item);
    this.score += points;
    say("Collected " + item);
  }

  finish() {
    if (this.items.includes("star") && this.score >= 10) {
      say(this.title + " complete!");
    } else {
      say("Keep building your game.");
    }
  }
}

let game = new MiniGame("Robot Star Quest");
game.collect("star", 10);
game.finish();

Challenge — a full example students can model on:

class AdventureGame {
  constructor(hero) {
    this.hero = hero;
    this.score = 0;
    this.items = [];
  }

  collect(item, points) {
    this.items.push(item);
    this.score += points;
  }

  play() {
    this.collect("star", 10);
    this.collect("shield", 5);

    if (this.items.includes("star") && this.score >= 15) {
      say(this.hero + " wins the adventure!");
    } else {
      say(this.hero + " keeps exploring.");
    }
  }
}

let finalGame = new AdventureGame("Nova");
finalGame.play();

class Creature {
  constructor(name, sound) {
    this.name = name;
    this.sound = sound;
  }

  speak() {
    say(this.name + " says " + this.sound);
  }
}

let pixel = new Creature("Pixel", "beep");
pixel.speak();

Challenge — own class, two objects, one method each:

class PowerUp {
  constructor(name, points) {
    this.name = name;
    this.points = points;
  }

  activate() {
    say(this.name + " gives " + this.points + " points");
  }
}

let star = new PowerUp("Star", 10);
let shield = new PowerUp("Shield", 5);

star.activate();
shield.activate();

class RobotPet {
  constructor(name) {
    this.name = name;
    this.energy = 3;
  }

  play() {
    this.energy = this.energy - 1;
    say(this.name + " played. Energy: " + this.energy);
  }
}

let pixel = new RobotPet("Pixel");
pixel.play();
pixel.play();

Challenge — property changed by a method called twice:

class GameCharacter {
  constructor(name) {
    this.name = name;
    this.health = 5;
  }

  takeHit() {
    this.health -= 1;
    say(this.name + " health: " + this.health);
  }
}

let hero = new GameCharacter("Nova");
hero.takeHit();
hero.takeHit();

class RobotPet {
  constructor(name, energy) {
    this.name = name;
    this.energy = energy;
  }

  status() {
    say(this.name + " has " + this.energy + " energy.");
  }
}

let pets = [
  new RobotPet("Pixel", 3),
  new RobotPet("Bolt", 5),
  new RobotPet("Zara", 4)
];

for (let pet of pets) {
  pet.status();
}

Challenge — ≥ 3 objects, loop calls one method on each:

class PowerUp {
  constructor(name, points) {
    this.name = name;
    this.points = points;
  }

  activate() {
    say(this.name + " gives " + this.points + " points");
  }
}

let powerUps = [
  new PowerUp("Star", 10),
  new PowerUp("Shield", 5),
  new PowerUp("Key", 3)
];

for (let powerUp of powerUps) {
  powerUp.activate();
}

class GameCharacter {
  constructor(name) {
    this.name = name;
  }

  introduce() {
    say("I am " + this.name + ".");
  }
}

class Wizard extends GameCharacter {
  castSpell() {
    say(this.name + " casts a sparkle spell!");
  }
}

let hero = new Wizard("Nova");
hero.introduce();
hero.castSpell();

Builder — one parent, two children:

class Creature {
  constructor(name) {
    this.name = name;
  }

  move() {
    say(this.name + " moves across the map.");
  }
}

class Dragon extends Creature {
  breatheFire() {
    say(this.name + " breathes a tiny practice flame.");
  }
}

class Unicorn extends Creature {
  heal() {
    say(this.name + " shares healing light.");
  }
}

let dragon = new Dragon("Ember");
let unicorn = new Unicorn("Luna");

dragon.move();
dragon.breatheFire();
unicorn.move();
unicorn.heal();

Challenge — parent + one child adding a method:

class Tool {
  constructor(name) {
    this.name = name;
  }

  use() {
    say("Using " + this.name + ".");
  }
}

class MagicTool extends Tool {
  glow() {
    say(this.name + " glows with extra power!");
  }
}

let wand = new MagicTool("Star Wand");
wand.use();
wand.glow();

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    say(this.name + " makes a sound.");
  }
}

class Cat extends Animal {
  speak() {
    say(this.name + " says meow.");
  }
}

class Dog extends Animal {
  speak() {
    say(this.name + " says woof.");
  }
}

let animals = [new Cat("Pixel"), new Dog("Bolt")];

for (let animal of animals) {
  animal.speak();
}

Challenge — two children overriding the same method:

class Power {
  constructor(name) {
    this.name = name;
  }

  use() {
    say(this.name + " is used.");
  }
}

class SpeedPower extends Power {
  use() {
    say(this.name + " makes the hero zoom!");
  }
}

class ShieldPower extends Power {
  use() {
    say(this.name + " blocks the next hit!");
  }
}

let powers = [
  new SpeedPower("Lightning Boots"),
  new ShieldPower("Bubble Shield")
];

for (let power of powers) {
  power.use();
}

class Player {
  constructor(name) {
    this.name = name;
    this.health = 10;
  }

  takeDamage(amount) {
    this.health -= amount;
    if (this.health < 0) {
      this.health = 0;
    }
  }

  heal(amount) {
    this.health += amount;
    if (this.health > 10) {
      this.health = 10;
    }
  }

  status() {
    say(this.name + " has " + this.health + " health.");
  }
}

let hero = new Player("Nova");
hero.takeDamage(3);
hero.heal(1);
hero.status();

Challenge — a protected value with sensible rules:

class BankAccount {
  constructor(owner) {
    this.owner = owner;
    this.balance = 0;
  }

  deposit(amount) {
    if (amount > 0) {
      this.balance += amount;
      say(this.owner + " deposited " + amount + " coins.");
    }
  }

  spend(amount) {
    if (amount <= this.balance) {
      this.balance -= amount;
      say(this.owner + " spent " + amount + " coins.");
    } else {
      say("Not enough coins.");
    }
  }

  report() {
    say(this.owner + " has " + this.balance + " coins.");
  }
}

let account = new BankAccount("Kai");
account.deposit(8);
account.spend(3);
account.report();