This is from the Sparkfun tutorials online found here. More code examples available here.
/*
SparkFun Inventor’s Kit
Circuit 4A-HelloWorld
The LCD will display the words "Hello World" and show how many seconds have passed since
the RedBoard was last reset.
This sketch was written by SparkFun Electronics, with lots of help from the Arduino community.
This code is completely free for any use.
View circuit diagram and instructions at: https://learn.sparkfun.com/tutorials/sparkfun-inventors-kit-experiment-guide---v41
Download drawings and code at: https://github.com/sparkfun/SIK-Guide-Code
*/
#include <LiquidCrystal.h> //the liquid crystal library contains commands for printing to the display
LiquidCrystal lcd(13, 12, 11, 10, 9, 8); // tell the RedBoard what pins are connected to the display
void setup() {
lcd.begin(16, 2); //tell the lcd library that we are using a display that is 16 characters wide and 2 characters high
lcd.clear(); //clear the display
}
void loop() {
lcd.setCursor(0, 0); //set the cursor to the 0,0 position (top left corner)
lcd.print("Hello, world!"); //print hello, world! starting at that position
lcd.setCursor(0, 1); //move the cursor to the first space of the bottom row
lcd.print(millis() / 1000); //print the number of seconds that have passed since the last reset
}
So, i decided to choose one idea for my final and started a big research. As I a little bit tired of the games and musical instruments, i want to work on generative art. I’m gonna create an art application with different modes for different users. This topic also coincides with mental health and social studies.
I found some readings about effectiveness of art therapy and results after it
Our project idea has been modified a bit now and is about creating a driving experience for the user in which the user chooses a circuit in processing and uses a joystick to drive a car (made using arduino) and attempts to finish the circuit shown on their processing screens.
For this week, we managed to figure out how to make the core of our project work. We found out a way to use a joystick as an input and then send that information to processing which then communicates it to the Arduino causing a change in it which we can then use as an output. This was actually so time consuming and we had to wrap our brains around how we could make this possible but eventually we found a library on processing called Game Control Plus and G4P which allowed us to configure processing so that we can design what each button in our joystick would do and this would be stored as a separate library which we could then import into our main processing code and use within it.
Meanwhile, we also started working on our processing interface and set up the following game screens:
menu()
Contains the main menu for the game in which the player can choose to play the game or read the instructions or change settings
choose_circuit()
The playable component of the game wherein the player chooses the circuit they want to race their car in
instruction()
Details game instructions
setting()
To change game settings
gameover()
To signify end of game
Code
The following is the code that we have written till now:
For the Joystick:
int ledPin = 4;
float brightness = 0;
void setup() {
Serial.begin(9600);
Serial.println("0");
pinMode(ledPin, OUTPUT);
}
void loop() {
while (Serial.available()) {
//get the brightness value from processing
brightness = Serial.parseFloat();
if (Serial.read() == '\n') {
//turn on the LED with the given brightness
analogWrite(ledPin, brightness);
Serial.println(brightness);
}
}
}
Arduino code to test out the effect of a joystick on an LED light and toggle it on or off
import net.java.games.input.*;
import org.gamecontrolplus.*;
import org.gamecontrolplus.gui.*;
import processing.serial.*;
Serial myPort;
ControlDevice cont;
ControlIO control;
float press;
void setup()
{
size(360, 200);
control = ControlIO.getInstance(this);
cont = control.getMatchedDevice("LED_Input");
if (cont == null)
{
println("not today champ");
System.exit(-1);
}
printArray(Serial.list());
String portname=Serial.list()[0];
println(portname);
myPort = new Serial(this, portname, 9600);
myPort.clear();
myPort.bufferUntil('\n');
}
void draw()
{
background(press);
getInput();
}
public void getInput()
{
press = map(cont.getSlider("analog").getValue(), -1, 1, 0, 255);
println(press);
}
void serialEvent(Serial myPort) {
String s=myPort.readStringUntil('\n');
s=trim(s);
//write brightness so that Arduino can use it
myPort.write(press + "\n");
}
We also created a library called “LED_Input” using the GCP Configurator Example of the GCP Library
Housekeeping
We set up a notion page to better manage our work flow
For my project, I’m building some sort of contraption to accompany Zoom classes. It’s been a chaotic week and I haven’t made as much progress as I would have liked, but I’ve been playing around with the speech recognition library in P5.js.
Here’s my code thus far:
var myRec = new p5.SpeechRec('en-US', parseResult); // new P5.SpeechRec object
myRec.continuous = true; // do continuous recognition
myRec.interimResults = true; // allow partial recognition (faster, less accurate)
var recordedString = "";
var x, y;
var dx, dy;
function setup()
{
// graphics stuff:
createCanvas(800, 600);
background(255, 255, 255);
fill(0, 0, 0, 255);
// instructions:
textSize(20);
textAlign(LEFT);
//myRec.onResult = parseResult; // now in the constructor
myRec.start(); // start engine
}
function draw()
{
text(recordedString, 20,20);
}
function parseResult()
{
var mostrecentword = myRec.resultString.split(' ').pop();
recordedString += mostrecentword;
}
I still need to add the functionality for wrapping the string and making sure that it removes a word printed if it realizes it’s actually a different word. For instance, when saying the word “happening’, “happy” would print to the screen and then “happening.”
This week, I hope to get started on building a capacitor sensor (foil inside pillow).
For this week, I decided to work on planning for my project and organizing my thoughts to see if my project was achievable. Honestly, I did not. had much time this week to start the coding part of my project so I decided to think about what different things I should implement.
Game:
My game mainly consists of two parts. The first part will be a free piano play where the user can record, edit, delete, move notes to compose a musical piece. The second part of the game is an actual game where notes will be falling above piano tiles and the user must push the button representing the tile. For this game, I had decided to only implement buttons and the potentiometer to control the position of the piano. However, after Prof. Aaron’s suggestion about making it more interactive, I decided to implement additional features. I will be using the ultrasonic sensor and a box to represent the position of the user in the piano instead of the potentiometer. I will also use additional features such as the photosensor, LED lights, and buttons.
Progress for this week.
For this week basically, I created sketches of what my goal for my final project is. I created sketches for the basic look of the game for both phase 1 and phase 2. I also organized my thoughts and wrote down what I thought was necessary for the game. I created a document where I wrote about what different classes were needed to create this project. I also created a brief sketch of what my initial screen should look like.
Conclusion and Reflection:
Honestly, this week I could not accomplish much on my project. I am proud that I organized my thoughts and started thinking about how Arduino and Processing should interact as well as planning what the general game should look like. I am not satisfied with this week’s progress and therefore I plan on working much more this week. For this week, my plan is to accomplish the first phase of the game and have good progress on the second part so that I can work on the aesthetic part of the game next week.
Once I’m more or less decided on my project, I went to do my little research on the many possibilities that Processing tool has to offer. I found many libraries and examples implemented in Processing, such as Mirror by Daniel Shiffman which quite literally shows ur reflection captured by webcam, or PeasyCam that transforms ur face and shows in three-dimensional space.
CHALLENGES:
I have faced an issue related to the Capture function, the camera is denying access to processing to run the program and open the webcam.
BaseSrc: [avfvideosrc0] : Device video access permission has just been denied
Could not run the sketch
(Target VM failed to initialize).
Professor later explained that this has to do with the privacy and security settings of new macOS not letting processing open the camera due to strict security restrictions.
CODE:
// daniel shiffman's library on mirror
import processing.video.*;
// Size of each cell in the grid
int cellSize = 20;
// Number of columns and rows in our system
int cols, rows;
// Variable for capture device
Capture video;
void setup() {
size(640, 480);
frameRate(30);
cols = width / cellSize;
rows = height / cellSize;
colorMode(RGB, 255, 255, 255, 100);
// This the default video input, see the GettingStartedCapture
// example if it creates an error
video = new Capture(this, width, height);
// Start capturing the images from the camera
video.start();
background(0);
}
void draw() {
if (video.available()) {
video.read();
video.loadPixels();
// Begin loop for columns
for (int i = 0; i < cols; i++) {
// Begin loop for rows
for (int j = 0; j < rows; j++) {
// Where are we, pixel-wise?
int x = i*cellSize;
int y = j*cellSize;
int loc = (video.width - x - 1) + y*video.width; // Reversing x to mirror the image
float r = red(video.pixels[loc]);
float g = green(video.pixels[loc]);
float b = blue(video.pixels[loc]);
// Make a new color with an alpha component
color c = color(r, g, b, 75);
// Code for drawing a single rect
// Using translate in order for rotation to work properly
pushMatrix();
translate(x+cellSize/2, y+cellSize/2);
// Rotation formula based on brightness
rotate((2 * PI * brightness(c) / 255.0));
rectMode(CENTER);
fill(c);
/noStroke();
// Rects are larger than the cell for some overlap
ellipse(0, 0, 1, random (20,100));
popMatrix();
}
}
}
}
Please read through my previous blog post if you haven’t to better follow this one 🙂
Once Cole and I had finalized our idea for the final project, the first very important thing was to finalize the instructions for bomb diffusion. We both had a preliminary idea on how our game should work – have LEDs light up to give a signal, press buttons according to that, this should give you the next task to do and a few such tasks should culminate in cutting a wire. This seemed very easy until we started making a plan. We realized, there were a lot of things to consider, and based on that, we could have many permutations of things we could do / signals and tasks we could create. So we decided on the things we will be using on our Arduino board for input and output first. Due to limited pins, we had to maximize what we could use and different signals we could create. We decided on 4 LEDs as output signals and 4 buttons (different colors), potentiometer, and distance meters as inputs. We made a complete plan on how to start, which instruction will lead to what and so. It can be found below. And I must mention, it took longer than we thought and harder than we assumed to chart this plan!
Instructions Part 1
Instructions Part 2
After this plan was made, Cole and I decided to first get started with some basics of our Arduino and interface on Processing.
Interface of Processing
We decided to start with the interface first because once we have the visualization, it will be easy to display the Arduino reads on the screen and check if our code/wiring is appropriate or not. Also, it is very hard to code the entire logic with no visible output. So, once we integrate Arduino with processing, we should be able to see the results on the screen.
I started with sketching the wires. I was thinking about how it could be possible to have wires disappear once they are cut. The best way I could imagine was draw these pieces individually and then display the appropriate wires based on their state (1 for uncut and 0 for uncut).
Next, I wanted to try to make the distance meter and potentiometer reading on screen. For testing purposes, I made them map to mouseX. This will be switched to Arduino readings later. The rotation of the needle was a little hard to achieve because I wanted it to pivot over a very particular point in the image. With a little trial and error and some calculations, I think I got that right!
You can find the working videos below:
I am currently working on displaying the bomb timer/countdown on the screen. This is proving to be a bit challenging. After this, I will start with the driver program for the game which is the LED sequences, and randomizing those. Based on that, the code for the rest of the game will follow. Each LED sequence needs to wait for input and update multiple flag variables and then change the sequence to give the next signal. I have charted out a plan on how this will work… implementation will hopefully follow soon 🙂
Arduino Part
For the Arduino part, Cole finished creating the Arduino with all the wiring. On the board, we have 4 LEDs, 4 buttons with corresponding colors to the LEDs, a potentiometer, a distance sensor, and a buzzer.
We have also completed the Arduino code needed to control the whole board from Processing as well as send the inputs from the sensors back.
Here is the Arduino circuit (note the distance meter in Tinkercad is a 3 pin, not a 4 pin variant like we have so I just placed 4 wires in the top left corner where the distance meter is actually at)
Tinker-cad ModelActual Arduino
Code
For the above, I have started with creating a few classes (currently have one for the wires, more are to come for the timer and LEDs). I have also broken down the into various sections and made functions based on different game stages / input we are waiting for from the bomb diffuser.
The Arduino code has also been completed by Cole as mentioned above.
For the full code (Arduino and Processing), you can follow this GitHub link.
Shreya and I have been busy this week creating the set of instructions and the foundations of the bomb game. We met to create the instructions that one player will have and by doing so have defined the structure of our game and Arduino. We then created a Github and split up the tasks so we could begin.
I finished creating the Arduino with all the wiring. I have on the board 4 LEDs, 4 buttons with corresponding colors to the LEDs, a potentiometer, a distance sensor, and a buzzer.
I have also created the Arduino code needed to control the whole board from Processing as well as send the inputs from the sensors back.
Here is the Arduino circuit (note the distance meter in Tinkercad is a 3 pin, not a 4 pin variant like we have so I just placed 4 wires in the top left corner where the distance meter is actually at)
I have also written the following code to control this board and talk to Processing from our game.
(Code on WordPress no longer inserting?)
//Pins
const int blueLedPin = 9;
const int redLedPin = 8;
const int greenLedPin = 7;
const int yellowLedPin = 6;
const int potentiometerPin = A0;
const int blueButtonPin = 5;
const int redButtonPin = 4;
const int greenButtonPin = 3;
const int yellowButtonPin = 2;
const int echoPin = 10; // Echo Pin of Ultrasonic Sensor
const int pingPin = 11; // Trigger Pin of Ultrasonic Sensor
const int buzzerPin = 12;
//On or off values for led
int blue = 0;
int red = 0;
int green = 0;
int yellow = 0;
//Has the bomb gone off
int alarm = 0;
//Are the buttons being pushed
int blueButton = 0;
int redButton = 0;
int greenButton = 0;
int yellowButton = 0;
void loop() {
while (Serial.available()) {
//Read in input values in form “yellowLed,greenLed,redLed,blueLed,alarm”
yellow = Serial.parseInt();
green = Serial.parseInt();
red = Serial.parseInt();
blue = Serial.parseInt();
alarm = Serial.parseInt();
if (Serial.read() == ‘\n’) {
//Turn lights on from read in values
digitalWrite(yellowLedPin, yellow);
digitalWrite(greenLedPin, green);
digitalWrite(redLedPin, red);
digitalWrite(blueLedPin, blue);
//Read in potentiometer value and the distance meter value, convert to centimeters
int meter = analogRead(A0);
delay(1);
long duration;
int cm;
digitalWrite(pingPin, LOW); //Send a ping out with sensor
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(10);
digitalWrite(pingPin, LOW); //Ping sent
duration = pulseIn(echoPin, HIGH); //Wait for return on echo Pin
cm = duration / 29 / 2; //Convert to cm
//Write to processsing in following form “potentiometer,distanceincm,yellowbuttonpressed,yellowbutton,greenbuttonpressed,greenbutton,redbuttonpressed,redbutton,bluebuttonpressed,bluebutton”
//Button pressed meaning if that button was just pressed and the value is now changing write 1
Serial.print(sensor);
Serial.print(‘,’);
Serial.print(cm);
Serial.print(‘,’);
int yellowButtonRead = digitalRead(yellowButtonPin)
if(yellowButtonRead == 1 && yellowButton == 0){
Serial.print(1);
}
else{
Serial.print(0);
}
yellowButton = yellowButtonRead;
Serial.print(‘,’);
Serial.print(digitalRead(yellowButtonRead));
Serial.print(‘,’);
int greenButtonRead = digitalRead(greenButtonPin)
if(greenButtonRead == 1 && greenButton == 0){
Serial.print(1);
}
else{
Serial.print(0);
}
greenButton = greenButtonRead;
Serial.print(‘,’);
Serial.print(digitalRead(greenButtonRead));
Serial.print(‘,’);
int redButtonRead = digitalRead(redButtonPin)
if(redButtonRead == 1 && redButton == 0){
Serial.print(1);
}
else{
Serial.print(0);
}
redButton = redButtonRead;
Serial.print(‘,’);
Serial.print(digitalRead(redButtonRead));
Serial.print(‘,’);
int blueButtonRead = digitalRead(blueButtonPin)
if(blueButtonRead == 1 && blueButton == 0){
Serial.print(1);
}
else{
Serial.print(0);
}
blueButton = blueButtonRead;
Serial.print(‘,’);
Serial.println(digitalRead(blueButtonRead));
}
}
}
Shreya
(From Shreya’s post about progress)
We decided to start with the interface first because once we have the visualization, it will be easy to display the Arduino reads on the screen and check if our code/wiring is appropriate or not. Also, it is very hard to code the entire logic with no visible output. So, once we integrate Arduino with processing, we should be able to see the results on the screen.
I started with sketching the wires. I was thinking about how it could be possible to have wires disappear once they are cut. The best way I could imagine was draw these pieces individually and then display the appropriate wires based on their state (1 for uncut and 0 for uncut).
Next, I wanted to try to make the distance meter and potentiometer reading on screen. For testing purposes, I made them map to mouseX. This will be switched to Arduino readings later. The rotation of the needle was a little hard to achieve because I wanted it to pivot over a very particular point in the image. With a little trial and error and some calculations, I think I got that right!
I am currently working on displaying the bomb timer/countdown on the screen. This is proving to be a bit challenging. After this, I will start with the driver program for the game which is the LED sequences, and randomizing those. Based on that, the code for the rest of the game will follow. Each LED sequence needs to wait for input and update multiple flag variables and then change the sequence to give the next signal. I have charted out a plan on how this will work… implementation will hopefully follow soon 🙂
This week, we were supposed to start working on the final project right after finalizing our proposals. The link to the proposal for the game Ngoc and I are working on can be found below.
Ngoc and I sat down and discussed the Processing part of the game. Based on our past experience of working on games, we had slightly different opinions on how to go about the classes our game would contain, but there’s a lot I can learn from a sophomore and I believed that her idea of creating 4 different classes would make it easier for us to work on different parts of the game. The 4 classes and a description of what all of them would do are as follows:
Item
The Item Class will consist of all attributes of items which are to fall down the screen. These attributes will include the initial x and y coordinates of the items, their velocities as they fall down the screen, radii, image (to be displayed for each item) and more. The Item Class will also consist of relevant methods for all items, including their update() and display() methods.
Player
The Player class will characterize the user of the Processing program. The most fundamental attribute of a Player object is the x coordinate which is communicated from the Arduino program and updated accordingly. It will also have a display() method to show where the player is on the screen (represented by a sprite). Other information will also be communicated between different classes like Player, Level, Game to determine when the player will appear on the screen etc.
Level
A Level object encompasses one full game level and includes a number of objects from other classes, for example one level will include one player and multiple items, as well as new entities like performance metrics. This class coordinates the interactions between Item class and Player class like checking for collisions, and supports other key game functionalities like updating and displaying performances.
Game
An instance of the Game class will represent one entire game which will have four levels, each corresponding to one of the four academic years. It will also contain its own update() and display() functions, which will coordinate certain conditions and outputs to deal with those conditions. Moreover, it will also be responsible for calling the update() functions of other objects which are instantiated within the Game class and the Level class.
Remote Control Testing
The part we expect to be the hardest is getting the remote control to work. From working on previous assignments, we have seen that the distance measuring sensor gives pretty unstable readings and we were concerned with how that might reflect in our program, since smooth and correct mapping of the movement of the remote control onto the screen is a key game function.
We first experimented with mapping the distance onto the movement of a circle on a blank screen to make sure that we could get the sensor to work as we want. As expected, the movement of the circle was quite jittery and glitchy, but it did move in the way we intended. So this proved that we could indeed move the whole Arduino and breadboard combination as a remote control for the game.
We then experimented further with the Processing code to smoothen the movement of the player (which is still represented by a single moving circle for the sake of simplicity). We went back to an earlier example and used it in our Processing code, which gave much smoother player movement.
The differences between no smoothing vs. with smoothing are recorded as can be seen in the short demo:
The Arduino and Processing code for testing the remote control is as following:
const int trigPin = 11;
const int echoPin = 12;
float distance;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
Serial.println("0");
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}
void loop() {
// put your main code here, to run repeatedly:
// distance = getDistance();
// Serial.println(distance);
while (Serial.available()) {
if (Serial.read() == '\n') {
distance = getDistance();
delay(1);
Serial.println(distance);
}
}
}
float getDistance()
{
float echoTime; //variable to store the time it takes for a ping to bounce off an object
float calculatedDistance; //variable to store the distance calculated from the echo time
//send out an ultrasonic pulse that's 10ms long
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
echoTime = pulseIn(echoPin, HIGH); //use the pulsein command to see how long it takes for the
//pulse to bounce back to the sensor
// calculatedDistance = echoTime / 148.0; //calculate the distance of the object that reflected the pulse (half the bounce time multiplied by the speed of sound)
calculatedDistance = echoTime / 58.0;
return calculatedDistance; //send back the distance that was calculated
}
For the Week 3 assignment, I made a game. This game was NYUAD-themed and the player used arrow keys to make Faiza the falcon avoid certain obstacles and get a 4.0 GPA. The link to that post is attached below.
This extra credit assignment is an extension of my Week 3 assignment, except that it makes use of buttons instead of arrow keys. There are 4 different buttons, each corresponding to a single direction.
I figured that the purpose of this assignment was to understand serial communication well, so I tried making good use of a game I had already made earlier.
The group exercises which were due on Monday, together with working on this game, have allowed me to understand the communication between Processing and Arduino a lot better.
Arduino code:
const int yellowButtonPin = 2;
const int greenButtonPin = 4;
const int redButtonPin = 7;
const int blueButtonPin = 8;
void setup() {
Serial.begin(9600);
Serial.println("0");
pinMode(yellowButtonPin, INPUT);
pinMode(greenButtonPin, INPUT);
pinMode(redButtonPin, INPUT);
pinMode(blueButtonPin, INPUT);
}
void loop() {
while (Serial.available()) {
if (Serial.read() == '\n') {
int yellow_button = digitalRead(2);
delay(1);
int green_button = digitalRead(4);
delay(1);
int red_button = digitalRead(7);
delay(1);
int blue_button = digitalRead(8);
delay(1);
Serial.print(yellow_button);
Serial.print(",");
Serial.print(green_button);
Serial.print(",");
Serial.print(red_button);
Serial.print(",");
Serial.println(blue_button);
}
}
}
Processing code:
import java.lang.Math;
import processing.sound.*;
import processing.serial.*;
Serial myPort;
SoundFile file;
String audioName = "intro.mp3";
String path;
PImage[] images;
Game game;
// creating an array for distractions which are used later
Distractions[] distractions;
class Faiza{
float posX, posY;
float radius;
float velocityX;
float velocityY;
float imgwidth, imgheight;
String directionX;
//String keyY, keyX;
boolean move_up, move_down, move_right, move_left;
boolean alive;
int counter, frame;
Faiza(float x, float y, float r, float img_w, float img_h){
posX = x;
posY = y;
radius = r;
velocityX = 0;
velocityY = 0;
imgwidth = img_w;
imgheight = img_h;
directionX = "right";
move_up = false;
move_down = false;
move_right = false;
move_left = false;
alive = true;
counter = 0;
frame = 0;
}
void display(){
update();
if (directionX == "right"){
image(images[0], float(int(posX - imgwidth/2)), float(int(posY - imgheight/2)), imgwidth, imgheight, int(frame * imgwidth), 0, int((frame + 1) * imgwidth), int(imgheight));
}
else if (directionX == "left"){
image(images[0], float(int(posX - imgwidth/2)), float(int(posY - imgheight/2)), imgwidth, imgheight, int((frame + 1) * imgwidth), 0, int(frame * imgwidth), int(imgheight));
}
}
void update(){
//The condition below is for when Faiza moves left
if (move_left == true){
velocityX = -2;
directionX = "left";
if (posX - radius + velocityX < 6){
velocityX = 0;
}
posX += velocityX;
}
//The condition below is for when Faiza moves right
else if (move_right == true){
velocityX = 2;
directionX = "right";
if (posX + radius + velocityX > 1018){
velocityX = 0;
}
posX += velocityX;
}
//If none of the left and right keys are being pressed, Faiza stops moving horizontally
else{
velocityX = 0;
}
if (move_up == true){
velocityY = -2;
if (posY - radius + velocityY <= 5){
velocityY = 0;
}
posY += velocityY;
}
//The condition below is for when Faiza moves downwards
else if (move_down == true){
velocityY = 2;
if (posY + radius + velocityY >= 762){
velocityY = 0;
}
posY += velocityY;
}
//If none of the up and down keys are being pressed, Faiza stops moving vertically
else{
velocityY = 0;
}
if (distance(game.gpa) <= (radius + game.gpa.radius)){
game.level += 1;
}
if (!(posX >= 0 && posX <= 100 && posY >= 530 && posY <= 640)){
for (int i = 0; i < 6; i++){
if (distance(distractions[i]) <= radius + distractions[i].radius){
counter += 1;
println(counter);
alive = false;
}
}
}
}
// this distance method will be used to check for collisions with distractions
double distance(Distractions target){
float a = (posX - target.posX);
float b = (posY - target.posY);
double c = Math.pow(a, 2);
double d = Math.pow(b, 2);
return Math.pow(c + d, 0.5);
}
// this distance method will be used to check for collisions with the gpa (marking the end of the game)
double distance(GPA target){
float a = (posX - target.posX);
float b = (posY - target.posY);
double c = Math.pow(a, 2);
double d = Math.pow(b, 2);
return Math.pow(c + d, 0.5);
}
}
class Distractions{
float posX, posY;
float radius;
float imgwidth, imgheight;
int frame;
PImage img;
float velocityX, velocityY;
Distractions(float x, float y, float r, String _img, float img_w, float img_h){
posX = x;
posY = y;
radius = r;
img = loadImage(_img);
imgwidth = img_w;
imgheight = img_h;
frame = 0;
velocityX = random(2,5);
velocityY = -1 * random(2,5);
}
void update(){
if (posX + radius >= 1024){
velocityX *= -1;
}
if (posX - radius <= 0){
velocityX *= - 1;
}
if (posY - radius <= 10){
velocityY *= -1;
}
if (posY + radius >= 780){
velocityY *= -1;
}
posX += velocityX;
posY += velocityY;
}
void display(){
update();
image(img, float(int(posX - imgwidth/2)), float(int(posY - imgheight/2)), imgwidth, imgheight, int(frame * imgwidth), 0, int((frame + 1) * imgwidth), int(imgheight));
}
}
class GPA{
float posX, posY;
float radius;
float imgwidth, imgheight;
int frame;
GPA(float x, float y, float r, float img_w, float img_h){
posX = x;
posY = y;
radius = r;
imgwidth = img_w;
imgheight = img_h;
frame = 0;
}
void display(){
image(images[1], float(int(posX - imgwidth/2)), float(int(posY - imgheight/2)), imgwidth, imgheight, int(frame * imgwidth), 0, int((frame + 1) * imgwidth), int(imgheight));
}
}
class Game{
float game_width, game_height;
Faiza faiza;
GPA gpa;
int level;
Game(float game_wth, float game_hght){
level = 1;
game_width = game_wth;
game_height = game_hght;
faiza = new Faiza(34, 585, 27, 66, 66);
gpa = new GPA(990, 35, 25, 70, 56);
}
void update(){
if (faiza.alive == false){
faiza.posX = 34;
faiza.posY = 585;
faiza.alive = true;
}
}
void display(){
update();
image(images[2], 0, 0);
if (level == 1){
textMode(CENTER);
textSize(40);
fill(255, 213, 43);
text("GET THAT 4.0!", 310, 65);
}
if (level != 1){
textSize(150);
fill(255, 213, 43);
text("GAME", 270, 220);
text("OVER", 290,350);
textSize(50);
text(faiza.counter + " distractions later,", 240, 550);
text("you achieved that 4.0 GPA!", 200, 600);
}
if (level == 1){
faiza.display();
gpa.display();
}
for (int i = 0; i < 6; i++){
distractions[i].display();
}
}
}
void setup(){
size(1024,768);
printArray(Serial.list());
String portname=Serial.list()[1];
println(portname);
myPort = new Serial(this,portname,9600);
myPort.clear();
myPort.bufferUntil('\n');
game = new Game(1024, 768);
path = sketchPath(audioName);
file = new SoundFile(this, path);
file.loop();
images = new PImage[3];
images[0] = loadImage("faiza.png");
images[1] = loadImage("gpa.png");
images[2] = loadImage("background.png");
distractions = new Distractions[6];
distractions[0] = new Distractions(100, 300, 58, "jake.png", 120, 120);
distractions[1] = new Distractions(444, 333, 48, "insta.png", 100, 100);
distractions[2] = new Distractions(900, 120, 48, "facebook.png", 100, 100);
distractions[3] = new Distractions(887, 635, 48, "netflix.png", 100, 100);
distractions[4] = new Distractions(134, 587, 48, "youtube.png", 100, 100);
distractions[5] = new Distractions(55, 100, 48, "ps.png", 120, 120);
}
void draw(){
background(255, 255, 255);
game.display();
}
// allowing key presses to dictate Faiza's movement
void keyPressed(){
if (key == CODED){
if (keyCode == RIGHT){
game.faiza.move_right = true;
}
if (keyCode == LEFT){
game.faiza.move_left = true;
}
if (keyCode == UP){
game.faiza.move_up = true;
}
if (keyCode == DOWN){
game.faiza.move_down = true;
}
}
}
void keyReleased(){
if (key == CODED){
if (keyCode == RIGHT){
game.faiza.move_right = false;
}
if (keyCode == LEFT){
game.faiza.move_left = false;
}
if (keyCode == UP){
game.faiza.move_up = false;
}
if (keyCode == DOWN){
game.faiza.move_down = false;
}
}
}
void serialEvent(Serial myPort){
String s=myPort.readStringUntil('\n');
s=trim(s);
if (s!=null){
println(s);
int values[] = int(split(s,','));
if (values.length == 4){
if (values[0] == 1){
game.faiza.move_left = true;
}
else{
game.faiza.move_left = false;
}
if (values[1] == 1){
game.faiza.move_down = true;
}
else{
game.faiza.move_down = false;
}
if (values[2] == 1){
game.faiza.move_up = true;
}
else{
game.faiza.move_up = false;
}
if (values[3] == 1){
game.faiza.move_right = true;
}
else{
game.faiza.move_left = false;
}
}
}
myPort.write("\n");
}
