15 March 2026

Scaffolding: Progress Review

 Description:

Our controller is designed for the puzzle game Fireboy and Watergirl, where two players must work together to navigate levels and collect gems. The controller consists of three parts, one for each character and one that connects the two. This design is meant to reflect the cooperative nature of the game by separating the controls for each character. The part that connects the two character controllers contains two potentiometers to control the mouse x and y movement. And has a photoresistor to act as a  left click.

The Fireboy controller will be colored red and the Watergirl controller will be colored blue, matching the characters they represent. Both controllers will be shaped like a diamond, inspired by the collectables found in game. The visual design helps connect the controller to the game's environment and narrative.

The Watergirl controller includes a microphone/sound sensor that allows the players to jump by making a sound, along with a potentiometer for left and right movement. The Fireboy controller also uses a potentiometer for movement, but jumping is triggered by shaking the controller using an accelerometer.


Sketch:



Schematic:




Pseudo Code:

//Normal Game Controls
//Watergirl---------------------------
//(W) = Jump
//(A) = Move Left
//(D) = Move Right
//Fireboy---------------------------
//(Up Arrow) = Jump
//(Left Arrow) = Move Left
//(Right Arrow) = Move Right



//Pseudo Code

//Initialize Circuit Playground Express

//Set mouse X-axis potentiometer value to be an analog pin.
//Set mouse Y-axis potentiometer value to be an analog pin.
//Set photoresistor value to be an analog pin.
//Set Watergirl potentiometer pin to be an Analog Input.
//Set Fireboy potentiometer pin to be an Analog Input.
//Set sound sensor as Analog Input.
//Start accelerometer on Circuit Playground Express.


//Define movement thresholds for potentiometers for both Watergirl and Fireboy.
//Define mouse movement thresholds for potentiometers for mouse x and y axis.
//Define threshold for photoresistor for left mouse click.
//Define sound threshold for jump.
//Define shake threshold for accelerometer.


//Start a Loop
  //Read Watergirl movement with potentiometer value.
    //If potentiometer value is less than left threshold:
      //Send keyboard key "A" (Watergirls left).
    //Else if potentiometer is greater than right threshold:
      //Send keyboard key "D" (Watergirl right).
    //Else:
      //Release Keyboard key "A" and "D" (Stops Watergirl from moving).
  //End If.

  //Read Fireboy movement with potentiometer value.
    //If potentiometer value is less than left threshold:
      //Send keyboard key "Left Arrow" (Fireboy left).
    //Else if potentiometer value is greater than right threshold:
      //Send keyboard key "Right Arrow" (Fireboy right).
    //Else:
      //Release keyboard key "Left Arrow" and "Right Arrow" (Stops Fireboy from moving).
  //End If.

  //Read sound sensor value
    //If sound value is greater than sound threshold:
      //Send keyboard key "W" (Watergirl jump).
      //Delay may be needed to prevent jumping multiple times.
    //End If.

  //Read accelerometer values for (x, y, z)
  //Calculate total shake force.
  //If shake force is greater than shake threshold:
    //Send keyboard key "Up Arrow" (Fireboy jump).
    //Delay may be needed to prevent jumping multiple times.
  //End If.


  //Mouse Controls
  //Read x-axis potentiometer value.
    //Map potentiometer value to mouse x-axis speed.
    //if value is less than center threshold:
      //Move mouse left.
    //Else if value is greater than center threshold value:
      //Move mouse right.
    //Else:
      //Stop all x axis mouse movement.
  //End If.

  //Read y-axis potentiometer value.
    //Map potentiometer value to mouse y-axis speed.
    //if value is less than center threshold:
      //Move mouse down.
    //Else if value is greater than center threshold:
      //Move mouse up.
    //Else:
      //Stop all y-axis mouse movement.
  //End if.

  //Read photoresistor value.
    //if light level is below click threshold:
      //Have it press "Left Mouse Button".
    //Else:
      //Release "Left Mouse Button".
  //End if.


14 March 2026

Team 22 Final - Scaffolding: Progress Review


Controller Description:

    Our controller is for the game “Sort the Court”. In this game, players take the role of a king listening to the requests of their many subjects and subordinates. To respond to the requests, the player must press either the “Y” or “N” keys for the “Yes” and “No” replies respectively. Our controller connects to the setting of this game through being a literal crown the player must wear upon their head to immerse them in their role as the king. In order to play the game with it, the player must answer the question by physically moving their head. An up and down nod will be received as a “Yes” response, while a side to side motion will be read as a “No” response. There will be a bit of visual feedback on the controller through the Circuit Playground Express’s neopixels. The board itself will be placed inside a gem on the front of the crown. When the motion input is detected, the neopixels will light up in response to the player’s choice. A “Yes” will result in the neopixels lighting up green, while a “No” will light up all of the neopixels red.

