Author: Fatema Nassar

Project Description:

My project is a generative drawing project where the user gets to draw with hands/joystick and then save the work they drew.

I started my work by exploring different shapes and types of brushes to choose one. After some time and looking around I decided it was best to give the user the option to use more than one brush in one piece.

I am still not done with the brush class but after testing the brushes separately, that is my unedited code for the brush class:

Main Class Function:

import java.util.*;

class Brush {

  int brushN;

  float stepSize;
  float angle;
  float x, y, tempX, tempY;
  color col;
  //
  int counter;
  PFont font;
  float fontSize;
  String letters;
  float  fontSizeMin;
  //
  float [] blurX={ -stepSize, -stepSize, 0, stepSize, stepSize, stepSize, 0, -stepSize};
  float [] blurY={ 0, stepSize, stepSize, stepSize, 0, -stepSize, -stepSize, -stepSize};
  //linemoduelw
  PShape lineModule;

  float  linelength=100;
  float [] numX={ -100, -70, 0, 70, 100, 70, 0, -70};
  float [] numY={ 0, 70, 100, 70, 0, -70, -100, -70};

  Brush(int defaultt, float step_size) {
    // 1 blur
    // 2 random cylinder
    // 3 dynamic shapes
    // 4 text lines
    // 5 rotating lines
    brushN = defaultt;
    stepSize = step_size;
    angle = 270;
    x = mouseX;
    y = mouseY;
    col = color(255);
    fontSizeMin=200;

    fontSize=50;
    letters = "It isn't true that my mattress is made of cotton candy. It was the first time he had ever seen someone cook dinner on an elephant. Homesickness became contagious in the young campers' cabin. Every manager should be able to recite at least ten nursery rhymes backward.";
    // for(int i; i<8; i++){
    //   numX = (float)acos()
    // }
  }
  void setbrush(int brushn) {
    brushN=brushn;
  }
  void setSize(int size) {
    stepSize=size;
  }
  void draw() {
    switch (brushN) {
    case 1:
      blur();
      break;

    case 2:
      randomprisms();
      break;

    case 3:
      dynamicShapes();
      break;

    case 4:
      textlines();
      break;

    default :
      rotatingLines();
      break;
    }
  }
  ...
}
class ColorWheel{
}

Blur:

void blur() {
  float diam = 1;
  if (mousePressed) {
    float d = dist(x, y, mouseX, mouseY);

    if (d > stepSize) {
      // gets the angle between the mouse and the location of the brush so that next point is drawn in the right intended location
      angle = (float)Math.atan2(mouseY-y, mouseX-x);

      tempX = x;
      tempY = y;

      pushMatrix();
      //
      translate(x, y);
      rotate(angle);
      noStroke();
      fill(col, 40);

      //
      for (int i=0; i<200; i++) {
        int dir =  int(random(0, 7));
        rotate(random(5));
        tempX=blurX[dir]*random(1, 10);
        tempY=blurY[dir]*random(1, 10);
        circle(tempX, tempY, diam);
      }
      //
      popMatrix();
      x=x+(float)Math.cos((angle))*stepSize;
      y=y+(float)Math.sin((angle))*stepSize;
    }
  }
  col = color(noise(100+0.01*frameCount)*255, noise(200+0.01*frameCount)*255, noise(300+0.01*frameCount)*255, 255);
}

Random Size Prisms Brush:

