Digital Games - Game States

Game States

Refresher
Game State
Timers
Example Game (state and huds)

Reading

Refresher

A control flow statement is anything that branches your code into different paths, hence the term, control flow.

If statements are examples of control flow as well as switch statements, and they are important for telling your program which state it is in.

Finite State Machines

Here is a turnstile, implemented at many stores and transit locations. As you can see the turnstile can be in only 1 state at a particular point in time and the diagram details how you will move between states.

Finite State Machines

Explaining all the intricacies of finite state machines is beyond the scope of this course but your game and all software programs are finite state machines.

Your application will maintain the state it is in (start, playing, won, lost, ...) and using control flow statements in your game loop you will show the correct state and allow the player to move between states.

Game State

Your game will at some point be in different states of play. Whether it's the intro screen, level 1, level 2, ..., or a final credit scene.

We're going to look at two ways to manage this state

Game State with if statements

Notice how we're calling methods from the main draw loop instead of putting all the code inside the if statements. This will keep our main loop clean and easy to understand which state calls which method. It's great for debugging and keeps everything readable.

Game state with switch statement

Game state with switch

Much cleaner than the if statements in my opinion. This may be the optimal choice for your program.

Avoid huge blocks of code in your main draw loop, use methods, and if necessary put them in another tab for better navigation and code readability.

Switching States

Create a method to clear any ArrayLists and reinstantiate objects that need it. This will ensure that your program continues to run smooth no matter what level you're on or how long your user plays.

Avoid huge blocks of code in your main draw loop.

Use methods for your different states, and if necessary put them in another tab for better navigation and code readability.

Reset objects before starting a new level.

HUDs

A HUD or heads up display, will let your user know what is going on during the game. Typical information includes health, score, lives, but you're free to include anything you want.

Health Bar

In order to draw a bar you must first calculate the percentage of health remaining for the player. This gives you a number between 0-1.

You may want to calculate the health percentage only when the player health changes and store this inside the player class. This will improve performance since you won't be calculating this percentage every frame.

Character player;
float speed = 2;
PVector upForce = new PVector(0, -speed);
PVector downForce = new PVector(0, speed);
PVector leftForce = new PVector(-speed, 0);
PVector rightForce = new PVector(speed, 0);
boolean up, down, left, right, fire;

int addEnemy = 90;

int state = 0;

ArrayList<Background> backgrounds = new ArrayList<Background>();
ArrayList<Enemy> enemies = new ArrayList<Enemy>();

void keyPressed() {
  if (key == CODED) {
    if (keyCode == LEFT) left = true;
    else if (keyCode == RIGHT) right = true;
    else if (keyCode == UP) fire = true;
  } else {
    if (key == ' ') fire = true;
  }
}
void keyReleased() {
  if (key == CODED) {
    if (keyCode == LEFT) left = false;
    else if (keyCode == RIGHT) right = false;
    else if (keyCode == UP) fire = false;
  } else {
    if (key == ' ') fire = false;
  }
}

void setup() {
  size(fullWidth, fullHeight);
  stroke(200);
  strokeWeight(2);
  fill(63);

player = new Character(new PVector(width/2, height - 50));

backgrounds.add(new Background("img/levels/bg.jpg", 2, 2, 0.25));
  backgrounds.add(new Background("img/levels/stars.png", 2, 2, 1));
}

void draw() {
    switch (state) {
        case 0: level1(); break;
        case 1: gameOver(); break;
    }
}

void level1() {
    background(255);
    if (left) player.move(leftForce);
    if (right) player.move(rightForce);
    if (up) player.move(upForce);
    if (down) player.move(downForce);
    if (fire) player.fireMissile();

if (frameCount % addEnemy == 0) {
        enemies.add( new Enemy(new PVector(random(64, width - 128), -64)) );
        if (addEnemy > 20) {
             addEnemy--;
        }
    }
    //draw bgs
    for (int i = 0; i < backgrounds.size(); i++) {
        backgrounds.get(i).draw(new PVector(-player.pos.x / 4, frameCount * 2));
    }
    //draw enemies
    for (int i = 0; i < enemies.size(); i++) {
        Enemy e = enemies.get(i);
        e.update();
        e.draw();
        if (e.collision(player)) {
            player.hit();
        }
    }
    //update + draw player
    player.update();
    //draw other stuff
    drawHealthBar();
    drawScore();
}

void gameOver() {
    background(255);
    text("Game Over", width/2 - 40, height/2);
}

void drawScore() {
    text("SCORE: " + player.score, width - 100, 40);
}