Controller Sketch:



Controller Schematic:



Pseudo Code:

Create float variable which stores Z rotation value

Create float variable which stores X rotation value

 

Setup

            Serial begin function

            Circuit Playground begin function

            Delay 1000

 

Loop

            Set Z rotation variable

            Set X rotation variable

            Clear circuit playground pixel colors

 

            If Z value is not between the set starting position range

                           Enter Y key on keyboard once

                           Fill all pixel colors with green

                           Delay 2000

 

            If X value is not between the set starting position range

                           Enter N key on keyboard once

                           Fill all pixel colors with red

                           Delay 2000




Team 15 Final Controller Progress Review

 Description:
    For our final controller, we decided on creating the model/toy car idea for "Buck Up and Drive". We choose to design our controller after a model car, as the game is an arcade-racer that only features cars as playable characters. The controller functions by moving the car left and right to simulate steering while the car auto-drives. The user can also press on the roof scoop on the car's ceiling to simulate performing tricks in the air. The car can initiate drifting by pressing down on the hood of the car. The game can also be paused by pressing on the button on the driver's side window. The car model design is inspired after one of the cars that can be unlocked and controlled in the game. The unique inputs of the controller help immerse the user to feel like they are driving the in-game car in real life.

Sketch: 


 

 

 

 

 

Schematic:


Pseudo Code:

    float variable that holds accelerometer input

    boolean variable that holds hood input

    boolean variable that holds roof scoop input

    boolean variable that holds pause button input

    float variable that maps accelerometer values

 

    if statement checking if map variable is less than -2

        simulate left arrow input 

 

    if statement checking if map variable is more than 2

        simulate right arrow input

 

    if statement checking if hood boolean is true

         simulate space bar input

 

    if statement checking if roof scoop boolean is true

        int variable that holds a randomly chosen number between the range of 0 and 1

        if statement checking if random number variable is 0

            simulate up arrow input

        if statement checking if random number variable is 1

            simulate down arrow input

 

    if statement checking if pause button boolean is true

        simulate escape button input

11 March 2026

Final Team 3: Progress Review

Controller Concept
The controller itself is designed to look like the level from Temple Run so it feels like you are moving the character on the path itself. The larger part of the controller will house the mechanisms under the path that the player would run on. The small figure is essentially your joystick, you would move the character above each of the input areas and lift the figure to jump. The full controls are as follows:

  • 1 - Photoresistor: Move Left
  • 2 - Distance Sensor: Jump
  • 3 - Photoresistor: Move Right
  • 4 - Photoresistor: Slide
  • 5 - Button: Start Game
To activate the photoresistors, you would hover the character figure over it to block the light. The distance sensor will detect if the figure is at a certain distance, so when you lift the figure, it will jump. This controller is meant to be immersive to the game itself, looking like you are moving the character through the level in real life.

3D Concept

Schematic

Pseudo Code
p1 = First Photoresistor
p2 = Second Photoresistor
p3 = Third Photoresistor
ds_distance = The current tracked distance detected by the distance sensor
startButton = The start button

IF p1 light level == 0
    Move left

IF ds_distance > distance needed to lift figure
    Jump

IF p2 light level == 0
    Move right

IF p3 light level == 0
    Slide

On Pressed startButton
    Press Space (start game)

10 March 2026

LCD RF ID reader

In this project, I used the Elegoo templates for LCD display- specifically Hello World, along with the RFID template for changing out an ID on a card. Though the provided cards from the kit I was using does not allow for writing, I was able to read them and determine them to have 2 IDs. Using this information, I was able to make the LCD display if there's an acceptable card is placed to it or not. This is a small version of a verification system.
  20260310-160852 1000004578 1000004581