void randomprisms() {
  if (mousePressed) {
    float d = dist(x, y, mouseX, mouseY);

    if (d>stepSize) {
      // gets the angle between the mouse and the location of the brush so that next point is drawn in the right intended location
      angle = (float)Math.atan2(mouseY-y, mouseX-x);
      for ( int i=0; i<8; i++) {
        numX[i]+=random(0-stepSize/2, stepSize/2);
        numY[i]+=random(0-stepSize/2, stepSize/2);
      }

      pushMatrix();
      //
      translate(x, y);
      rotate(angle+random(-0.1, 0.1));
      stroke(col);
      strokeWeight(stepSize/4);
      // if (frameCount%2 == 0) stroke(100);
      // line(0, 0, 0, linelength*random(0.95, 1)*d/100);
      rectMode(CENTER);
      noFill();
      rect(0, 0, linelength*random(0.95, 1)*d/100, linelength*random(0.95, 1)*d/100);

      // noFill();
      // beginShape();
      // curveVertex(numX[0], numY[0]);///////////////
      // curveVertex(numX[0], numY[0]);///////////////
      // curveVertex(numX[1], numY[1]);//mid
      // curveVertex(numX[2], numY[2]);///////////////
      // curveVertex(numX[3], numY[3]);// mid
      // curveVertex(numX[4], numY[4]);///////////////
      // curveVertex(numX[5], numY[5]);//mid
      // curveVertex(numX[6], numY[6]);///////////////
      // curveVertex(numX[7], numY[7]);//mid
      // curveVertex(numX[0], numY[0]);///////////////
      // curveVertex(numX[0], numY[0]);///////////////


      // endShape();

      popMatrix();

      x=x+(float)Math.cos((angle))*stepSize;
      y=y+(float)Math.sin((angle))*stepSize;
      x=mouseX;
      y=mouseY;
    }
  }
  col = color(noise(100+0.01*frameCount)*255, noise(200+0.01*frameCount)*255, noise(300+0.01*frameCount)*255, 255);
}

void dynamicShapes() {
  if (mousePressed) {
    float d = dist(x, y, mouseX, mouseY);

    if (d>stepSize) {
      //
      lineModule = createShape();
      stroke(col);
      strokeWeight(10);
      noFill();
      lineModule.beginShape();

      lineModule.vertex(100, 0); // first point

      lineModule.vertex(0, 100);// /
      lineModule.vertex(-100, 0);// \
      lineModule.vertex(0, -100);// /
      lineModule.vertex(100, 0);// \

      lineModule.endShape();

      // lineModule = createShape();
      // stroke(col);
      // strokeWeight(10);
      // fill(col);
      // lineModule.beginShape();
      // lineModule.vertex(50, 75); // first point
      // lineModule.bezierVertex(100, 100, 500, 100, 400, 300);
      // lineModule.endShape();
      //
      // gets the angle between the mouse and the location of the brush so that next point is drawn in the right intended location
      angle = (float)Math.atan2(mouseY-y, mouseX-x);


      pushMatrix();
      //
      translate(mouseX, mouseY);
      rotate((angle+PI));
      shape(lineModule, 0, 0, d, noise(1+frameCount*0.0001)*10);
      //
      popMatrix();


      x=x+(float)Math.cos((angle))*stepSize;
      y=y+(float)Math.sin((angle))*stepSize;
    }
  }
  col = color(noise(100+0.01*frameCount)*255, noise(200+0.01*frameCount)*255, noise(300+0.01*frameCount)*255, 255);
}

Text Brush:

void textlines() {
  if (mousePressed) {
    float d = dist(x, y, mouseX, mouseY);
    d= constrain(d, 60, 7000);

    if (d>stepSize) {
      // gets the angle between the mouse and the location of the brush so that next point is drawn in the right intended location
      angle = (float)Math.atan2(mouseY-y, mouseX-x);
      fontSize= fontSizeMin*60/d;
      println("d: "+d);
      font = createFont("Calibri", fontSize);

      textFont(font, fontSize);
      char newLetter = letters.charAt(counter);
      stepSize = textWidth(newLetter);
      fill(col);
      //stroke(col);


      pushMatrix();
      //
      translate(x, y);
      rotate(angle);
      text(newLetter, 0, 0);
      //
      popMatrix();

      counter++;

      if (counter>letters.length()-1) counter=0;

      x = x + (float)Math.cos(angle)*stepSize;
      y = y + (float)Math.sin(angle)*stepSize;
    }
  }
  col = color(noise(100+0.01*frameCount)*255, noise(200+0.01*frameCount)*255, noise(300+0.01*frameCount)*255, 255);
}

Rotating Brush:

void rotatingLines() {

  if (mousePressed) {
    pushMatrix();
    strokeWeight(3);
    stroke(col);
    //
    translate(mouseX, mouseY);
    rotate(radians(angle));
    line(0, 0, linelength, 0);
    //
    popMatrix();

    angle +=1;
    col = color(noise(100+0.01*frameCount)*255, noise(200+0.01*frameCount)*255, noise(300+0.01*frameCount)*255, 255);
    linelength= int(noise(50+0.01*frameCount)*300);
  }
}

Next Steps:

Processing:

1) Workout the user input method