void drawHealthBar() {
    int healthBarWidth = 200;
    pushMatrix();
    fill(0, 64);
    translate(20, 20);
    rect(0, 0, healthBarWidth, 20); //container for health
    fill(255, 0, 0, 255);
    rect(0, 0, healthBarWidth * player.healthPercentage, 20); //health bar
    popMatrix();
}

//a class to describe a Tile
class Missile {
    PVector pos, vel;
    int life;
    ArrayList list;
    ArrayList<Explosion> explosions;
    Missile(pos, vel, life, list) {
        this.pos = pos;
        this.vel = vel;
        this.life = life;
        this.list = list;
        explosions = new ArrayList<Explosion>();
    }
    boolean collision(MovingObject other) {
        if (dist(pos.x, pos.y, other.pos.x, other.pos.y) < other.radius) {
            return true;
        }
        return false;
    }
    void update() {
        pos.add(vel);
        if (pos.y < 0) {
            life = -1;
        }
        if (life == 0) {
            for (int i = 0; i < 32; i++) {
                explosions.add( new Explosion(new PVector(pos.x, pos.y), explosions ));
            }
        }
        if (life < 0 && explosions.size() == 0) {
            list.remove(this);
        }
        for (int i = 0; i < explosions.size(); i++) {
            Explosion e = explosions.get(i);
            e.update();
            e.draw();
        }
        life--;
    }
    void draw() {
        fill(63);
        if (life > 0) {
            pushMatrix();
            translate(pos.x, pos.y);
            ellipse(0, 0, 8, 8);
            popMatrix();
        }
    }
}

//a class to describe a generic Character
class MovingObject {
  //fields
  PVector pos, vel, acc;
  float radius;
  float damp = 0.8; //constant damping factor

MovingObject(PVector pos) {
    this.pos = pos;
    vel = new PVector(); //must create instance
    acc = new PVector(); //these are complex data types (i.e. objects)
  }
  //move method, PVector force as parameter, add to acceleration
  void move(PVector force) {
    acc.add(force);
  }
  boolean collision(MovingObject other) {
      if (dist(pos.x, pos.y, other.pos.x, other.pos.y) < radius + other.radius) {
          return true;
      }
      return false;
   }
  //update the character
  void update() {
    vel.add(acc); //add acceleration to velocity
    vel.mult(damp); //multiply velocity by dampening factor (0.9-0.99);
    pos.add(vel); //add velocity to position (moves character)
    acc.set(0, 0, 0); //clear the acceleration for the next loop
  }
  
  void draw() {
    pushMatrix();
    translate(pos.x, pos.y);
    ellipse(0, 0, 32, 32);
    popMatrix();
  }
}

//a class to describe a generic Character
class Character extends MovingObject {
  ArrayList<Missle> missiles;
  //control firing
  int fireTimer = 0;
  int invincibleTimer = 60;
  int health;
  int maxHealth;
  float healthPercentage;
  int score = 0;
  //a constructor to initialize the fields above with initial values
  Character(PVector pos) {
    super(pos);
    missiles = new ArrayList<Missle>();
    radius = 24;
    maxHealth = 10;
    health = maxHealth;
    healthPercentage = 1;
  }

void fireMissile() {
    if (fireTimer === 0) {
        missiles.add( new Missile(new PVector(pos.x, pos.y), new PVector(0, -8), 200, missiles) );
        fireTimer = 6;
    }
    fireTimer--;
  }

void hit() {
    if (invincibleTimer == 0) {
        health--;
        if (health == 0) {
            state = 1;
        }
        invincibleTimer = 60;
        healthPercentage = (float) health / (float) maxHealth;
    }
  }
  
  //update the character
  void update() {
    for (int i = 0; i < missiles.size(); i++) {
        Missile m = missiles.get(i);
        m.update();
        m.draw();
        for (int j = 0; j < enemies.size(); j++) {
            Enemy e = enemies.get(j);
            if (m.collision(e) && m.life > 0) {
                m.life = 0;
                enemies.remove(e);
                score += 100;
            }
        }
    }
    super.update();
    if (invincibleTimer > 0) {
        if (invincibleTimer % 2 == 0) {
            draw();
        }
        invincibleTimer--;
    } else {
        draw();
    }
  }
  
  void draw() {
    fill(63);
    
    pushMatrix();
    translate(pos.x, pos.y);
    if (vel.x < -0.5) {
        rotate(-PI/8);
    } else if (vel.x > 0.5) {
        rotate(PI/8);
    }
    ellipse(0, 0, radius * 2, radius);
    arc(0, -4, radius * 2 - 12, radius, -PI, 0);
    popMatrix();
  }
}