#include <SPI.h> #include <MFRC522.h> #include <LiquidCrystal.h> // initialize the library with the numbers of the interface pins LiquidCrystal lcd(7, 8, 9, 10,5, 4); #define RST_PIN 3 // Configurable, see typical pin layout above #define SS_PIN 6 // Configurable, see typical pin layout above MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance /* Set your new UID here! */ #define NEW_UID {0xDE, 0xAD, 0xBE, 0xEF} byte cardUID[4] = {0x7B, 0x20, 0xF9, 0x3};// blue thing is 53, FC, E6, 2C MFRC522::MIFARE_Key key; void setup() { Serial.begin(9600); // Initialize serial communications with the PC while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4) SPI.begin(); // Init SPI bus mfrc522.PCD_Init(); // Init MFRC522 card // Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory. for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; } // set up the LCD's number of columns and rows: lcd.begin(16, 2); // Print a message to the LCD. lcd.print("Card to Reader"); } // But of course this is a more proper approach void loop() { bool match = true; // Look for new cards, and select one if present if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) { // (note: line 1 is the second row, since counting begins with 0): lcd.setCursor(0, 1); // print the number of seconds since reset: lcd.print("NO CARD "); } else{ for (byte i = 0; i < 4; i++) { if (mfrc522.uid.uidByte[i] != cardUID[i]) { match = false; } } if(match){ lcd.setCursor(0, 1); lcd.print("Allowed! "); } if(!match){ lcd.setCursor(0, 1); lcd.print("NOT Allowed! "); } delay(2000); } /* just checking the id when needed Serial.print("UID: "); for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i], HEX); Serial.print(" "); } Serial.println(); delay(2000); */ }


09 March 2026

Final Team 3 Scaffolding: Concept Review

Jesse Smith and Michael Rowley

The games we chose to work on controllers for were League of Legends and Minecraft. 

https://www.leagueoflegends.com/en-us/

https://www.minecraft.net/en-us

League of Legends is a Massive Online Battle Arena (MOBA) game. Its most common controls are Q, W, E, R, D, and F for abilities. You use the mouse to aim your abilities and right-click to move your character to where your mouse pointer is. These mechanics require precise targeting of abilities, attacks, and movement. 


Minecraft is a sandbox survival and building game where players gather resources, build structures and items, and explore the world. Its most common controls are WASD or the arrow keys for movement, the mouse for aiming, both mouse buttons for mining, interacting, placing, and using objects, and certain buttons used for sneaking, sprinting, and opening the inventory. Numbers on the keyboard are usually used for selecting items; however, the wheel on the mouse can be used to scroll through the items. 


The mechanics could be expressed through an alternate controller to eliminate the use of two hands or stylize the gameplay for thematic purposes. We were most interested in the use of hand and finger gestures to interact with the game and using touchpads to give a different feeling than playing with a keyboard and mouse. We were also interested in making two separate devices interact to form a whole controller. 


Do our controller concepts make the gameplay mechanics feel better, or do they make gameplay too complicated? 

Which controller designs feel the most intuitive for new players?















08 March 2026

Final Team 17 - Scaffolding: Concept Review

Resident Evil

Our motivation for working with the first Resident Evil game was that it employs a fixed camera mechanic, eliminating the need for us to include camera movement in our control scheme. The main mechanics of Resident Evil are exploring the mansion, finding items, and trying to survive the enemies. The player goes through different rooms collecting keys, weapons, and other items that help unlock new areas. You also have to be careful with things like ammo and healing items because they are limited. A lot of the game is about exploring, solving puzzles, and figuring out how to move forward while avoiding or fighting enemies. The core mechanics in Resident Evil might benefit from an alternative controller by making movement feel a little more intuitive. Resident Evil controls the player using a tank controller approach, so finding ways to make the player movement feel smoother could help. In Resident Evil, gestures are shown through the character’s actions. You move around, aim and shoot weapons, open doors, and pick up items. Even though it’s controlled with buttons, the game represents these actions as if you were actually performing them.

Slime Rancher 2

Our motivation for working with Slime Rancher was that it was a game familiar to us so we thought it might be easy to work with. The main mechanics of Slime Rancher are exploring, collecting slimes, and managing them on your ranch. The player uses the Vacpack to suck up slimes, food, and other items, and then shoot them back out into corrals. Feeding slimes makes them produce plorts, which can be sold for money to buy upgrades and expand the ranch. The core mechanics in Sime Rancher can benefit from an alternative controller by making the game more immersive. A controller that looks like the vac pac or another item in the game could help with that. In Slime Rancher 2, a key mechanical object in the game is the Vacpack, which works like a vacuum. Most actions in the game involve aiming it, sucking items toward you, and launching them somewhere else.

Peer Review Questions:

  • Some of the designs use an accelerometer and a potentiometer for movement. Is there another way those could be used for movement or looking around besides just basic movement controls?
  • In terms of input placement on the controllers, are there any inputs placed in a spot that does not feel intuitive?
Resident Evil Controller Designs





Slime Rancher 2 Controller Designs