2) Create the user interface and develop a collect pixels mechanism to restore the drawing after the color wheel appears when the user changes colors

3)Save the images and save files with people’s previous images to display images when the user saves the file.

Arduino:

1) Get readings from joyStick for color wheel and possibly brush.

2) Get readings from buttons for save and fader variable resistor for brush

Description:

My idea is to make a drawing machine on Processing and to use Arduino-controlled Joy Sticks to control the mouse position on the screen.

The user would get to control the colors and save the image if desired.

If the user decides to save their generative art drawing, the 5 last saved drawings will show on the screen in a polaroid-like look.

Processing Inspiration:

I chose to make a generative art piece on processing because I feel that a drawing using a joystick can only get you so far without much practice, so I decided that a generative art algorithm would work better for this case.

These are some sources that I feel inspire my goal for the processing part of my project.

First design this is a randomly generated piece, but it is really close to what I thought of when I first thought of generative.

Second design This is a drawing piece where the letters are drawn instead of ink at the position of the mouse and the size is decided by the speed of the movement of the mouse.

Third design In this one the cursor is followed by randomly changing shape instead of a normal brush.

Fourth design This, like the first, does not follow the mouse, it is just random instead-but follows a random path and is not completely random.

I think this might be nice to add behind any of the other designs with a lower opacity to give a smoky look behind the drawing.

Arduino:

My plan is to have 2 joysticks, one to control the mouse location and one to change the color of the drawing at a certain point.

I also plan to add push buttons to toggle values that will reset/save/show prev saved images.

This is the arrangement I have in mind at the moment

Exercise 1:

Processing:

import processing.serial.*;
Serial myPort;
int xPos=0;
int yPos=0;
boolean onOff=false;
boolean onOff2=false;

void setup(){
  size(960,720);
  printArray(Serial.list());
  String portname=Serial.list()[0];
  println(portname);
  myPort = new Serial(this,portname,9600);
  myPort.clear();
  myPort.bufferUntil('\n');
}

void draw(){
  background(255);
  ellipse(xPos,yPos,30,30);
  if (mousePressed){
    if(mouseX<=width/2)
      onOff2=true;
    else
      onOff=true;
  }else{
    onOff=onOff2=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==2){
      xPos=(int)map(values[0],0,1023,0, width);
      yPos=height/2;
    }
  }
  myPort.write(int(onOff)+","+int(onOff2)+"\n");
}

Arduino:

int left = 0;
int right = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("0,0");
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
}

void loop() {
  while (Serial.available()) {
    right = Serial.parseInt();
    left = Serial.parseInt();
    if (Serial.read() == '\n') {
      digitalWrite(3, right);
      digitalWrite(5, left);
      int sensor = analogRead(A0);
      delay(1);
      int sensor2 = analogRead(A1);
      delay(1);
      Serial.print(sensor);
      Serial.print(',');
      Serial.println(sensor2);
    }
  }
}

Exercise 2:

Processing:

import processing.serial.*;
Serial myPort;
int xPos = 0;
int yPos = 0;
int onOff = 0;
int onOff2 = 0;
int brightness = 0;

void setup() {
  size(960, 720);
  printArray(Serial.list());
  String portname = Serial.list()[0];
  println(portname);
  myPort = new Serial(this, portname, 9600);
  myPort.clear();
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  brightness = int(map(mouseY, 0, height, 0, 255));
  ellipse(xPos, yPos, 30, 30);
  if (mousePressed) {
    if (mouseX <= width / 2) {
      onOff2 = brightness;
    } else {
      onOff = brightness;
    }
  } else {
    onOff = onOff2 = 0;
  }
}

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 == 2) {
      xPos = (int)map(values[0], 0, 1023, 0, width);
      //yPos=(int)map(values[1],0,1023,0, height);
      yPos = mouseY;
    }
  }
  myPort.write(int(onOff) + "," + int(onOff2) + "\n");
}

Arduino:

int left = 0;
int right = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("0,0");
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
}

void loop() {
  while (Serial.available()) {
    right = Serial.parseInt();
    left = Serial.parseInt();
    if (Serial.read() == '\n') {
      analogWrite(3, right);
      analogWrite(5, left);
      int sensor = analogRead(A0);
      delay(1);
      int sensor2 = analogRead(A1);
      delay(1);
      Serial.print(sensor);
      Serial.print(',');
      Serial.println(sensor2);
    }
  }
}

