Digital Games - Game Loops

Game Loops

Refresher
Game Loops
Timers
Example Game (with timers)

Reading

Refresher

Processing will "try" and execute everything in the draw loop at 60 frames per second (fps). Certain code will impact performance and of course there should be 0 redundant code.

Redundant code includes: repeated statements or statements that have no effect.

Another form of redundant code is unreachable code, this simply adds to your programs files size, which is important when your program is delivered online.

Performance Bottlenecks

Excessive draw calls
Complex shapes
Large images

Redundant / repeated loops
Redoing heavy calculations (dist, abs)
Redundant code

Tips for Improvement

Don't draw what cannot be seen (clipping)
Simplify your shapes
Store heavy calculations temporarily (in a class or in the game loop)
Break up large images into smaller pieces (background: tiles, mountains, trees, clouds)

Game Loops

A game loop describes your main draw loop. This is where all objects in your game will be updated, and sometimes created and destroyed. There's some logic that doesn't belong in your game loop, most often specific adjustments to several fields of an object. This logic should be contained within the class of that object, in a method.

We'll take a look at a good game loop and a bad game loop.

A Good Game Loop

A Bad Game Loop

Discussion

As you can see the second loop is a lot messier. If we're having trouble coding our sketch it will be hard to find the specific statements in even a slightly more complicated program than this.

By calling methods you will know exactly which part of your code to focus on when behavior is not as desired.

Never repeat code. Put it in a class. If it's shared, make it a superclass.

Performance

An additional benefit of calling methods from your game loop instead of writing logic statements is performance. In order to determine bottlenecks (slow parts) you can simply comment out method calls to identify what is taking the most time.

Performance Testing

Take a look at the following code for a performance testing metric you can use in your code.

Never put statements in your game loop that belong in a method of a class.

Never (as much as you can) access fields from outside a class.

Never repeat code. Put it in a class. If it's shared, make it a superclass.

Test test test to find bottlenecks.

Timers

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;

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));
}

void draw() {
    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();

player.update();
    player.draw();
}

//a class to describe a generic Character
class Character {
  //fields
  PVector pos, vel, acc;
  float damp = 0.8; //constant damping factor
  ArrayList<Missle> missiles;

//control firing
  int fireTimer = 0;
  //a constructor to initialize the fields above with initial values
  Character(PVector pos) {
    this.pos = pos;
    vel = new PVector(); //must create instance
    acc = new PVector(); //these are complex data types (i.e. objects)
    missiles = new ArrayList<Missle>();
  }
  //move method, PVector force as parameter, add to acceleration
  void move(PVector force) {
    acc.add(force);
  }

void fireMissile() {
    if (fireTimer === 0) {
        missiles.add( new Missile(new PVector(pos.x, pos.y), new PVector(0, -8), 30, missiles) );
        fireTimer = 10;
    }
    fireTimer--;
  }
  
  //update the character
  void update() {
    for (int i = 0; i < missiles.size(); i++) {
        Missile m = missiles.get(i);
        m.update();
        m.draw();
    }
    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();
  }
}

The fireTimer

The fireTime variable is an integer stored in the player class to limit the rate of firing Missiles. Remember the draw loop executes at 60fps so if the UP key is held down, the player would fire (or try to) 60 missiles per second.

This is often undesirable, so we'll only let the player fire when the fireTimer variable == 0 and every time it is we'll reset the fireTimer variable to the delay we'd like to see in between Missile firings.

The Missile Life

The Missiles class contains a field for life, this is how we will keep track of how long the missile is "alive" and when it should explode or be removed from the ArrayList it belongs to.

In the Missile update method life is decreased and when it reaches 0, the missile creates and stores a number of explosion objects which it will then update.

Finally the missile class checks to see if all the explosions are removed from the ArrayList of explosions, if this is the case the missile will remove itself from the list it belongs to and cease to be a part of our program.

The Explosion Life

Explosion life is similar to missile life, when it hits zero or is below zero (it often doesn't matter) we will remove the explosion from the ArrayList it belongs to.

Looking back at the Missile class we see that once all explosions are removed, we remove the instance of the missile class in order to eliminate it from our sketch.

Every object should manage it's own timer / lifespan / animation.

Each object should store a reference to the list it belongs to in order to be able to remove itself later.

Objects should take care of their own logic, including: updating, life, timers, removal... This is IMPORTANT!

int addEnemy = 90;

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

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

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

if (frameCount % addEnemy == 0) {
        enemies.add( new Enemy(new PVector(random(64, width - 128), -64)) );
        if (addEnemy > 20) {
             addEnemy--;
        }
    }

for (int i = 0; i < enemies.size(); i++) {
        Enemy e = enemies.get(i);
        e.update();
        e.draw();
        if (e.collision(player)) {
            player = new Character(new PVector(width/2, height - 50));
        }
    }

player.update();
}

//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 startTimer = 60;
  //a constructor to initialize the fields above with initial values
  Character(PVector pos) {
    super(pos);
    missiles = new ArrayList<Missle>();
    radius = 16;
  }

void fireMissile() {
    if (fireTimer === 0) {
        missiles.add( new Missile(new PVector(pos.x, pos.y), new PVector(0, -8), 200, missiles) );
        fireTimer = 6;
    }
    fireTimer--;
  }
  
  //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);
            }
        }
    }
    super.update();
    if (startTimer > 0) {
        if (startTimer % 2 == 0) {
            draw();
        }
        startTimer--;
    } else {
        draw();
    }
  }
  
  void draw() {
    fill(63);
    pushMatrix();
    translate(pos.x, pos.y);
    ellipse(0, 0, radius * 2, radius * 2);
    popMatrix();
  }
}