My Sketch - OpenProcessing

mySketch
xxxxxxxxxx
 
//Base Game for Processing games
//By Jason Galbraith
//Date: 9/21/2020
//Version 1.1, added better destruction code
​
//Image example preload command for OpenProcessing Games (Make sure you remove word REMOVE for it to work)
/* @pjsREMOVE preload="Ghost1.gif,Money.gif,Fire.gif"; */
//String ghostLoc = "Ghost1.gif", moneyLoc = "Money.gif", fireLoc = "Fire.gif";
//
//Image example for Processing application using local sprites:
//String paddleLoc = "../Sprites/Breakout1/bat1.gif", ballLoc = "../Sprites/Breakout1/ball1.gif";
​
​
color backgroundColor = color(50, 50, 50);
static int gameWidth = 600, gameHeight = 400;
GameObjects block1, block2, block3, block4, wallLeft, WallBottom, wallRight, wallCenter, controller;
int shape, rotation;
final int STRAIGHT = 1;//   1   12   123   1     1    12   12
final int BLOCK = 2;//      2   34    4    2     2   34     34
final int T_SHAPE = 3;//    3              34   43
final int L_SHAPE = 4;//    4
final int J_SHAPE = 5;
final int S_SHAPE = 6;
final int Z_SHAPE = 7;
int gameSpeed = 1000;
int linesCleared = 0;
int level = 0;
PFont f;
​
void setup() { //Any code that has to happen at the start of the game goes here
  size(600, 400);
  noStroke();
  wallLeft = new GameObject(0, 0, 19, gameHeight);
  wallLeft.solid = true;
  wallRight = new GameObject(gameWidth-20, 0, 20, gameHeight);
  wallRight.solid = true;
  wallBottom = new GameObject(19, gameHeight-20, gameWidth-39, 20);
  wallBottom.solid = true;
  wallCenter = new GameObject(20+(10*20), 0, 20, gameHeight-20);
  createTetrisShape();
  controller = new GameObject(-20, -20, 19, 19);
  controller.setAlarm(gameSpeed);
  f = createFont("Arial",72,false);
}
​
void draw() { //The draw loops continuously in order to run the game, change code here that you want to check every game loop
  background(backgroundColor);
  noStroke();
  updateObjects();
  drawObjects();
  textFont(f, 32);
  fill(#000000);
  text("Lines cleared:"+linesCleared, 300, 150);
  text("Level:"+level, 300, 200);
}
​
void keyPressed() { //Set up what happens when a key is pressed
  if (key == CODED) {
    if (keyCode == LEFT) {
      moveBlocks(-20, 0);
      if (checkShapeCollision() == true) {
        moveBlocks(20, 0);
      }
    }
    else if (keyCode == RIGHT) {
      moveBlocks(20, 0);
      if (checkShapeCollision() == true) {
        moveBlocks(-20, 0);
      }
    }
    else if (keyCode == DOWN) {
      moveBlocks(0, 20);
      if (checkShapeCollision() == true) {
        moveBlocks(0, -20);
        block1.classTag = "static";
        block2.classTag = "static";
        block3.classTag = "static";
        block4.classTag = "static";
        completedLines();
        createTetrisShape();
        controller.setAlarm(gameSpeed);
      }
    }
    else if (keyCode == UP) {
      rotateShape();
    }
  }
}
​
void mousePressed() {
  int check = checkAnswer();
  if (check == YES) {
    restartGame();
  }
  else if (check == NO) {
    println("Game Over!");
    endGame();
  }
}
​
void alarm(GameObject alarmObject) { //Fires when an object alarm counts down to zero
  if (alarmObject == controller) {
    moveBlocks(0, 20);
    if (checkShapeCollision() == true) {
      moveBlocks(0, -20);
      block1.classTag = "static";
      block2.classTag = "static";
      block3.classTag = "static";
      block4.classTag = "static";
      completedLines();
      createTetrisShape();
    }
    controller.setAlarm(gameSpeed);
  }
}
​
void collision(GameObject moving, GameObject notMoving) { //Set up what happens when there is a collision between an object that tried to move and another object
}
​
boolean checkShapeCollision() {
  boolean collided = false;
  if (checkCollision(block1) != -1 || checkCollision(block2) != -1 || checkCollision(block3) != -1 || checkCollision(block4) != -1) {
    collided = true;
  }
  return collided;
}
​
void completedLines() {
  for (int row = gameHeight - 40; row >= 0; row -= 20) {
    int count = 0;
    for (int col = 20; col < 20 + (10 * 20); col += 20) {
      controller.x = col;
      controller.y = row;
      if (checkCollision(controller) != -1 && objects[checkCollision(controller)].classTag == "static") {
        count++;
      }
    }
    if (count == 10) {
      for (int col = 20; col < 20 + (10 * 20); col += 20) {
        controller.x = col;
        controller.y = row;
        objects[checkCollision(controller)].destroy();
      }
      for (int a = 0; a < arrayIndex; a++) {
        if (objects[a].y < row && objects[a].classTag == "static") {
          objects[a].y += 20; 
        }
      } linesCleared++;
      if (linesCleared % 10 == 0) {
        level++;
        gameSpeed = int(gameSpeed * 0.7);
        if (gameSpeed <= 0) gameSpeed = 1;
      }
      row += 20;
    }
  }
  controller.x = -20;
  controller.y = -20;
}
​
void createTetrisShape() {
  shape = int(random(1, 8));
  rotation = 0;
  color shapeColor = randomColor();
  if (shape == STRAIGHT) {
    block1 = new GameObject(20+100, 0, 19, 19, shapeColor);//  1
    block2 = new GameObject(20+100, 20, 19, 19, shapeColor);// 2
    block3 = new GameObject(20+100, 40, 19, 19, shapeColor);// 3
    block4 = new GameObject(20+100, 60, 19, 19, shapeColor);// 4
  }
  else if (shape == BLOCK) {
    block1 = new GameObject(20+80, 0, 19, 19, shapeColor);//  12
    block2 = new GameObject(20+100, 0, 19, 19, shapeColor);// 34
    block3 = new GameObject(20+80, 20, 19, 19, shapeColor);
    block4 = new GameObject(20+100, 20, 19, 19, shapeColor);
  }
  else if (shape == T_SHAPE) {
    block1 = new GameObject(20+80, 0, 19, 19, shapeColor);//  123
    block2 = new GameObject(20+100, 0, 19, 19, shapeColor);//  4
    block3 = new GameObject(20+120, 0, 19, 19, shapeColor);
    block4 = new GameObject(20+100, 20, 19, 19, shapeColor);
  }
  else if (shape == L_SHAPE) {
    block1 = new GameObject(20+100, 0, 19, 19, shapeColor);//  1
    block2 = new GameObject(20+100, 20, 19, 19, shapeColor);// 2
    block3 = new GameObject(20+100, 40, 19, 19, shapeColor);// 34
    block4 = new GameObject(20+120, 40, 19, 19, shapeColor);
  }
  else if (shape == J_SHAPE) {
    block1 = new GameObject(20+100, 0, 19, 19, shapeColor);//   1
    block2 = new GameObject(20+100, 20, 19, 19, shapeColor);//  2
    block3 = new GameObject(20+100, 40, 19, 19, shapeColor);// 43
    block4 = new GameObject(20+80, 40, 19, 19, shapeColor);
  }
  else if (shape == S_SHAPE) {
    block1 = new GameObject(20+100, 0, 19, 19, shapeColor);//   12
    block2 = new GameObject(20+120, 0, 19, 19, shapeColor);//  34
    block3 = new GameObject(20+80, 20, 19, 19, shapeColor);
    block4 = new GameObject(20+100, 20, 19, 19, shapeColor);
  }
  else if (shape == Z_SHAPE) {
    block1 = new GameObject(20+80, 0, 19, 19, shapeColor);//  12
    block2 = new GameObject(20+100, 0, 19, 19, shapeColor);//  34
    block3 = new GameObject(20+100, 20, 19, 19, shapeColor);
    block4 = new GameObject(20+120, 20, 19, 19, shapeColor);
  }
  block1.classTag = "moving";
  block2.classTag = "moving";
  block3.classTag = "moving";
  block4.classTag = "moving";
  if (checkCollision(block1) != -1 || checkCollision(block2) != -1 || checkCollision(block3) != -1 || checkCollision(block4) != -1) {
    drawQuestion("Game over! Play again?");
  }
}
​
void moveBlocks(int x, int y) {
  block1.x += x;
  block2.x += x;
  block3.x += x;
  block4.x += x;
  block1.y += y;
  block2.y += y;
  block3.y += y;
  block4.y += y;
}
​
color randomColor() {
  int randomPick = int(random(1, 8));
  if (randomPick == 1) {//blue
    return #0000ff;
  } else if (randomPick == 2) {//green
    return #00ff00;
  } else if (randomPick == 3) {//red
    return #ff0000;
  } else if (randomPick == 4) {//yellow
    return #ffff00;
  } else if (randomPick == 5) {//purple
    return #cc00cc;
  } else if (randomPick == 6) {//cyan
    return #00ffff;
  } else if (randomPick == 7) {//orange
    return #ff9900;
  }
}
​
void rotateShape() {
  if (shape == STRAIGHT) {
    if (rotation == 0) {// change to   1234  block 2 stays in place
      block1.x -= 20;block1.y += 20;
      block3.x += 20;block3.y -= 20;
      block4.x += 40;block4.y -= 40;
      if (checkShapeCollision() == true) {
        block1.x += 20;block1.y -= 20;
        block3.x -= 20;block3.y += 20;
        block4.x -= 40;block4.y += 40;
      }
      else {
        rotation = 1;
      }
    }
    else if (rotation == 1) {//       change to   1   block2 stays in place   
      block1.x += 20;block1.y -= 20;//            2
      block3.x -= 20;block3.y += 20;//            3
      block4.x -= 40;block4.y += 40;//            4
      if (checkShapeCollision() == true) {
        block1.x -= 20;block1.y += 20;
        block3.x += 20;block3.y -= 20;
        block4.x += 40;block4.y -= 40;
      }
      else {
        rotation = 0;
      }
    }
  }
  else if (shape == BLOCK) {
    //no rotation
  }
  else if (shape == T_SHAPE) {//Starting position is   123
    //                                                  4
    if (rotation == 0) {
      block1.x += 20;block1.y -= 20;// change to    1
      block3.x -= 20;block3.y += 20;//             42
      block4.x -= 20;block4.y -= 20;//              3
      if (checkShapeCollision() == true) {
        block1.x -= 20;block1.y += 20;
        block3.x += 20;block3.y -= 20;
        block4.x += 20;block4.y += 20;
      }
      else {
        rotation = 1;
      }
    }
    else if (rotation == 1) {
      block1.x += 20;block1.y += 20;// change to    4
      block3.x -= 20;block3.y -= 20;//             321
      block4.x += 20;block4.y -= 20;//              
      if (checkShapeCollision() == true) {
        block1.x -= 20;block1.y -= 20;
        block3.x += 20;block3.y += 20;
        block4.x -= 20;block4.y += 20;
      }
      else {
        rotation = 2;
      }
    }
    else if (rotation == 2) {
      block1.x -= 20;block1.y += 20;// change to    3
      block3.x += 20;block3.y -= 20;//              24
      block4.x += 20;block4.y += 20;//              1
      if (checkShapeCollision() == true) {
        block1.x += 20;block1.y -= 20;
        block3.x -= 20;block3.y += 20;
        block4.x -= 20;block4.y -= 20;
      }
      else {
        rotation = 3;
      }
    }
    else if (rotation == 3) {
      block1.x -= 20;block1.y -= 20;// change to   123
      block3.x += 20;block3.y += 20;//              4
      block4.x -= 20;block4.y += 20;//              
      if (checkShapeCollision() == true) {
        block1.x += 20;block1.y += 20;
        block3.x -= 20;block3.y -= 20;
        block4.x += 20;block4.y -= 20;
      }
      else {
        rotation = 0;
      }
    }
  }
}
​
​
/*Base code for Processing Games*/
static int objectArraySize = 200;
static GameObject[] objects = new GameObject[objectArraySize]; //Array of Game Objects, setting an upper limit on how many objects you can run
static int arrayIndex = 0; //current index of the last object; effectively the size of the array of objects
static int objectId = 100000;
static boolean askingQuestion = false, answer = false;
static int questionX=gameWidth/2-80, questionY=gameHeight/2-40, questionWidth=160, questionHeight=40;
final static int NO_ANSWER = 0;
final static int YES = 1;
final static int NO = 2;
​
int checkAnswer() {
  if (mouseX >= questionX && mouseX <= questionX+questionWidth/2 && mouseY >= questionY+questionHeight/2 && mouseY <= questionY+questionHeight && askingQuestion == true) {
    loop();
    askingQuestion = false;
    answer = true;
    return YES;
  }
  if (mouseX >= questionX+questionWidth/2 && mouseX <= questionX+questionWidth && mouseY >= questionY+questionHeight/2 && mouseY <= questionY+questionHeight && askingQuestion == true) {
    loop();
    askingQuestion = false;
    answer = false;
    return NO;
  }
  return NO_ANSWER;
}
​
int checkCollision(GameObject test) { //Check to see if the object hits another object, and return it's index (-1 if no object)
  if (getIndex(test) == -1) {
    return -1;
  }
  for (int a = 0; a < arrayIndex; a++) {
    if (test != objects[a] && test.x <= objects[a].x + objects[a].spriteWidth && objects[a].x <= test.x + test.spriteWidth 
                           && test.y <= objects[a].y + objects[a].spriteHeight && objects[a].y <= test.y + test.spriteHeight) {
      return a;
    }
  }
  return -1;
}
​
void drawQuestion(String question) {
  stroke(0);
  fill(255);
  rect(questionX-2, questionY-2, questionWidth+4, questionHeight+4);
  rect(questionX, questionY, questionWidth, questionHeight);
  rect(questionX, questionY+questionHeight/2, questionWidth/2, questionHeight/2);
  rect(questionX+questionWidth/2, questionY+questionHeight/2, questionWidth/2, questionHeight/2);
  stroke(255);
  fill(0);
  textFont(createFont("Arial",72,false), 12);
  text(question, questionX+4, questionY+questionHeight-25);
  text("Yes", questionX+4, questionY+questionHeight-2);
  text("No", questionX+questionWidth/2+4, questionY+questionHeight-2);
  askingQuestion = true;
  noLoop();
}
​
void drawObjects() { //Draw all of the objects in the game
  for (int a = 0; a < arrayIndex; a++) {
     objects[a].drawObject(); 
  }
}
​
void endGame() {
  noLoop();  
}
​
int getIndex(GameObject test) { //Return the index of the test object in the objects array 
  for (int a = 0; a < arrayIndex; a++) {
    if (test == objects[a]) {
      return a; 
    }
  }
  return -1;
}
​
void restartGame() {
  while (arrayIndex > 0) {
    objects[0].destroy(); 
  }
  setup();
}
​
void updateObjects() { //Move all objects bassed on their speed and direction; also check for collisions
  for (int a = 0; a < arrayIndex; a++) {
     objects[a].x += cos(radians(objects[a].direction)) * objects[a].speed; 
     objects[a].y -= sin(radians(objects[a].direction)) * objects[a].speed;//Flip y-axis so that degrees increase counter-clockwise
     int collidedIndex = checkCollision(objects[a]);
     if (collidedIndex != -1) {
       if (objects[collidedIndex].solid == true) {//If solid, jump back to previous position, set speed to zero
         objects[a].x -= cos(radians(objects[a].direction)) * objects[a].speed; 
         objects[a].y += sin(radians(objects[a].direction)) * objects[a].speed;
         objects[a].speed = 0;
       }
       collision(objects[a], objects[collidedIndex]);//Call the user-defined collision event
     }
     if (objects[a].alarmTime > 0 && millis() - objects[a].startTime > objects[a].alarmTime) {
       alarm(objects[a]);
     }
  }
}
​
class GameObject {
  float x, y; //x and y position of object
  float speed, direction; //speed in pixels per cycle, direction in degrees (0 is right, 90 is up, 180 is left, 270 is down)
  int spriteWidth = 16; //width of sprite, rectangle if image is null
  int spriteHeight = 16; //height of sprite, rectangle if image is null
  PImage sprite = null; //sprite to be drawn
  color objectColor = color(255, 255, 255); //object color
  int id; //unique object id
  String classTag = "", idTag = "";
  boolean solid = false; //if solid is true, cannot be moved into
  int startTime, alarmTime = -1;
  
  GameObject() { //Default constructor
    if (arrayIndex >= objectArraySize) { //if our object array isn't big enough
      objectArraySize *= 2;
      GameObject[] bigger = new GameObject[objectArraySize];
      for (int a = 0; a < arrayIndex; a++) { //create an array twice the size, transfer all the objects over
         bigger[a] = objects[a]; 
      }
      objects = bigger;
    }
    objects[arrayIndex++] = this; //add the object to the array
    id = objectId++; //give the object a unique id
  }
  
  GameObject(float nx, float ny) { //Constructor takes x and y position
    this();
    x = nx;
    y = ny;
  }
  
  GameObject(float nx, float ny, String imagePath) { //Constructor takes x and y position, and sprite path
    this();
    x = nx;
    y = ny;
    setSprite(imagePath);
  }
  
  GameObject(float nx, float ny, int sW, int sH) { //Constructor takes x and y position, sprite width, and sprite height
    this(nx, ny);
    spriteWidth = sW;
    spriteHeight = sH;
  }
  
  GameObject(float nx, float ny, int sW, int sH, color c) { //Constructor takes x and y position, sprite width, sprite height, and object color
    this(nx, ny, sW, sH);
    objectColor = c;
  }
  
  void destroy() { //Removes an object from the object list, effectively destroying it
    for (int a = 0; a < arrayIndex; a++) {
      if (this == objects[a]) {
        for (int b = a; b < arrayIndex - 1; b++) { //move all the objects past this one down one
          objects[b] = objects[b + 1];  
        }
        objects[arrayIndex] = null; //set the last one to null
        arrayIndex--;
        a--;
      }
    }
  }
  
  void drawObject() { //Draw all objects in the object list
    if (sprite == null) {
      fill(objectColor);
      rect(x, y, spriteWidth, spriteHeight);
    }
    else {
      image(sprite, x, y); 
    }
  }
  
  void move(float newSpeed, float newDirection) { //Set speed and direction of object
    this.speed = newSpeed;
    this.direction = newDirection;
  }
    
  void setAlarm(int timeUntilAlarm) {
    startTime = millis();
    alarmTime = timeUntilAlarm;
  }
  
  void setSprite(String imagePath) { //Set the sprite to the one at the imagePath location
    sprite = loadImage(imagePath);
    if (sprite != null) {
      spriteWidth = sprite.width;
      spriteHeight = sprite.height;
    }
  }
  
  void setTowards(GameObject destination) { //Set the current object angle to be the destination point
    if (getIndex(destination) != -1) {
      direction = degrees(atan2(-destination.y+y, destination.x-x)); //Note: y is negative due to flipped axis, atan2 due to quadrant issues
    }
  }
   
}
​