Exercise 3:

Processing:

import processing.serial.*;
Serial myPort;

PVector velocity;
PVector gravity;
PVector position;
PVector acceleration;
PVector wind;
float drag = 0.99;
float mass = 50;
float hDampening;
int[] values;

int onoff, onoff2;

void setup() {
  size(960, 720);
  printArray(Serial.list());

  noFill();
  position = new PVector(width/2, 0);
  velocity = new PVector(0, 0);
  acceleration = new PVector(0, 0);
  gravity = new PVector(0, 0.5*mass);
  wind = new PVector(0, 0);
  hDampening=map(mass, 15, 80, .98, .96);


  String portname=Serial.list()[0];
  println(portname);
  myPort = new Serial(this, portname, 9600);
  myPort.clear();
  myPort.bufferUntil('\n');
}

void draw() {
  background(255);
  applyForce(wind);
  applyForce(gravity);
  velocity.add(acceleration);
  velocity.mult(drag);
  position.add(velocity);
  acceleration.mult(0);
  ellipse(position.x, position.y, mass, mass);
  if (position.y > height-mass/2) {
    velocity.y *= -0.9;  // A little dampening when hitting the bottom
    position.y = height-mass/2;
  }

  if (velocity.y!=0) {
    onoff=1;
    onoff2=0;
  } else {
    onoff=0;
    onoff2=1;
  }
}

void applyForce(PVector force) {
  // Newton's 2nd law: F = M * A
  // or A = F / M
  PVector f = PVector.div(force, mass);
  acceleration.add(f);
}

void serialEvent(Serial myPort) {
  String s=myPort.readStringUntil('\n');
  s=trim(s);
  if (s!=null) {
    println(s);
    values=int(split(s, ','));
    if (values.length==3) {
      if (values[0]==1) {
        wind.x=-2;
      }
      if (values[1]==1) {
        wind.x=2;
      }
      if (values[2]==1) {
        mass=random(15, 80);
        position.y=-mass;
        velocity.mult(0);
      }
      if (values[0]==0 && values[1]==0) {
        wind.x=0;
        velocity.x*=hDampening;
      }
    }
  }
  myPort.write(onoff+ ","+onoff2+"\n");
}

Arduino:

int left = 0;
int right = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("0,0,0");
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
}

void loop() {
  while (Serial.available()) {
    right = Serial.parseInt();
    left = Serial.parseInt();
    if (Serial.read() == '\n') {
      digitalWrite(3, right);
      digitalWrite(5, left);
      int button = digitalRead(A0);
      delay(1);
      int button2 = digitalRead(A1);
      delay(1);
      int button3 = digitalRead(A2);
      delay(1);
      Serial.print(button);
      Serial.print(',');
      Serial.print(button2);
      Serial.print(',');
      Serial.println(button3);
    }
  }
}

Description:

I decided, after a struggle of thought, to make a simple water refill reminder. Drinking water is crucial and many people tend to try to forget. So I made this simple water that detects the weight of the bottle and knows how much water is left in the bottle/cup using a force sensor.

using the force sensor on its own did not give a range of weight enough for the water weight detector. so I decided to place the force sensor on a sponge.

I also used an on/off button that turns the circuit on when pressed and off when pressed once more

I also used 4 red lights that are more likely to capture someone’s attention and remind them to refill their water bottle when it’s empty.

and I used 4 blue led lights, more of the blue lights light up the more water there is in the bottle.

this is how my circuit looks:

the last set of wires that are neither connected to the button or the less is connected to the force sensor.

video:

the video shows how the circuit works:

Code:

const int outs[] = {3, 5, 6, 9,
                    10, 11, 12, 13
                   };
const int ins[] = {A2, A3};
int var, var2, b, r, maxx = 0;

long timer;
bool turnon = 0, curr, prev;

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < sizeof(outs); i++) {
    pinMode(outs[i], OUTPUT);
  }
  Serial.begin(9600);
  for (int i = 0; i < sizeof(ins); i++) {
    pinMode(ins[i], INPUT);
  }
}

void loop() {
  if (curr != prev && curr == 1) {
    turnon = !turnon;
  }
  curr = digitalRead(ins[1]);
  timer = millis();
  var = analogRead(ins[0]);//0-250
  var = map(var, 0, 500, 0, 255);
  var2 = constrain(var, 250, 255);
  Serial.print(" on: ");
  Serial.print(turnon);
  Serial.print(" curr: ");
  Serial.print(curr);
  Serial.print(" prev: ");
  Serial.println(prev);


  if (turnon == 1) {
    on();
  }
  else {
    for (int i = 0; i < 8; i++) {
      analogWrite(outs[i], 0);
    }
  }
  //
  prev = digitalRead(ins[1]);

}

void redled(int n) {
  if (timer % (n * 4) < (n * 1)) {
    analogWrite(outs[4], var2);
    analogWrite(outs[5], 0);
    analogWrite(outs[6], 0);
    analogWrite(outs[7], 0);
  }
  else if (timer % (n * 4) < (n * 2)) {
    analogWrite(outs[4], 0);
    analogWrite(outs[5], var2);
    analogWrite(outs[6], 0);
    analogWrite(outs[7], 0);
  }
  else if (timer % (n * 4) < (n * 3)) {
    analogWrite(outs[4], 0);
    analogWrite(outs[5], 0);
    analogWrite(outs[6], var2);
    analogWrite(outs[7], 0);
  }
  else {
    analogWrite(outs[4], 0);
    analogWrite(outs[5], 0);
    analogWrite(outs[6], 0);
    analogWrite(outs[7], var2);
  }
}

void on() {

  if (var < 20) {
    b = -1;
    r = 4;
  }
  else if (var < 140) {
    b = 0;
    r = 0;
  }
  else if (var < 260) {
    b = 1;
    r = 0;
  }
  else if (var < 380) {
    b = 2;
    r = 0;
  }
  else {
    b = 3;
    r = 0;
  }

  // there is water
  if (r == 0) {
    for (int i = 0; i < b + 1; i++) {
      analogWrite(outs[i], var2);
    }
    for (int i = 7; i > b; i--) {
      analogWrite(outs[i], 0);
    }
  }
  else {
    for (int i = 0; i < 4; i++) {
      analogWrite(outs[i], 0);
    }
    redled(1000);

  }
}

Description:

I have always been the worst when it came to forgetting different things at different places. Forgetting my card at the most random places was getting me locked out of my room more than I would have liked. So I decided to make a switch that reminds you to put your card back in its place sometime out.

I started by placing a switch in the circuit and making it work using a normal push-button switch. once I finished the circuit I replaced one end of the switch with a wire connected to the card and the other end with a wire connected to a cardholder that is to be stuck to a phone.

I connected the wires to copper tape that I stuck on contacting sides of the card and the cardholder so that when the card is in place, the switch is closed.

I used a yellow led light for the normal time when the card is placed in its location. when you remove the card from the cardholder, a timer starts, when the time span in the code ends, the red light starts to blink to remind you to put the card back in.

IMAGES:

Breadboard Circuit:

Whole Circuit:

Card Connection

Video:

CODE:

long mytime=500, timer = 0;
const int outs[] = {2, 4};
const int ins = A2;
int curr = 0, prev=0;
bool flip=false;
long blinkk=0;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  for (int i = 0; i < sizeof(outs); i++) {
    pinMode(outs[i], OUTPUT);
  }
  pinMode(ins, INPUT);
}

void loop() {
  curr = digitalRead(ins);// <500, <900, >900
  if (curr == 0) {
    Serial.print(timer);
    Serial.print(" ");
    Serial.println(mytime);
    if (mytime == timer) {
      if(blinkk<=millis()){
        flip=!flip;
        blinkk+=500;
      }
      digitalWrite(outs[0], flip);
      digitalWrite(outs[1], LOW);
    }
    else{
      timer+=1;
      digitalWrite(outs[0], LOW);
      digitalWrite(outs[1], LOW);
    }
  }
  else {
    {
      timer=0;
      digitalWrite(outs[1], HIGH);
      digitalWrite(outs[0], LOW);
      blinkk=millis();
    }
  }
  prev = digitalRead(ins);
}

Overview:

Finally, it’s here.

The purpose of this game is for the student, skeleton in the picture, to collect all the questions and then collect the final paper to get the full grade for their exam.

IDEA(details):

Background:

Originally, I intended to have clouds as the background with the stars, but even when I used images instead of pixels, the game’s frameRate dropped and the game was barely functioning so I settled for a clear starry night look.

I choose this because:

firstly, I have really sensitive eyes, and I find it easier on my eye to look at a dark screen.

Secondly, I am a night person, night always looks better ;).

For the stars, I used overlapping circles to give a faded look, which resembles actual stars more than normal circles would.

Code:

class Bg {
  float[] x = new float[50];
  float[] y = new float[50];
  Bg() {
    for (int i=0; i<50; i++) {
      x[i] = random(0, widthh);
      y[i] = random(0, heightt);
    }
  }

  void drawBG() {
    if (frameCount%50==0) {
      for (int i=0; i<50; i++) {
        x[i] = random(0, width);
        y[i] = random(0, height);
      }
    }
    background(50, 50, 80);
    for (int i=0; i<50; i++) {
      for (int j=0; j<10; j++) {
        noStroke();
        fill(255, 25);
        ellipse(x[i], y[i], 1+j, 1+j);
      }
    }
  }
}

Creature:

Instead of making repetitive classes, I used class inheritance, where I made the Superclass, Creatures, for all the live items in the game.

Code:

public class Creature {

  // Attributes
  PVector pos;
  PVector speed;
  boolean alive;
  float ground;
  PVector size;
  PVector imgSize;
  int numFrames;
  PImage imgs;
  PImage[] img;
  int frame;
  boolean dir; //left = 0 right = 1
  boolean secondJump = false;

  public Creature(float x, float  y, float  r, float  g, PImage _img, float  w, float  h, int  num_frames) {
    pos= new PVector(x, y);
    speed= new PVector(0, 0);
    alive = true;
    ground = height-g;
    numFrames = num_frames;
    imgSize = new PVector(_img.width/num_frames, _img.height);
    size = new PVector (r, imgSize.y*(r/imgSize.x));
    imgs = _img;
    img = new PImage[numFrames];
    for (int i=0; i<numFrames; i++) {
      img[i] = imgs.get(
        int((imgSize.x)*i),
        0,
        int(imgSize.x),
        int(imgSize.y));
    }
    // for (int y=0; y < 4; y++) {
    //   for (int x=0; x< 12; x++) {
    //     sprites[y][x] = spritesheet.get(x*w, y*h, w, h);
    //   }
    // }
    frame = 0;
    dir = true;
  }

  void gravity() {
    if (pos.y<ground-size.y+10  ||pos.y<ground-size.y ) {
      speed.y+=0.2;
    } else {
      speed.y=0;
      pos.y = constrain(pos.y, ground-size.y, ground-size.y+10);
      secondJump=false;
    }
    for (int p=game.plats.length-1; p>=0; p--) {
      if ((pos.y+size.y <=game.plats[p].pos.y+15)//height
        && pos.x+size.x/3>=game.plats[p].pos.x//right
        && pos.x-size.x/3  <= game.plats[p].pos.x+game.plats[p].pWidth) {//left
        ground = game.plats[p].pos.y;
        break;
      } else {
        ground = heightt-game.ground;
      }
    }
  }


  void update() {
    gravity();
    pos.x += speed.x;
    pos.y += speed.y;
  }
  void display() {
    update();
    // println(this.getClass().getName());
    if (dir && alive) {
      scale(1, 1);
      image(img[frame], pos.x, pos.y, size.x, size.y);
    } else if (!dir && alive) {
      if (this.getClass().getName()=="Midterm$Player") {
        pushMatrix();
        scale(-1, 1);
        image(img[frame], -pos.x, pos.y, size.x, size.y);
        popMatrix();
      } else if (this.getClass().getName()=="Midterm$Monster") {
        image(img[frame], pos.x, pos.y, size.x, size.y);
      }
    }
  }
}

Player:

For the player, I choose the skeleton, because obviously, we are all dead during midterm and final seasons. That also gave me the idea of the name “dead student“.

Sprite:

With the player, I struggled a little with the jumps. I wanted to only allow double jumps, which I thought was the case until my roommate tried it and I realized it didn’t. I tried to fix it, but that only made it worse, so I left it as it was when my roommate tried it. (I mean what works, works right?)

Code:

class Player extends Creature {
  boolean left;
  boolean up;
  boolean right;
  SoundFile jump;
  int count;
  Player(float x, float  y, float  r, float  g, PImage _img, float  w, float  h, int  num_frames, PApplet sketch) {
    super(x, y, r, g, _img, w, h, num_frames);
    left = false;
    up = false;
    right = false;
    jump = new SoundFile(sketch, "jump.wav");
    count = frameCount;
  }

  void update() {
    gravity();
    //====================
    if (left==true) {
      speed.x=-3;
      dir=false;
    } else if (right==true) {
      speed.x=3;
      dir=true;
    } else {
      speed.x=0;
    }
    //====================
    if (up==true && pos.y>=ground-size.y &&secondJump==false) {
      jump.play();
      speed.y = -6;
    } else if (up==true && speed.y<0 && secondJump==true && pos.y<ground-size.y) {
      jump.play();
      speed.y = -8;
      secondJump=false;
    }
    pos.x +=speed.x;
    pos.y +=speed.y;
    if (frameCount%5 == 0 && speed.x !=0 && speed.y ==0) {
      frame= (frame+1)%numFrames;
    } else if (speed.x==0) {
      frame=8;
    }

    //====================
    if (pos.x<=0) {
      pos.x = 0;
    }
    //====================
    if (pos.x+size.x>= widthh) {
      pos.x = widthh- size.x;
    } else if (pos.x<size.x) {
      pos.x = size.x;
    }
    //====================
    for (int i =0; i<game.myMonsters.length; i++) {
      float numME = pow((pow(size.x, 2)+(pow(size.y, 2))), 0.5);
      float numthem = pow((pow(game.myMonsters[i].size.x, 2)+(pow(game.myMonsters[i].size.y, 2))), 0.5);

      if (game.myMonsters[i].distance(this)<=numME/2.5+numthem/2.5 && game.myMonsters[i].alive) {
        if (speed.y>0) {
          game.myMonsters[i].alive=false;
          game.myMonsters[i].sound2.play();
        } else {
          game.myMonsters[i].sound1.play();
          alive = false;
        }
      }
    }
    for (int i =0; i<game.myQuestions.length; i++) {
      if (game.myQuestions[i].distance(this)<=size.x/2+game.myQuestions[i].size.x/2 && game.myQuestions[i].alive) {
        game.score++;
        game.myQuestions[i].sound.play();
        game.myQuestions[i].alive = false;
      }
    }
    if (game.myfinal.distance(this)<=size.x/2+game.myfinal.size.x/2 && game.myfinal.alive) {
      game.score+=5;
      game.myfinal.sound.play();
      game.myfinal.alive = false;
      game.won= true;
    }
  }
}

Monsters:

Finding Sprites for the monsters was not easy. I was trying to find monsters that represent the distractions we have while studying. So instead of finding different monsters, I made my own using emojis and clip art images.

I used the facial features from the emojis and the body of what I think represents distractions. I made them alternate between an Innocent look and an evil look because distractions usually don’t look so bad.

Here are the sprites:

Monster 1, Phone:

Monster 2, Thoughts:

Monster 3, Anxiety:

Code:

class Monster extends Creature {
  SoundFile sound1, sound2;
  float xleft, xright;
  Monster(float x, float  y, float  r, float  g, PImage _img, float  w, float  h, int  num_frames, float x_left, float x_right, PApplet sketch) {
    super(x, y, r, g, _img, w, h, num_frames);

    speed.x=random(0.3,0.9);
    speed.y=0;
    xleft = x_left;
    xright = x_right;
    sound1 = new SoundFile(sketch, "eat.wav");
    sound2 = new SoundFile(sketch, "kill.wav");
  }

  void update() {
    gravity();
    if (pos.x<=xleft) {
      dir = true;
      frame= (frame+1)%numFrames;
      speed.x*=-1;
    } else if (pos.x>=xright) {
      dir = false;
      frame= (frame+1)%numFrames;
      speed.x*=-1;
    }
    pos.x +=speed.x;
    pos.y +=speed.y;
  }



  float distance(Player target) {
    return dist(this.pos.x+size.x/2, this.pos.y+size.y/2, target.pos.x+target.size.x/2, target.pos.y+target.size.y/2);
  }
}

Questions and Final:

For this one, I thought it was better to have a bouncy still image, as it was the only one that was completely dead. I used the same class for both as they had the same charactaristics.

Sprites:

Questions:

Final:

Code: