My only problem is a mouth. I don't know, how to make it work. I want it either be active all the time or only when snake moves, any solution will work. Can you help me?

Here is my code:https://gist.github.com/anonymous/d002d99b90b2288ee6f8f3a16ee49c2e

PImage StartScreen;
PImage Text1;
PImage Text2;
PImage FinalText;
PImage Keep;
PImage Fire;
PImage Laverne;
PImage Chase;
PImage Lindsay;
PImage Riley;
int stage;
int path = 0;

void setup () {
  stage=1;
  size (960, 540);
  StartScreen = loadImage ("Start Screen.png");
  Text1 = loadImage ("Text card 1.png");
  Text2 = loadImage ("Text card 2.png");
  FinalText = loadImage ("Text card 3.png");
  Keep = loadImage ("KEEP Big.png");
  Fire = loadImage ("FIRE Big.png");
  Laverne = loadImage ("Laverne Waller.png");
  Chase = loadImage ("Chase Willoughby.png");
  Lindsay = loadImage ("Lindsay Holme.png");
  Riley = loadImage ("Riley Travis.png");
}

void draw () {
  println (mouseX, mouseY);
  //START SCREEN
  if (path == 0) {
    image (StartScreen, 0, 0);
    if ((mouseX > 354) && (mouseX < 432) && (mouseY > 368) && (mouseY < 396) && (mousePressed == true)) {
      path = 1;
    }
  }

  //FIRST TEXT
  else if (path == 1) {
    image (Text1, 0, 0);
    if ((mouseX > 385) && (mouseX < 445) && (mouseY > 412) && (mouseY < 437) && (mousePressed == true)) { 
      path = 2;
    }
  }

  //SECOND TEXT
  else if (path == 2) {
    image (Text2, 0, 0);
    if ((mouseX > 382) && (mouseX < 443) && (mouseY > 372) && (mouseY < 397) && (mousePressed == true)) {
      path = 3;
    }
  }

  //PATH 3
  else if (path == 3) { // Laverne
    background (0);
    imageMode (CENTER);
    image (Keep, 240, 405);
    image (Fire, 720, 405);
    image (Laverne, 480, 150);

    if ((mouseY > 315) && (mouseY < 515) && (mouseX > 98) && (mouseX < 398) && (mousePressed == true)) {
      path = 4;
    } else if ((mouseX > 575) && (mouseX < 875) && (mouseY > 315) && (mouseY < 515) && (mousePressed == true)) {
      path = 4;
    }
  }

  // PATH 4
  else if (path == 4) { // Chase
    image (Keep, 240, 405);
    image (Fire, 720, 405);
    image (Chase, 480, 150);

    if ((mouseY > 315) && (mouseY < 515) && (mouseX > 98) && (mouseX < 398) && (mousePressed == true)) {
      path = 5;
    } else if ((mouseX > 575) && (mouseX < 875) && (mouseY > 315) && (mouseY < 515) && (mousePressed == true)) {
      path = 5;
    }
  }                                                    

  // PATH 5
  else if (path == 5) { // Lindsay
    image (Keep, 240, 405);
    image (Fire, 720, 405);
    image (Lindsay, 480, 150);

    if ((mouseY > 315) && (mouseY < 515) && (mouseX > 98) && (mouseX < 398) && (mousePressed == true)) {
      path = 6;
    } else if ((mouseX > 575) && (mouseX < 875) && (mouseY > 315) && (mouseY < 515) && (mousePressed == true)) {
      path = 6;
    }
  }

  else if (path == 6) {
    image (Keep, 240, 405);
    image (Fire, 720, 405);
    image (Riley, 480, 150);

    if ((mouseY > 315) && (mouseY < 515) && (mouseX > 98) && (mouseX < 398) && (mousePressed == true)) {
      path = 7;
    } else if ((mouseX > 575) && (mouseX < 875) && (mouseY > 315) && (mouseY < 515) && (mousePressed == true)) {
      path = 7;
    }
  }

  else if (path == 7) {
    imageMode (CORNER);
    image (FinalText, 0, 0);
  }
}

Any help would be greatly appreciated!

int radius = 12;
int direction = 1;
int direction2 = 0;

float x = 250;
float y = 250;


void setup() {
  size(500, 500);
  ellipseMode(RADIUS);
}

void draw() {
  background(255);
  fill (0, 175, 255);
  smooth ();
  noStroke();
  render();

}

void keyPressed() {
  if (key == CODED) {
    if (keyCode == LEFT) {
      x = x - 10;
      direction = -1;
      direction2 = 0;
    }
    else if (keyCode == RIGHT) {  
      x = x + 10;
      direction = 1;
      direction2 = 0;
    }
    else if (keyCode == UP) {
      y = y - 10;
      direction = 0;
      direction2 = -1;
    }
    else if (keyCode == DOWN) { 
      y = y + 10;
      direction = 0;
      direction2 = 1;
    }
  }
}


void render() {
  for ( int i=-1; i < 2; i++) {
    for ( int j=-1; j < 2; j++) {
      pushMatrix();
      translate(x + (i * width), y + (j*height));
      if ( direction == -1) { 
        rotate(PI);
      }
      if ( direction2 == 1) { 
        rotate(HALF_PI);
      }
      if ( direction2 == -1) { 
        rotate( PI + HALF_PI );
      }
      arc(0, 0, radius, radius, map((millis() % 500), 0, 500, 0, 0.52), map((millis() % 500), 0, 500, TWO_PI, 5.76) );
      popMatrix();
      // mouth movement //
    }
  }
}

Ghost Blinky;
Ghost Inky; 
Ghost Pinky;
Ghost Clyde;

Pac Man;


void setup() {
  size(800, 800);
  smooth();

  Blinky = new Ghost(color(255, 0, 0), 0, 60, 2, 1); 
  Inky = new Ghost(color(0, 233, 252), 0, 60, 3, 2);
  Pinky = new Ghost(color(248, 0, 252), 0, 60, 1, 3);
  Clyde = new Ghost(color(252, 80, 0), 0, 60, 2, 4);

  Man = new Pac(color(254, 255, 8), 0, 60, 3, 1);
}

void draw() {
  background(255);
  Blinky.move();
  Blinky.display();
  Inky.move();
  Inky.display();
  Pinky.display();
  Pinky.move();
  Clyde.display();
  Clyde.move();

  Man.display();
  Man.move1();
}


class Ghost { 
  color c;
  float x = 80;
  float y = 60;
  float speedX;
  float speedY;


  Ghost(color vC, float Xpos, float Ypos, float Xspeed, float Yspeed) { 
    c = vC;
    x = Xpos;
    y = Ypos;
    speedX = Xspeed;
    speedY = Yspeed;
  }
}


class Pac {
  color b;
  float xX = 80;
  float yY = 60;
  float speedX;
  float speedY;

  Pac(color cB, float Xpos, float Ypos, float Xspeed, float Yspeed) { 
    b = cB;
    xX = Xpos;
    yY = Ypos;
    speedX = Xspeed;
    speedY = Yspeed;
  }
}

void display() {

  fill(c);

  // Ghost Body
  beginShape();
  vertex(x - 20, y - 50);
  vertex(x - 20, y - 40);
  vertex(x - 30, y - 40);
  vertex(x - 30, y - 30);
  vertex(x - 40, y - 30);
  vertex(x - 40, y - 25);
  vertex(x - 50, y - 25);
  vertex(x - 50, y - 13);
  vertex(x - 55, y - 13);
  vertex(x - 55, y + 51);
  vertex(x - 47, y + 51);
  vertex(x - 47, y + 60);
  vertex(x - 35, y + 60);
  vertex(x - 35, y + 51);
  vertex(x - 25, y + 51);
  vertex(x - 25, y + 43);
  vertex(x - 20, y + 43);
  vertex(x - 20, y + 51);
  vertex(x - 10, y + 51);
  vertex(x - 10, y + 60);
  vertex(x + 5, y + 60);
  vertex(x + 5, y + 51);
  vertex(x + 10, y + 51);
  vertex(x + 10, y + 43);
  vertex(x + 20, y + 43);
  vertex(x + 20, y + 51);
  vertex(x + 25, y + 51);
  vertex(x + 25, y + 60);
  vertex(x + 40, y + 60);
  vertex(x + 40, y + 51);
  vertex(x + 45, y + 51);
  vertex(x + 45, y);
  vertex(x + 40, y);
  vertex(x + 40, y - 10);
  vertex(x + 35, y - 10);
  vertex(x + 35, y - 30);
  vertex(x + 30, y - 30);
  vertex(x + 30, y - 40);
  vertex(x + 20, y - 40);
  vertex(x + 20, y - 50);
  vertex(x - 20, y - 50);
  endShape();

  fill(255, 255, 255);

  // Right EYE
  beginShape();
  vertex(x + 30, y - 40);
  vertex(x + 20, y - 40);
  vertex(x + 20, y - 30);
  vertex(x + 10, y - 30);
  vertex(x + 10, y - 10);
  vertex(x + 20, y - 10);
  vertex(x + 20, y);
  vertex(x + 30, y);
  vertex(x + 30, y - 10);
  vertex(x + 35, y- 10);
  vertex(x + 35, y - 30);
  vertex(x + 30, y - 30);
  vertex(x + 30, y - 40);
  endShape(); 

  fill(255, 255, 255);

  //LEFT EYE
  beginShape();
  vertex(x - 10, y - 30);
  vertex(x - 20, y - 30);
  vertex(x - 20, y - 40);
  vertex(x - 30, y - 40);
  vertex(x - 30, y - 30);
  vertex(x - 40, y - 30);
  vertex(x - 40, y - 10);
  vertex(x - 30, y - 10);
  vertex(x - 30, y);
  vertex(x - 20, y);
  vertex(x - 20, y - 10);
  vertex(x - 10, y - 10);
  vertex(x - 10, y - 30);
  endShape();

  fill(0, 0, 0);

  // LEFT PUPIL
  beginShape();
  vertex(x - 10, y - 30);
  vertex(x - 20, y - 30);
  vertex(x - 20, y - 20);
  vertex(x - 10, y - 20);
  vertex(x - 10, y - 30);
  endShape();

  fill(0, 0, 0);

  //RIGHT PUPIL
  beginShape();
  vertex(x + 35, y - 30);
  vertex(x + 25, y - 30);
  vertex(x + 25, y - 20);
  vertex(x + 35, y - 20);
  vertex(x + 35, y - 30);
  endShape();


  // Pac Man
  fill(230, 247, 5);

  beginShape();
  vertex(xX + 48, yY);
  vertex(xX + 48, yY - 10);
  vertex(xX + 42, yY - 10);
  vertex(xX + 42, yY - 15);
  vertex(xX + 36, yY - 15);
  vertex(xX + 36, yY - 23);
  vertex(xX + 25, yY - 23);
  vertex(xX + 25, yY - 30);
  vertex(xX - 29, yY - 30);
  vertex(xX - 29, yY - 22);
  vertex(xX - 37, yY - 22);
  vertex(xX - 37, yY - 15);
  vertex(xX - 45, yY - 15);
  vertex(xX - 45, yY - 7);
  vertex(xX - 55, yY - 7);
  vertex(xX - 55, yY + 2);
  vertex(xX - 61, yY + 2);
  vertex(xX - 61, yY + 60);
  vertex(xX - 55, yY + 60);
  vertex(xX - 55, yY + 70);
  vertex(xX - 47, yY + 70);
  vertex(xX - 47, yY + 75);
  vertex(xX - 40, yY + 75);
  vertex(xX - 40, yY + 85);
  vertex(xX - 29, yY + 85);
  vertex(xX - 29, yY + 95);
  vertex(xX + 25, yY + 95);
  vertex(xX + 25, yY + 85);
  vertex(xX + 30, yY + 85);
  vertex(xX + 30, yY + 75);
  vertex(xX + 43, yY + 75);
  vertex(xX + 43, yY + 68);
  vertex(xX + 48, yY + 68);
  vertex(xX + 48, yY + 60);
  vertex(xX + 35, yY + 60);
  vertex(xX + 35, yY + 50);
  vertex(xX + 20, yY + 50);
  vertex(xX + 20, yY + 43);
  vertex(xX + 10, yY + 43);
  vertex(xX + 10, yY + 35);
  vertex(xX - 5, yY + 35);
  vertex(xX - 5, yY + 25);
  vertex(xX + 10, yY + 25);
  vertex(xX + 10, yY + 18);
  vertex(xX + 20, yY + 18);
  vertex(xX + 20, yY + 8);
  vertex(xX + 30, y + 8);
  vertex(xX + 30, yY);
  vertex(xX + 48, yY);
  endShape();


  // Power Pellet

  fill(255);
  beginShape();
  vertex(xX + 90, yY + 20);
  vertex(xX + 80, yY + 20);
  vertex(xX + 80, yY + 30);
  vertex(xX + 70, yY + 30);
  vertex(xX + 70, yY + 40);
  vertex(xX + 80, yY + 40);
  vertex(xX + 80, yY + 50);
  vertex(xX + 90, yY + 50);
  vertex(xX + 90, yY + 40);
  vertex(xX + 100, yY + 40);
  vertex(xX + 100, yY + 30);
  vertex(xX + 90, yY + 30);
  vertex(xX + 90, yY + 20);

  endShape();
}

void move() {
  x = x + speedX;
  y = y + speedY;

  // SETS THE BOUNDARIES for Ghosts

  if ( x > width)
  {
    speedX = - speedX;
  } else if ( x < 1)
  {
    speedX = - speedX;
  } else if (  y > height)
  {
    speedY = - speedY;
  } else if ( y < 1)
  {
    speedY = - speedY;
  }
}


void move1() {
  xX = xX + speedX;
  yY = yY + speedY;

  // SETS THE BOUNDARIES for Ghosts

  if ( xX > width)
  {
    speedX = - speedX;
  } else if ( xX < 1)
  {
    speedX = - speedX;
  } else if (  yY > height)
  {
    speedY = - speedY;
  } else if ( yY < 1)
  {
    speedY = - speedY;
  }
}

The map1 class

class map1 {
  int SIDE = 30; //How big is the rectangle (30x30)
  PImage tile;
  char[][] map = {
  //Where X is a rectangle will be drawn. 
  //1,2,3 and 4 are for portals (which I didn't code yet). 
  //The A is an empty spot, seems like I can't leave the array empty so I filled it with A

    {'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', '1', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '2', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', ' ', ' ', ' ', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'X', 'X', 'X', 'X', 'X', 'X'}, 
    {'X', ' ', ' ', ' ', 'X', 'X', ' ', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'P', 'x', 'x', 'x', 'x', 'x', 'p'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'X', 'X', 'X', 'X', 'X', 'X'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', ' ', ' ', 'X', 'X', ' ', ' ', ' ', ' ', ' ', 'X', 'X', 'x', 'x', 'x', 'x', 'x', 'X', 'X', ' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', ' ', ' ', 'X', 'X', 'X', 'x', 'X', 'X', 'X', ' ', ' ', 'X', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', 'X', 'X', 'X', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', ' ', ' ', 'X', 'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', ' ', ' ', 'X', ' ', ' ', 'X', ' ', ' ', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', ' ', ' ', 'X', ' ', ' ', 'X', ' ', ' ', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'X', 'X', 'X', ' ', 'X', ' ', ' ', ' ', 'X', ' ', 'X', 'X', 'X', ' ', ' ', ' ', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', 'X', 'X', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', 'X', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', 'X', ' ', ' ', ' ', 'X', ' ', ' ', ' ', 'X', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', ' ', 'X', ' ', 'X', 'X', 'X', 'X', ' ', 'X', 'X', 'X', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', 'X', 'X', ' ', 'X', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', '3', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'X', 'X', 'X', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '4', 'X', 'A', 'A', 'A', 'A', 'A', 'A'}, 
    {'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'A', 'A', 'A', 'A', 'A', 'A'} };

  map1() {

    tile = loadImage("tile.jpg");
  }

  void display() {

    for (int i = 0; i<23; i++) {

      for (int j = 0; j<37; j++) { 

        if (map[i][j]=='X') { 

          image(tile, j*SIDE, i*SIDE); 
        }
      }
    }
  }
}

Pac class

class pac {

  int x, y, R, speed = 2;
  String TOUP, TODOWN, TOLEFT, TORIGHT, direction = "TORIGHT";

  pac() {
    x = 465;
    y = 405;
    R = 15; 
  }

  void display() {

    ellipse(x,y,R*2,R*2);
  }

  void move() {

    switch (direction) {

      case "TORIGHT":
          x+=speed;
      break;
      case "TOLEFT":
          x-=speed;
      break;
      case "TOUP":
          y-=speed;
      break;
      case "TODOWN":
          y+=speed;
      break;
      case "NOMOVE":
          //Stop moving if hits a wall
      break;      
    }

    if (keyCode == LEFT) {
      direction = "TOLEFT";
    }
    if (keyCode == RIGHT) {
      direction = "TORIGHT";
    }
    if (keyCode == DOWN) {
      direction = "TODOWN";
    }
    if (keyCode == UP) {
      direction = "TOUP";
    }

  }

  void collision() {


  }

}

How the game looks so far if helps, don't pay attention to the numbers, I was just trying to make collisions work.

Here is some of the code: (I am not sure what is the issue so I just posted a section of the stuff I wrote, but let me know if you need more information/code.)

  void setup() {
    size(448, 576);
    //size(448, 726);
    //surface.setResizable(true);
    background(255);
    mazeimg = loadImage("mazeimg.png");
    image(mazeimg, 0, 0);

  rectColor = color(0);
  rectHighlight = color(51);
  rectX = 0;
  rectY = 0;


    //////////System.out.println(start);
    int cols = 28;
    String[] lines = loadStrings("MainMaze.txt");
    //String[] mazeLines = new String[lines.length];
    maze = new Location[36][28];

    for (int r = 0; r < lines.length; r ++) { 
      for (int c = 0; c < lines[0].length(); c ++) { 
        //////////System.out.println("row: " + r + " col: " + c);
        if (lines[r].charAt(c) == '0') { 
          maze[r][c] = new Wall (r, c); 
        } else {
          maze[r][c] = new EmptySpace(r,c); 
        }
        }
      }
      int x1 = 0, y1 = 0; 
      int c;
      for (int r = 0; r < maze.length; r ++) {
        for (c =  0; c < maze[r].length; c ++) { 
          y1 = (width / 28) * r; //+75;
          x1 = (height / 36) * c; 
          if (!maze[r][c].isValid()) { // if it's wall
            noFill();
            rect (x1, y1, (width/ 28), (height/36));
          } 
          else if (maze[r][c].isValid()){ // if it's an open space
          //////////System.out.println ("x: " + r + " y: " + c);

            fill(#000000); 
            //noStroke(); (add this in later when we're done)
            rect (x1, y1, (width/ 28), (height/36));
            // for tiny dots


          }
        }   
      }

    pac = new Pacman (); 
    locPac = maze[pac.getR()][pac.getC()]; 
    ellipse (pac.xPixel(), pac.yPixel() , 16, 16);

    redd = new RedGhost("red");
    locRed = maze[redd.getR()][redd.getC()]; 
    redd.moveTo(maze[16][12]);
    ellipse ( redd.xPixel() , redd.yPixel(), 16, 16);


    pink = new RedGhost("pink");
    locPink = maze[pink.getR()][pink.getC()]; 
    pink.moveTo(maze[16][15]);
     ellipse (pink.xPixel() , pink.yPixel(), 16, 16);

    blue = new RedGhost("blue");
    locBlue = maze[blue.getR()][blue.getC()]; 
    blue.moveTo(maze[18][12]);
    ellipse ( blue.xPixel() , blue.yPixel(), 16, 16);

    orange = new RedGhost("orange");
    locOrange = maze[orange.getR()][orange.getC()]; 
    orange.moveTo(maze[18][15]);
     ellipse (orange.xPixel() , orange.yPixel(), 16, 16);

     n = redd;

  }

  void draw() {

    //////////System.out.println (n);
     a++; 


    if (called && a == 40) { 
      //System.out.println (true);
      redd.moveRandom(); 
         pink.moveRandom(); 
         blue.moveRandom(); 
         orange.moveRandom();
         called = false;
    } 

    update(mouseX, mouseY);
    if (rectOver) {
    fill(rectHighlight);
     } else {
    fill(rectColor);
  }
  stroke(255);
  rect(rectX, rectY, rectSize, rectSize);


    color col = color(0, 255, 0);
    fill(col);
    noStroke();
    y = locPac.getR() * (width / 28) + 16;
    x = locPac.getC() * (height/ 36) + 8;
      background (0); 



    background(255);
    mazeimg = loadImage("mazeimg.png");
    image(mazeimg, 0, 0);
    for (int r = 0; r < maze.length; r ++) { 
      for (int c = 0; c < maze[r].length; c ++) { 
        if (maze[r][c].isValid() && maze[r][c].hasDot()){ 
           fill(#FFEC00);
              noStroke();
              ellipse(maze[r][c].xPixel(), maze[r][c].yPixel(), 8, 8);

        } 
        }


         rectColor = color(#000000 );
  rectHighlight = color(51);
  rectX = 0;
  rectY = 0;
    fill (color(0,255,0));
    locPac = maze[pac.getR()][pac.getC()]; 
    ellipse (pac.xPixel() , pac.yPixel() , 16, 16);


    fill (color(255,0,0));
    locRed= maze[redd.getR()][redd.getC()]; 
    ellipse (redd.xPixel(), redd.yPixel(), 16, 16);


    fill (#FFC0CB) ;
    locPink = maze[pink.getR()][pink.getC()];
    ellipse (pink.xPixel(), pink.yPixel(), 16, 16);


    fill(#0000FF);
    locBlue = maze[blue.getR()][blue.getC()]; 
    ellipse (blue.xPixel(), blue.yPixel(), 16, 16);

    fill (#FFA500) ;
    locOrange = maze[orange.getR()][orange.getC()]; 
    ellipse (orange.xPixel(), orange.yPixel(), 16, 16);

   }

  if (locRed.equals(locPac) || locBlue.equals(locPac) || locOrange.equals(locPac) || locPink.equals(locPac)){ 
    background(0);
    println("game over: " + pac.score + " points earned");
    noLoop();
    try {
        Thread.sleep(1000);
    } catch (Exception e) {exit();}
    exit();
      } 

        }

void update(int x, int y) {
  if ( overRect(rectX, rectY, rectSize, rectSize) ) {
    rectOver = true;
  } else {
    rectOver = false;
  }
}

void mousePressed() {

  if (rectOver) {
    draw(); 
  }
}

boolean overRect(int x, int y, int width, int height)  {
  if (mouseX >= x && mouseX <= x+width && 
      mouseY >= y && mouseY <= y+height) {
    return true;
  } else {
    return false;
  }
}

      void keyPressed() {

      // 1 = red, 2 = pink, 3 =  orange, 4 = blue;

      if (key == '1') { 

        n = redd; 
      } else if (key == '2') { 
        n = pink; 
      } else if (key == '3') { 
        n = orange;       
      } else if (key == '4') { 
        n = blue;
      } 

      locN = maze[n.getR()][n.getC()];
      ////////System.out.println(locN);

      //////////System.out.println(n.getLocation());
        if (key == CODED) {

      if (keyCode == UP) {

        if (n.getR() > 0 && maze[n.getR() -1][n.getC()].isValid()) 

        locN = maze[n.getR()- 1][n.getC()];
        ////////System.out.println(locN);
            //////////System.out.println(n.getLocation());
      } else if (keyCode == DOWN) {
        if (n.getR() < 35 && maze[n.getR() + 1][n.getC()].isValid()) 
        locN = maze[n.getR()+1][n.getC()];
            //////////System.out.println(n.getLocation());
      } else if (keyCode == RIGHT) { 
        if (n.getC() < 27 && maze[n.getR()][n.getC() + 1].isValid()) { 
          //////////System.out.println ("true");
        locN = maze[n.getR()][n.getC() + 1];
            //////////System.out.println(n.getLocation());
        }
        //////////System.out.println ("false");
      } else if (keyCode == LEFT) { 
        if (n.getC() > 0 && maze[n.getR()][n.getC() - 1].isValid()) 
        locN = maze[n.getR()][n.getC() - 1];
            //////////System.out.println(n.getLocation());
      }

           ArrayList<Location> neighbors = new ArrayList<Location>();
     neighbors.clear();

      for (int i = 0; i < xShift.length; i ++) { 
         if(pac.getR() + xShift[i] > 0 && pac.getR() + xShift[i] < 36 && pac.getC() + yShift[i] > 0 && pac.getC() + yShift[i] < 28) { 
         if ( maze[pac.getR() + xShift[i]][pac.getC() + yShift[i]].isValid()) { 
           neighbors.add(maze[pac.getR() + xShift[i]][pac.getC() + yShift[i]]); 
         } 
         }
      }


      for (Location n: neighbors) {

         int reddist= n.computeShortestPath(redd.getLocation()); 
         int pinkdist = n.computeShortestPath(pink.getLocation()); 
         int bluedist = n.computeShortestPath(blue.getLocation());
         int orangedist = n.computeShortestPath(orange.getLocation()); 

        n.setAvgDist((reddist + pinkdist + bluedist +orangedist)/5);
      }

       java.util.Collections.sort(neighbors);

       //for (Location local: neighbors) { 
         Location target = neighbors.get(0);

        for (Location n: neighbors) {
            if (locPac.hasDot()) { 

      locPac.setDot(new Dot("empty")); 
         pac.moveTo(n);
        }
        }
        n.moveTo(maze[locN.getR()][locN.getC()]);
        pac.setScore (pac.getScore() + 1);
        }
}

Our creature class looks like this:

  abstract class  Creature {

  int r, c; 
  int xPixel () { 
      return c * 16  + 8;
    }
     int yPixel () { 
      return r * 16 + 8; 
    }  
  }

public abstract class item
{
abstract void pacEatsDots();
}


public class Pacman extends item
{
  int x;
  int y;
  int radius = 15;
  int direction = 1;
  int direction2 = 0;

  public Pacman(int xn, int yn)
  {
    x = xn;
    y = yn;
  }

  void keyPressed() {//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
    color white = color(255, 255, 255);
    color black = color(0, 0, 0);
    color c = pg.get(x+1, y);
    color d = pg.get(x, y+1);
    color e = pg.get(x-1, y);
    color f = pg.get(x, y-1);

    if (key == CODED)
    {
      if (e == white)
      {
        if (keyCode == LEFT) 
        {
          x = x - 2;
          direction = -1;
          direction2 = 0;
        }
      } 
      if ( c == white)
      {
        if (keyCode == RIGHT) 
        {  
          x = x + 2;
          direction = 1;
          direction2 = 0;
        }
      } 
       if ( f == white)
      {
         if (keyCode == UP) 
        {
          y = y - 2;
          direction = 0;
          direction2 = -1;
        }
      } 
      if ( d == white)
      {
         if (keyCode == DOWN) 
        { 
          y = y + 2;
          direction = 0;
          direction2 = 1;
        }
      }
    }
    render();
  }


  public void render() {//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
    for ( int i=-1; i < 2; i++) {
      for ( int j=-1; j < 2; j++) {
        pushMatrix();
        translate(x +(i*width), y + (j*height) );
        if ( direction == -1) { 
          rotate(PI);
        }
        if ( direction2 == 1) { 
          rotate(HALF_PI);
        }
        if ( direction2 == -1) { 
          rotate( PI + HALF_PI );
        }

        arc(0, 0, radius*2.3, radius*2.3, map((millis() % 500), 0, 500, 0, 0.52), map((millis() % 500), 0, 500, TWO_PI, 5.76) );
        popMatrix();
        fill(255, 255, 0);
        // mouth movement //
      }
    }
  }




  void pacEatsDots()
  {

  }
  }



public class Dots  {
  float x, y;
  boolean isVisible;
  boolean on=true;
  Dots(float ix, float iy) {
    x = ix;
    y = iy;
    isVisible = true;
  }
  void display() {
    fill(#E5DA99);


    ellipse(x,y,12,12);


  }

  void displayBigDots()//https://processing.org/discourse/beta/num_1261323787.html
  {

  if(frameCount% 8== 0) {
    if(on)
  fill(255);
    else
  fill(0);
    on = !on;
  }
  ellipse(x,y,20,20);
  }
  //public void setup(
}

ArrayList<Dots> dots = new ArrayList();
Pacman pac;
PImage img;
PImage startscreen;
PGraphics pg;
boolean path = false;
Dots dotUpperLeftCorner;
Dots dotUpperRightCorner;
Dots dotLowerLeftCorner;
Dots dotLowerRightCorner;
void setup()
{
  background(0);

  size(723, 800);
  int y=40;
  int x = 40;
  dotUpperLeftCorner = new Dots(40, 40);
  dotUpperRightCorner = new Dots(683, 40);
  dotLowerLeftCorner = new Dots(40, 610);
  dotLowerRightCorner = new Dots(680,610);
  img = loadImage("psb2.jpg");
  pac = new Pacman(362, 610);
  pg = createGraphics(723, 800);

  for (int i =0; i<28; i++)//long line left side
  {
    dots.add(new Dots(165, y+20)); 
    y+=23;
  }
  for(int i = 0;i<5;i++)
  {
    dots.add(new Dots(x,y-645));
    y+=22;
  }
  for(int i = 0; i<5;i++)
  {
    dots.add(new Dots(x,y-644));
    x+=26;
  }
  for(int i = 0;i<11;i++)
  {
    dots.add(new Dots(x-110,y-755));
    x+=26;
  }
  for(int i = 0;i<20;i++)
  {
    dots.add(new Dots(x-265,y-644));
    x+=26;
  }
   for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-935,y-620));
    y+=26;
  }
   for(int i = 0;i<4;i++)
  {
    dots.add(new Dots(x-910,y-645.5));
    x+=26;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-837,y-695));
    y+=26;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-810,y-720));
    x+=26;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-760,y-720));
    x+=26;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-758,y-773));
    y+=26;
  }
  for(int i = 0;i<5;i++)
  {
    dots.add(new Dots(x-837,y-990));
    y+=23;
  }
  for(int i = 0;i<10;i++)
  {
    dots.add(new Dots(x-812,y-1105));
    x+=26;
  }
  for(int i = 0;i<4;i++)
  {
    dots.add(new Dots(x-811,y-1080));
    y+=23;
  }
  for(int i = 0;i<4;i++)
  {
    dots.add(new Dots(x-1175,y-1175));
    y+=23;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-811,y-1155));
    y+=26;
  }
  for(int i = 0;i<4;i++)
  {
    dots.add(new Dots(x-915,y-1180));
    x+=26;
  }
  for(int i = 0;i<4;i++)
  {
    dots.add(new Dots(x-1046,y-1345));
    y+=23;
  }
  for(int i = 0;i<23;i++)
  {
    dots.add(new Dots(x-1044,y-1325));
    y+=23;
  }
  for(int i = 0;i<5;i++)
  {
    dots.add(new Dots(x-1015,y-1500));
    x+=25;
  }
  for(int i = 0;i<6;i++)
  {
    dots.add(new Dots(x-1320,y-1500));
    x+=25;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-1470,y-1480));
    y+=23;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-1555,y-1550));
    y+=23;
  }
  for(int i = 0;i<6;i++)
  {
    dots.add(new Dots(x-1685,y-1638));
    x+=26;
  }
  for(int i = 0;i<5;i++)
  {
    dots.add(new Dots(x-1990,y-1638));
    x+=26;
  }
  for(int i = 0;i<14;i++)
  {
    dots.add(new Dots(x-1970,y-1554));
    x+=26;
  }
  for(int i = 0;i<2;i++)
  {
   dots.add(new Dots(x-2484,y-1610));
    y+=26;
  }
  for(int i = 0;i<2;i++)
  {
    dots.add(new Dots(x-2460,y-1604));
    x+=26;
  }
  for(int i = 0;i<2;i++)
  {
   dots.add(new Dots(x-2485,y-1580));
    y+=26;
  }
  for(int i = 0;i<5;i++)
  {
    dots.add(new Dots(x-2535,y-1585));
    x+=26;
  }
  for(int i = 0;i<2;i++)
  {
   dots.add(new Dots(x-2665,y-1560));
    y+=26;
  }
  for(int i = 0;i<26;i++)
  {
    dots.add(new Dots(x-2665,y-1565));
    x+=26;
  }
  for(int i = 0;i<3;i++)
  {
   dots.add(new Dots(x-2692,y-1635));
    y+=26;
  }
  for(int i = 0;i<2;i++)
  {
   dots.add(new Dots(x-2978,y-1695));
    y+=26;
  }
  for(int i = 0;i<2;i++)
  {
   dots.add(new Dots(x-3065,y-1745));
    y+=26;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-2976,y-1818));
    x+=26;
  }
  for(int i = 0;i<3;i++)
  {
    dots.add(new Dots(x-3196,y-1820));
    x+=26;
  }
  for(int i = 0;i<3;i++)
  {
   dots.add(new Dots(x-3063,y-1870));
    y+=26;
  }
  for(int i = 0;i<3;i++)
  {
   dots.add(new Dots(x-3294,y-1950));
    y+=26;
  }
  for(int i = 0;i<3;i++)
  {
   dots.add(new Dots(x-2910,y-2047));
    y+=26;
  }
  for(int i = 0;i<4;i++)
  {
    dots.add(new Dots(x-2964,y-2050));
    x+=28;
  }
  for(int i = 0;i<1;i++)
  {
    dots.add(new Dots(x-2994,y-2126));
    x+=28;
  }
  for(int i = 0;i<2;i++)
  {
   dots.add(new Dots(x-2995,y-2180));
    y+=28;
  }

}



void draw()
{
  stroke(0);
  image(img, 0, 0);
  fill(255);
  pg.beginDraw();
  pg.background(0);
  pg.stroke(255);
  pg.strokeWeight(21.0);
  pg.line(40, 40, 40, 225);//pathway
  pg.line(40, 225, 165, 225);//pathway
  pg.line(40, 40, 325, 40);//pathway
  pg.line(165, 40, 165, 685);
  pg.line(165, 685, 40, 685);
  pg.line(40, 685, 40, 755);
  pg.line(40, 755, 690, 755);
  pg.line(690, 755, 690, 685);
  pg.line(690, 685, 560, 685);
  pg.line(560, 685, 560, 40);
  pg.line(400, 40, 690, 40);
  pg.line(400, 40, 400, 145);
  pg.line(690, 40, 690, 145);
  pg.line(690, 145, 40, 145);
  pg.line(325, 40, 325, 145);
  pg.line(245, 145, 245, 225);
  pg.line(245, 225, 320, 225);
  pg.line(320, 225, 320, 300);
  pg.line(250, 300, 480, 300);
  pg.line(250, 300, 250, 375);
  pg.line(480, 300, 480, 375);
  pg.line(480, 375, 800, 375);
  pg.line(250, 375, 0, 375);
  pg.line(250, 375, 250, 525);
  pg.line(40, 525, 320, 525);
  pg.line(40, 525, 40, 610);
  pg.line(320, 525, 320, 610);
  pg.line(320, 610, 165, 610);
  pg.line(40, 610, 90, 610);
  pg.line(90, 610, 90, 685);
  pg.line(320, 610, 560, 610);
  pg.line(475, 610, 475, 685);
  pg.line(475, 685, 405, 685);
  pg.line(405, 685, 405, 755);
  pg.line(320, 755, 320, 680);
  pg.line(320, 680, 250, 680);
  pg.line(250, 680, 250, 610);
  pg.line(400, 610, 400, 525);
  pg.line(400, 525, 680, 525);
  pg.line(680, 525, 680, 610);
  pg.line(680, 610, 630, 610);
  pg.line(630, 610, 630, 685);
  pg.line(480, 375, 480, 525);
  pg.line(480, 455, 250, 455);
  pg.line(400, 300, 400, 225);
  pg.line(400, 225, 480, 225);
  pg.line(480, 225, 480, 145);
  pg.line(690, 145, 690, 220);
  pg.line(690, 220, 560, 220);
  pg.endDraw();
 //image(pg, 0, 0);


  for (int i =0; i<dots.size (); i++)
  {
    dots.get(i).display();
  }

  dotUpperLeftCorner.displayBigDots();
  dotUpperRightCorner.displayBigDots();
  dotLowerLeftCorner.displayBigDots();
  dotLowerRightCorner.displayBigDots();
  pac.keyPressed();

}

//Here is the code in my void setup and draw tab
    Pacman pac;
    PImage img;
    PImage startscreen;
    float x = 250.0;
    float y = 250.0;
    int direction = 1;
    int direction2 = 0;
    int radius = 15;



    void setup()
    {
      background(0);
      size(723, 800);
      pac = new Pacman(100, 200);
    }

    void draw()
    {
      // startscreen = loadImage("startscreen2.jpg");
      img = loadImage("psb2.jpg");
      stroke(0);
      image(img, 0, 0);
      pac.display();
      render();
      stroke(255);
      strokeWeight(3.0);
      line(40, 40, 40, 225);//pathway
      line(40, 225, 165, 225);//pathway
      line(40, 40, 325, 40);//pathway
      line(165, 40, 165, 685);
      line(165, 685, 40, 685);
      line(40, 685, 40, 755);
      line(40, 755, 690, 755);
      line(690, 755, 690, 685);
      line(690, 685, 560, 685);
      line(560, 685, 560, 40);
      line(400, 40, 690, 40);
      line(400, 40, 400, 145);
      line(690, 40, 690, 145);
      line(690, 145, 40, 145);
      line(325, 40, 325, 145);
      line(245, 145, 245, 225);
      line(245, 225, 320, 225);
      line(320, 225, 320, 300);
      line(250, 300, 480, 300);
      line(250, 300, 250, 375);
      line(480, 300, 480, 375);
      line(480, 375, 800, 375);
      line(250, 375, 0, 375);
      line(250, 375, 250, 525);
      line(40, 525, 320, 525);
      line(40, 525, 40, 610);
      line(320, 525, 320, 610);
      line(320, 610, 165, 610);
      line(40, 610, 90, 610);
      line(90, 610, 90, 685);
      line(320, 610, 560, 610);
      line(475, 610, 475, 685);
      line(475, 685, 405, 685);
      line(405, 685, 405, 755);
      line(320, 755, 320, 680);
      line(320, 680, 250, 680);
      line(250, 680, 250, 610);
      line(400, 610, 400, 525);
      line(400, 525, 680, 525);
      line(680, 525, 680, 610);
      line(680, 610, 630, 610);
      line(630, 610, 630, 685);
      line(480, 375, 480, 525);
      line(480, 455, 250, 455);
      line(400, 300, 400, 225);
      line(400, 225, 480, 225);
      line(480, 225, 480, 145);
      line(690, 145, 690, 220);
      line(690, 220, 560, 220);
    }




    void keyPressed() {//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
      if (key == CODED) {
        if (keyCode == LEFT) {
          x = x - 10;
          direction = -1;
          direction2 = 0;
        } else if (keyCode == RIGHT) {  
          x = x + 10;
          direction = 1;
          direction2 = 0;
        } else if (keyCode == UP) {
          y = y - 10;
          direction = 0;
          direction2 = -1;
        } else if (keyCode == DOWN) { 
          y = y + 10;
          direction = 0;
          direction2 = 1;
        }
      }
    }


    void render() {//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
      for ( int i=-1; i < 2; i++) {
        for ( int j=-1; j < 2; j++) {
          pushMatrix();
          translate(x + (i * width), y + (j*height));
          if ( direction == -1) { 
            rotate(PI);
          }
          if ( direction2 == 1) { 
            rotate(HALF_PI);
          }
          if ( direction2 == -1) { 
            rotate( PI + HALF_PI );
          }
          arc(0, 0, radius, radius, map((millis() % 500), 0, 500, 0, 0.52), map((millis() % 500), 0, 500, TWO_PI, 5.76) );
          popMatrix();
          // mouth movement //
        }
      }
    }


//***here is my pacman class
    public class Pacman  
    {
      float x;
      float y;
      int radius = 15;
      int direction = 1;
      int direction2 = 0;

      public Pacman(float xn, float xy)
      {
        x = xn;
        y = xy;
      }

      public void display()
      {
        //yellow circle
        ellipseMode(RADIUS);//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
        smooth();
        noStroke();
        fill(255, 255, 0);
      }
    }

public interface Game
{
  public void move();
}

public class Enemies implements Game 
{
  public void move()
  {
  }

}

public abstract class Item 
{

}

Any help would be great thanks!!

public abstract class Item 
{
  public void pacEatsDots();

}

public class Pacman extends Item
{
  int x;
  int y;
  int radius = 15;
  int direction = 1;
  int direction2 = 0;

  public Pacman(int xn, int yn)
  {
    x = xn;
    y = yn;
  }

void keyPressed() {//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
  if (key == CODED) {
    if (keyCode == LEFT) {
      x = x - 5;
      direction = -1;
      direction2 = 0;
    } else if (keyCode == RIGHT) {  
      x = x + 5;
      direction = 1;
      direction2 = 0;
    } else if (keyCode == UP) {
      y = y - 5;
      direction = 0;
      direction2 = -1;
    } else if (keyCode == DOWN) { 
      y = y + 5;
      direction = 0;
      direction2 = 1;
    }
  }
}


  public void render() {//https://forum.processing.org/two/discussion/1573/spoof-of-pacman-game-for-project
  for ( int i=-1; i < 2; i++) {
    for ( int j=-1; j < 2; j++) {
      pushMatrix();
      translate(x + (i * width), y + (j*height));
      if ( direction == -1) { 
        rotate(PI);
      }
      if ( direction2 == 1) { 
        rotate(HALF_PI);
      }
      if ( direction2 == -1) { 
        rotate( PI + HALF_PI );
      }
      arc(0, 0, radius*2, radius*2, map((millis() % 500), 0, 500, 0, 0.52), map((millis() % 500), 0, 500, TWO_PI, 5.76) );
      popMatrix();
      fill(255, 255, 0);
      // mouth movement //
    }
  }
  }

  public void checkPixelsPacman()
  {
    color white = color(255, 255, 255);
    color black = color(0,0,0);
    color c = pg.get(x,y);
    if (c==white) {
      pac.keyPressed();
      pac.render();
    }
    else if(c == black)
   {
    pac.render();
   } 
  }
}

public class Dots extends Item {
  int[][] data = new int[][];
  int x;
  int y;
  public Dots(int xn,int yn)
  {
    x = xn;
    y = yn;
  }

  public void display()
  {

    fill(255); 
    ellipse(x,y,15,15);
  }
}


Pacman pac;
PImage img;
PImage startscreen;
int direction = 1;
int direction2 = 0;
int radius = 15;
PGraphics pg;
boolean path = false;
Dots dot;
void setup()
{
  background(0);
  size(723, 800);
  dot = new Dots(40,40);
  pac = new Pacman(100, 225);
  pg = createGraphics(723, 800);
  img = loadImage("psb2.jpg");
}


void draw()
{
  stroke(0);
  image(img, 0, 0);
   dot.display();


  pg.beginDraw();
  pg.background(0);
  pg.stroke(255);
  pg.line(40, 40, 40, 225);//pathway
  pg.line(40, 225, 165, 225);//pathway
  pg.line(40, 40, 325, 40);//pathway
  pg.line(165, 40, 165, 685);
  pg.line(165, 685, 40, 685);
  pg.line(40, 685, 40, 755);
  pg.line(40, 755, 690, 755);
  pg.line(690, 755, 690, 685);
  pg.line(690, 685, 560, 685);
  pg.line(560, 685, 560, 40);
  pg.line(400, 40, 690, 40);
  pg.line(400, 40, 400, 145);
  pg.line(690, 40, 690, 145);
  pg.line(690, 145, 40, 145);
  pg.line(325, 40, 325, 145);
  pg.line(245, 145, 245, 225);
  pg.line(245, 225, 320, 225);
  pg.line(320, 225, 320, 300);
  pg.line(250, 300, 480, 300);
  pg.line(250, 300, 250, 375);
  pg.line(480, 300, 480, 375);
  pg.line(480, 375, 800, 375);
  pg.line(250, 375, 0, 375);
  pg.line(250, 375, 250, 525);
  pg.line(40, 525, 320, 525);
  pg.line(40, 525, 40, 610);
  pg.line(320, 525, 320, 610);
  pg.line(320, 610, 165, 610);
  pg.line(40, 610, 90, 610);
  pg.line(90, 610, 90, 685);
  pg.line(320, 610, 560, 610);
  pg.line(475, 610, 475, 685);
  pg.line(475, 685, 405, 685);
  pg.line(405, 685, 405, 755);
  pg.line(320, 755, 320, 680);
  pg.line(320, 680, 250, 680);
  pg.line(250, 680, 250, 610);
  pg.line(400, 610, 400, 525);
  pg.line(400, 525, 680, 525);
  pg.line(680, 525, 680, 610);
  pg.line(680, 610, 630, 610);
  pg.line(630, 610, 630, 685);
  pg.line(480, 375, 480, 525);
  pg.line(480, 455, 250, 455);
  pg.line(400, 300, 400, 225);
  pg.line(400, 225, 480, 225);
  pg.line(480, 225, 480, 145);
  pg.line(690, 145, 690, 220);
  pg.line(690, 220, 560, 220);
  pg.endDraw();
 // image(pg, 0, 0);

  pac.checkPixelsPacman();

}

https://openprocessing.org/sketch/421938

I am trying to make a pacman game and am running into errors that I am unfamiliar with. I am trying to get pacman controllable with the keyboard.

Here is my code:

int mv = 60;

void setup( ) {
  size(500, 200);
  background(0);
  stroke(0);
  smooth();
  fill(255);
  for (int i = 0; i < 16; i++) {
    ellipse(100 + 25 * i, 100, 15, 15);
  }
}

void draw( ) {
  fill(0);
  arc(mv, 100, 80, 80, radians(50 - 2 * (1 + mv % 25)), radians(310 + 2 * (1 + mv % 25)));
  mv++;
  fill(255, 255, 0);
  arc(mv, 100, 80, 80, radians(50 - 2 * (1 + mv % 25)), radians(310 + 2 * (1 + mv % 25)));
}

void keyPresses() {
  if (key == CODED) {   // Get key pressed
    if (keyCode == RIGHT) {
      pDirX = pSpeed;  // set packman X to increase (+1)
      pDirY = 0;  // only move in x direction 
    } else if (keyCode == LEFT) {
      pDirX = -pSpeed;  // set Pacman X to decrease (-1)
      pDirY = 0;  // only move in X dir=ection
    } else if (keyCode == UP) {
      pDirY = -pSpeed;  //set pacman Y to decrease (-1)
      pDirY = 0;  //only move in y direction
    } else if (keyCode == DOWN) {
      pDirY = +pSpeed; // set pacman X to increase (+1)
      pDirX = 0;  //only move in Y direction
    }
  }
}

And this is the error message I am getting: http://i346.photobucket.com/albums/p405/Griff-500/Screen Shot 2017-02-14 at 1.32.44 PM_zpsocj4lget.png

Link to my GitHub repo (where you will find the game and all the necessary files to run it):

https://github.com/andremourato/Pacman-in-Processing

Here are some previews of the game:

    var pacman;
    var w = 40;
    var cols, rows;
    //width of each square is 40
    var grid = [];
    var current;
    //the current cell being visited
    var stack = [];



    function setup() {
      createCanvas(400, 400);
      cols = floor(width / w);
      rows = floor(height / w);
      pacman = new Pacman(0, 0);
      for (var j = 0; j < rows; j++) {
        for (var i = 0; i < cols; i++) {
          var cell = new Cell(i, j);
          grid.push(cell);
        }
      }
      current = grid[0];

    }

    function draw() {
      background(0);
      pacman.show();
      pacman.borders();
      for (var i = 0; i < grid.length; i++) {
        grid[i].show();
      }
      current.visited = true;
      var next = current.checkNeighbours();
      if (next) {
        next.visited = true;

        stack.push(current);

        removeWalls(current, next);

        current = next;
      } else if (stack.length > 0) {
        current = stack.pop();
      }
    }

        function keyPressed() {
      if (keyCode === RIGHT_ARROW) {
        pacman.moveh(1);
      }
      if (keyCode === LEFT_ARROW) {
        pacman.moveh(-1);
      }
      if (keyCode === UP_ARROW) {
        pacman.movev(-1);
      }
      if (keyCode === DOWN_ARROW) {
        pacman.movev(1);
      }
    }


    function Pacman(x, y) {
      this.x = x + 20;
      this.y = y + 20;
      this.toDelete = false;
      this.r = w;
      this.top = false;


      this.show = function() {
        noStroke();
        fill(255, 146, 0);
        ellipseMode(CENTER);
        ellipse(this.x, this.y, this.r, this.r);
      }

      this.moveh = function(dir) {
        this.x += dir * w;
      }
      this.movev = function(dir) {
        this.y += dir * w;
      }
      this.borders = function() {
        if (this.x > width - 1) {
          this.x = x + 20;
        }
        if (this.x < 0) {
          this.x = width - 20;
        }

        if (this.y > height - 1) {
          this.y = y + 20;
        }
        if (this.y < 0) {
          this.y = height - 20;
        }
      }
    }

    function index(i, j) {
      if (i < 0 || j < 0 || i > cols - 1 || j > rows - 1) {
        return -1;
      }
      return i + j * cols;
    }

    function Cell(i, j) {
      this.i = i;
      this.j = j;
      //i = column number
      //j = row number
      this.walls = [true, true, true, true];
      //top, right, bottom, left
      //if true you see that side of the wall of each cell, if false you do not see the wall
      this.visited = false;


      this.checkNeighbours = function() {
        var neighbours = [];
  `  //top = walls[0]`
        var top = grid[index(i, j - 1)];
        var right = grid[index(i + 1, j)];
        var bottom = grid[index(i, j + 1)];
        var left = grid[index(i - 1, j)];

        if (top && !top.visited) {
          neighbours.push(top);
        }
        if (right && !right.visited) {
          neighbours.push(right);
        }
        if (bottom && !bottom.visited) {
          neighbours.push(bottom);
        }
        if (left && !left.visited) {
          neighbours.push(left);
        }
        if (neighbours.length > 0) {
          var r = floor(random(0, neighbours.length));
          return neighbours[r];
        } else {
          return undefined;
        }

      }



      this.show = function() {
        var x = this.i * w;
        var y = this.j * w;
        stroke(255);
        if (this.walls[0]) {
          line(x, y, x + w, y);
        }
        if (this.walls[1]) {
          line(x + w, y, x + w, y + w);
        }
        if (this.walls[2]) {
          line(x + w, y + w, x, y + w);
        }
        if (this.walls[3]) {
          line(x, y + w, x, y);
        }

      }
    }

    function removeWalls(a, b) {
      var x = a.i - b.i;
      if (x === 1) {
        a.walls[3] = false;
        b.walls[1] = false;
      } else if (x === -1) {
        a.walls[1] = false;
        b.walls[3] = false;
      }
      var y = a.j - b.j;
      if (y === 1) {
        a.walls[0] = false;
        b.walls[2] = false;
      } else if (y === -1) {
        a.walls[2] = false;
        b.walls[0] = false;
      }
    }

int i=1; int nxtx; int nxty; float ang=0; float speed=10; int posx=50; int posy=300; PVector[]dots=new PVector[50]; void setup(){ background(128); size(800,600); frameRate(15); ellipseMode(RADIUS); fill(#FAF312); for(int i=0;i<50;i++){ dots[i]=new PVector(random(0,width),random(0,height));} } void draw() { background(128); stroke(10); strokeWeight(10); for(int i=0;i<50;i++){ point(dots[i].x,dots[i].y);} noStroke(); resetShader(); //ang=atan2(mouseY-posy,mouseX-posx); nxtx=posx+=speedcos(ang); nxty=posy+=speedsin(ang); if(nxty<=width1) if(nxty<=height1) translate(posx,posy); rotate(ang); arc(5,0,100,100,.4,6); if(i==1){arc(5,0,100,100,.7,6); i=-i;} else{ellipse(5,0,100,100); i=-i;} //if(keyPressed==){ if(keyPressed==true){ if(keyCode==UP){ang=-PI/2;} if(keyCode==DOWN){ang=PI/2;} if(keyCode==LEFT){ang=PI;} if(keyCode==RIGHT){ang=0;} }}

    var foods = [];
    var pacman;
    var w = 40;


    function setup() {
      createCanvas(400, 400);
      var t = 0;
      pacman = new Pacman(0, 0);
      for (var f = 0; f < 10; f++) {
        for (var g = 0; g < 10; g++) {
          foods[t++] = new Food(g * 40 + 15, f * 40 + 15);
        }
      }
    }

    function draw() {
      background(51);
      pacman.show();
      pacman.borders();

      for (var i = 0; i < foods.length; i++) {
        foods[i].cook();
        if (pacman.eats(foods[i])) {
          foods[i].eaten();
        }
      }
      for (var j = 0; j < foods.length; j++) {
        if (foods[j].toDelete) {
          foods.splice(1, j);
          console.log(foods.length);
        }
      }
    }

    function Food(x, y) {
      this.x = x;
      this.y = y;
      this.r = 10;
      this.toDelete = false;

      this.cook = function() {
        fill(255);
        ellipseMode(CORNER);
        ellipse(this.x, this.y, this.r, this.r);
      }
        this.eaten = function() {
          this.toDelete = true;
      }
    }

    function keyPressed() {
      if (keyCode === RIGHT_ARROW) {
        pacman.moveh(1);
      }
      if (keyCode === LEFT_ARROW) {
        pacman.moveh(-1);
      }
      if (keyCode === UP_ARROW) {
        pacman.movev(-1);
      }
      if (keyCode === DOWN_ARROW) {
        pacman.movev(1);
      }
    }

    function Pacman(x, y) {
      this.x = x;
      this.y = y;
      this.toDelete = false;


      this.show = function() {
        noStroke();
        fill(255, 146, 0);
        ellipseMode(CORNER);
        ellipse(this.x, this.y, w, w);
      }

      this.moveh = function(dir) {
        this.x += dir * w;
      }
      this.movev = function(dir) {
        this.y += dir * w;
      }
      this.borders = function() {
        if (this.x > width - 1) {
          this.x = 0;
        }
        if (this.x < 0) {
          this.x = width - w;
        }

        if (this.y > height - 1) {
          this.y = 0;
        }
        if (this.y < 0) {
          this.y = height - w;
        }
      }
        this.eats = function(Food) {
        var d = dist(this.x, this.y, Food.x, Food.y);
        if (d < Food.x) {
          console.log("eaten");
          return true;
        } else {
          return false;
        }
      }
    }

float ang = 0;
float speed = 10;
int posx = 50;
int posy = 300;
int i = 1;

void setup(){
  background (128);
  size(800, 600);
  frameRate(20);
  ellipseMode(RADIUS);
  fill(#FAF312);
  noStroke();
}

void draw() {
  background (128);
  ang = atan2(mouseY - posy, mouseX - posx);
  posx += speed * cos(ang);
  posy += speed * sin(ang);
  translate(posx, posy);
  rotate(ang);
  //arc(50,50,75,75,.51,5.02);

  if (i == 1){
    arc(50, 50, 50, 50, .51, 5.9);
    i = -i;
  } else {
    ellipse(50, 50, 50, 50);
    i = -i;
  }
}

class Ghost {

  int type;
  int x, y, tx, ty, ptx, pty;  
  int pgx, pgy;
  int d;  
  boolean is_scared;  
  boolean is_dead; 
  int trapped_timer;  

  Ghost(int itype) {
    type = itype % ghost_colors.length;
    x = 10 + 20 * 15;
    y = 10 + 20 * 14;
    tx = x;
    ty = y;
    ptx=tx;
    pty=ty;
    trapped_timer = 200 * type;
  }

  void dont_be_afraid() {
    if (is_scared) {
      is_scared = false;
      d=(d+2)%4;
      tx = ptx;
      ty = pty;
    }
  }

  void be_afraid() {
    if (!is_dead) {
      is_scared = true;
      d=(d+2)%4;
      tx = ptx;
      ty = pty;
    }
  }

  void draw() {
    simulate();
    render();
    if (!is_dead) kill_check();
  }

  void simulate() {
    trapped_timer--;
    if (trapped_timer > 0) return;
    int px = x;
    int py = y;
    if (tx < x) x--;
    if (tx > x) x++;
    if (ty < y) y--;
    if (ty > y) y++;
    if (px==x&&py==y) {
      ptx = tx;
      pty = ty;
      int wall_count = 0;
      for (int w = 0; w < 4; w++) {
        if ( grid.is_wall(x+decodeX[w], y+decodeY[w]) ) {
          wall_count++;
        }
      }
      if (wall_count == 4) { // >:(
        d = 4;
        tx = x+decodeX[d];
        ty = y+decodeY[d];
        return;
      }
      if (wall_count == 3) {
        for (int w = 0; w < 4; w++) {
          if ( !grid.is_wall(x+decodeX[w], y+decodeY[w]) ) {
            d = w;
          }
        }
        tx = x+decodeX[d];
        ty = y+decodeY[d];
        return;
      }
      if (wall_count == 2) {
        int result = 5;
        for (int w = 0; w < 4; w++) {
          if ( !grid.is_wall(x+decodeX[w], y+decodeY[w]) ) {
            if ( w != (d+2)%4 ) {
              result = w;
            }
          }
        }
        d = result;
        tx = x+decodeX[d];
        ty = y+decodeY[d];
        return;
      }
      int gx = int(player.x); // RED - Go for pacman.
      int gy = int(player.y);
      if (!to_corners) {
        if (type == 1 ) { // PINK = Get in front of pacman.
          gx = int(player.x)+4*decodeX[player.d];
          gy = int(player.y)+4*decodeY[player.d];
          if ( player.d == 3 ) { // Classic pink ghost behaviour.
            gx = int(player.x-80);
          }
        }
        if ( type == 2 ) { // CYAN - Negative RED's positions, offset a couple of squares.
          float mpx = player.x+2*decodeX[player.d];
          float mpy = player.y+2*decodeY[player.d];
          if (player.d == 3) { // Classic cyan ghost behaviour.
            mpx = player.x - 40;
          }
          gx = int(2*mpx - ghosts[0].x);
          gy = int(2*mpy - ghosts[0].y);
        }
        if ( type == 3 ) { // ORANGE - Get close, then back off.
          if (dist(player.x, player.y, x, y) < 160) {
            gx = 0;
            gy = height;
          }
        }
      } else {
        gx = width;
        gy = height;
        if ( type == 1 || type == 3 ) gx = 0; 
        if ( type == 1 || type == 0 ) gy = 0;
      }
      if (is_dead||is_scared) {
        gx = 10 + 20 * 15;
        gy = 10 + 20 * 14;
        if (is_dead && x==gx &&y==gy) is_dead = false;
      }    
      pgx = gx;
      pgy = gy;
      float best = -1 ;
      int result = 5;
      for ( int w = 0; w < 4; w++) {
        if ( w!=(d+2)%4 && !grid.is_wall(x+decodeX[w], y+decodeY[w])) {
          float new_dist = dist(x+decodeX[w], y+decodeY[w], gx, gy);
          if ( best == -1 || new_dist < best) {
            best = new_dist;
            result = w;
          }
        }
      }
      d = result;
      tx = x+decodeX[d];
      ty = y+decodeY[d];
      return;
    }
  }

  void render() {
    stroke(0);
    fill(is_scared?color(0, 0, 255):ghost_colors[type]);
    pushMatrix();
    translate(x, y);
    if (!is_dead) {
      rect(-11, -1, 22, 11);
      arc(0, 0, 22, 22, PI, TWO_PI);
      for (int i=0; i<4; i++) {
        arc(-7+5*i, 10, 5, 5, 0, PI);
      }
    }
    fill(255);
    noStroke();
    ellipse(-4, 0, 4, 8);
    ellipse(4, 0, 4, 8);
    if (is_dead||!is_scared) {
      fill(0, 0, 255);
      int eyex = (d==2?-1:0)+(d==0?1:0);
      int eyey = (d==3?-3:0)+(d==1?3:0);
      ellipse(-4+eyex, eyey, 3, 3);
      ellipse(4+eyex, eyey, 3, 3);
    }
    popMatrix();
  }

  void kill_check() {
    if ( grid.kill_at(x, y) ) is_dead = true;
  }
}

int[] decodeX = {    20, 0, -20, 0, 0 }; 
int[] decodeY = {    0, 20, 0, -20, 0 };

    Pacman pacman = new Pacman(75); 

   void setup() {
  size(500, 500); //set the size of the page to 500pixels by 500pixels
  ellipseMode(CENTER); //set ellipse mode to center
  }

  void draw() {

  background(0); //set background to black
  pacman.update(); //use the function update() as written in class Pacman                               
  pacman.transmit(); //use the function transmit() as written in class Pacman 
  pacman.drawTrail(); //use the function drawTrail() as written in class Pacman
  pacman.collideTrail(); //use the function collideTrail() as written in class Pacman
  pacman.checkEdges();
  pacman.draw(); //use the function draw() as written in class Pacman
  }

  class Pacman {

  PVector location; 
  PVector velocity;                                                     
  PVector acceleration;                                                    
  PVector target; 
  float topspeed; 
  float tolerance = 15;      
  float direction = 0;

  float diameter; //declare diameter as float
  float MouthAngle = 0; //set MouthAngle to 0 (starting position closed)
  float OpeningAngle = PI * 2 / 180; 
  boolean MouthMovement = true; //set variable for MouthMovement
  ArrayList trail; // declare the use of trail as an Arraylist
  boolean MousePressed = false;


  Pacman(float dia) {

    diameter = dia;  
    trail = new ArrayList(); // assign trail as a function to create a new Arraylist
    location = new PVector(250,250);            
    velocity = new PVector(0, 0); 
    target = new PVector(width/2, height/2);                              
    topspeed = 3; //top speed is assigned a value of 3
  }

  void update() {


    PVector dir = PVector.sub(target, location);
    float distance = dist(location.x, location.y, target.x, target.y); 



    if (topspeed > tolerance) {                                           
      topspeed *= 0.9;
    } else {
      topspeed = distance*0.05;
    }

    dir.normalize(); //normalize
    direction = dir.mag(); 
    acceleration = dir; // acceleration = direction                                               
    velocity.add(acceleration); 
    velocity.limit(topspeed);   //limit velocity to topspeed


    if (distance<tolerance) { 
      target.x = random(width -100, width +100); 
      target.y = random(height -100, height +100);
    } else { //if the target hasn't been reached 
      location.add(velocity); //continue to move as normal

      if (mousePressed) {
        target.x = mouseX;
        target.y = mouseY;
      }
    }
  }

  void draw() {

    float dX = location.x - target.x; 
    float dY = location.y - target.y; 


    float angle = radians((atan2(dY, dX) * 180 / PI));


    if (dist(target.x, target.y, location.x, location.y) > 0) {
      cherries();

      pushMatrix();
      translate(location.x, location.y);
      rotate(angle);
      if (MouthMovement == true) MouthAngle += OpeningAngle; 
      else MouthAngle -= OpeningAngle; 
      if (MouthAngle > TWO_PI / 8 || MouthAngle < 0) MouthMovement = ! MouthMovement;
      stroke(0);
      fill(255, 255, 0); // set fill to yellow
      arc(0, 0, diameter, diameter, HALF_PI*-2 + MouthAngle, HALF_PI*2 -MouthAngle); 
      fill (0); //set fill to black
      ellipse(0, 0 - diameter / 4, diameter/8, diameter/8);
      popMatrix();
    }
  }

  void checkEdges() {
    if (location.x  > width -diameter/2 || location.x  <0 +diameter/2 ) { 
      velocity.x *= -2; //its velocity is multiplied by -0.1
      target.x = random(width); 
      target.y = random(height);
    } 
    if (location.y +diameter/2> height || location.y  <0 +diameter/2 ) { 
      velocity.y *= -2; //its velocity is multiplied by -0.1
      target.x = random(width); 
      target.y = random(height);
    }
  }

  void transmit() {


    for (int i=0; i<trail.size (); i++) { 
      if (trail.size() != 0) { 
        crumbs t = (crumbs) trail.get(i); 
        t.draw();
      }
    }
  }
  void drawTrail() {


    trail.add(new crumbs(new PVector(location.x, location.y), 10));
  }

  void collideTrail() {

    PVector crumbPos; 
    for (int i=0; i<trail.size (); i++) {
      crumbs drop = (crumbs) trail.get(i);
      crumbPos = drop.loc;
      float d = location.dist(crumbPos); 
      if (d < diameter/2) { //if Pacman is touching the crumbs                                
        trail.remove(i);
        // target.x = random(width); 
        //  target.y = random(height); 
        //velocity.x *= -2;
        //velocity.y *= -2;
      }
    }
  }


  void cherries() {
    stroke(0, 255, 0); //set stroke to green
    line (target.x -5, target.y+1, target.x-2.5, target.y-25); //draw line
    line (target.x +5, target.y-1, target.x-2.5, target.y-25); //draw line

    stroke(0);
    fill(255, 0, 0); //set fill to red
    ellipse(target.x-5, target.y-1, 15, 15); //draw ellipse 
    ellipse(target.x+5, target.y+1, 15, 15); //draw ellipse
   }
  }

   class crumbs { 

  PVector loc; //declare loc as a PVector 
  float diameter; //declare diameter as a float 



  crumbs(PVector loc_, float dia) {
    loc = loc_; 
    diameter=dia;
  }

  void draw () { 
    fill (255, 255, 0); 
    noStroke(); 

    ellipse(loc.x, loc.y, diameter, diameter);
    }
  }

I have some parts moving, namely, a yellow dot that moves through a maze when the directional arrows are pressed.

This worked for the most part when coded basically in setup/draw, however as soon as I write a class for the exact same code (reorganized), the entire game shrinks!

I don't know what is triggering it, I think it has to do with the placement of the values that moved from the original version of setup(). I would appreciate any help. I noticed some behaviours in Processing change when written as a class (but I'm still new to this, so I can't tell if it's a quirk or my unfamiliarity).

Code written as a class

Maze gameset = new Maze(); 

void setup() {
  size(1000, 500);
}

void draw() {
  gameset.displayMap();
  gameset.keyPressed();
}

class Maze {

  //Starting by using a 2D Array to map the maze.
  int [][]maze = new int[][]{
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //TOP WALL // ROW 1
    {-1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1}, // ROW 2
    {-1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1}, //ROW 3
    {-1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1}, //ROW 4
    {-1, 1, -1, 1, -1, -1, 1, -1, -1, 0, 0, -1, -1, 1, -1, -1, 1, -1, 1, -1}, //ROW 5
    {-1, 2, 1, 1, 1, 1, 1, -1, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, -1}, //ROW 6
    {-1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1}, //ROW 7
    {-1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1}, //ROW 8  
    {-1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1}, //ROW 9
    {-1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1}, // ROW 10
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //BOTTOM WALL // ROW 11
  };

  int rows = 11;
  int cols = 20;
  int minX, maxX, minY, maxY;
  int cellWidth, cellHeight;
  int pacX = 1, pacY = 6;

  Maze() {
    minX = 10;
    maxX = width;
    minY = 10;
    maxY = height;
    cellWidth = maxX/cols;
    cellHeight = maxY/rows;
  }

  void displayMap() {
    for (int i = 0; i < cols; i++) {
      for (int j = 0; j < rows; j++) {
        pushStyle();
        noStroke();
        int value = maze[j][i];
        if (value == -1) {
          fill(0, 0, 255);
        } else if (value == 0) {
          fill(0);
        } else if (value == 1) {
          fill(0, 255, 0);
        } else {
          fill(230, 190, 30);
        }
        rect(i * cellWidth, j * cellHeight, cellWidth, cellHeight);
        popStyle();
      }
    }
    println(pacX, pacY);
  }

  void keyPressed() {
    if (key == CODED) {
      int newX = pacX, newY = pacY;
      if (keyCode == RIGHT) {
        newX = pacX + 1;
        newY = pacY;
      } else if (keyCode == LEFT) {
        newX = pacX - 1;
        newY = pacY;
      } else if (keyCode == UP) {
        newX = pacX;
        newY = pacY - 1;
      } else if (keyCode == DOWN) {
        newX = pacX;
        newY = pacY + 1;
      }
      updatePacPosition(newX, newY);
    }
  }
  void updatePacPosition(int newX, int newY) {
    if (newX < cols && newX >= 1 && newY >= 1 && newY < rows && maze[newY][newX] != -1) {
      maze[pacY][pacX] = 0;
      pacX = newX;
      pacY = newY;

      maze[pacY][pacX] = 2;
    }
  }
}

Code before class

//Starting by using a 2D Array to map the maze.


int [][]maze = new int[][]{
  {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //TOP WALL // ROW 1
  {-1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1}, // ROW 2
  {-1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1}, //ROW 3
  {-1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1}, //ROW 4
  {-1, 1, -1, 1, -1, -1, 1, -1, -1, 0, 0, -1, -1, 1, -1, -1, 1, -1, 1, -1}, //ROW 5
  {-1, 2, 1, 1, 1, 1, 1, -1, 0, 0, 0, 0, -1, 1, 1, 1, 1, 1, 1, -1}, //ROW 6
  {-1, 1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, -1}, //ROW 7
  {-1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1}, //ROW 8  
  {-1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, -1, 1, -1, -1, 1, -1}, //ROW 9
  {-1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1}, // ROW 10
  {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //BOTTOM WALL // ROW 11
};

int rows = 11;
int cols = 20;
int minX, maxX, minY, maxY;
int cellWidth, cellHeight;
int pacX = 1, pacY = 6;

void setup() {
  size(1000, 500);
  minX = 10;
  maxX = width;
  minY = 10;
  maxY = height;
  cellWidth = maxX/cols;
  cellHeight = maxY/rows;
}

void draw() {
  //fill(0);
  //rect(0, 0, width, height);
  //fill(0);
  //rect(minX, minY, maxX-minX, maxY-minY);
  for (int i = 0; i < cols; i++) {
    for (int j = 0; j < rows; j++) {
      pushStyle();
      noStroke();
      int value = maze[j][i];
      if (value == -1) {
        fill(0, 0, 255);
      } else if (value == 0) {
        fill(0);
      } else if (value == 1) {
        fill(0, 255, 0);
      } else {
        fill(230, 190, 30);
      }
      rect(i * cellWidth, j * cellHeight, cellWidth, cellHeight);
      popStyle();
    }
  }
  println(pacX, pacY);
}

void keyPressed() {
  if (key == CODED) {
    int newX = pacX, newY = pacY;
    if (keyCode == RIGHT) {
      newX = pacX + 1;
      newY = pacY;
    } else if (keyCode == LEFT) {
      newX = pacX - 1;
      newY = pacY;
    } else if (keyCode == UP) {
      newX = pacX;
      newY = pacY - 1;
    } else if (keyCode == DOWN) {
      newX = pacX;
      newY = pacY + 1;
    }
    updatePacPosition(newX, newY);
  }
}

void updatePacPosition(int newX, int newY) {
  if (newX < cols && newX >= 1 && newY >= 1 && newY < rows && maze[newY][newX] != -1) {
    maze[pacY][pacX] = 0;
    pacX = newX;
    pacY = newY;

    maze[pacY][pacX] = 2;
  }
}

Thanks!

We are doing a pacman with some friends. Unfortunately we can't manage to find out how to program the death of the pacman. We have also the same problem for "eating the coins". We know where our error is ! But we don't know how to solve it We have the position of the pacman (positionX/positionY) and of the ghost (positionF1X/positionF1Y)

if(positionX==positionF1X && positionY==positionF1Y){ background(0);
textSize(40); text("GAME OVER",200,200); text("SCORE FINAL ="+score,170,140); fill(255); }

if(positionX==positionF2X && positionY==positionF2Y){ background(0);
textSize(40); text("GAME OVER",200,200); text("SCORE FINAL ="+score,170,140); fill(255); }

if(positionX==positionF3X && positionY==positionF3Y){ background(0);
textSize(40); text("GAME OVER",200,200); text("SCORE FINAL ="+score,170,140); fill(255); }

if(positionX==positionF4X && positionY==positionF4Y){ background(0);
textSize(40); text("GAME OVER",200,200); text("SCORE FINAL ="+score,170,140); fill(255);

BUT! the position of the pacman is never completely and just superpose with the ghost! So we would like to know if there is a way to create an "if" with an interval of values (for example if positionX is nearly as positionF1X, at 10 pixels near).

Is there a solution? Thanks you so much for your help!

TeamPac

Our first question is about the mouvement of ghosts.

How can we manage to make the ghost follow the pacman. We were thinking about creating two vectros, one which relies the position of the pacman and the ghost, and the oder which is a constant horizontal (1,0)

Then, calculate the angle between the two vectors.

If the angle is 0< A <PI/2 the ghost can go to the right and up.

If the angle is PI /2< A < PI the ghost can go the left and up.

If the angle is PI < A < 3PI/2 the ghost can go down and left.

If the angle is 3 PI/2 < A <0 the ghost can go right and down.

Is there any posibility to do it?

Thank you so so much in advance.

class Pacman {

  int x;
  int y;
  int durchmesser;
  int state = 0;
  float animTimerSec = 0;
  float ANIM_CYCLE = .5;
      int score;
    int life;
    PFont font;
    boolean [] [] food = new boolean [20][15];

  Pacman(int d) {
    durchmesser = d;
    x = d/2;
    y = d/2;
  }

    ////start over the game every time pacman touches the X and Y walls
    void startOver () {
      if  ((pacman.x > width) || (pacman.x < 0) ||
        (pacman.y > height) || (pacman.y < 0)) {
    //    pacman = new pacman();     
        life-=1;
        score=0;
        background (0);
        textFont(font);
        println("You died");
        fill (0, 255, 255);
        text("You died", height/2, width/2);
      }
      if  (life==0)
      {
        println ("Game over");
        background (0);
        textFont(font);
        fill (0, 255, 255);
        text("GAME OVER ", height/2, width/2);
      }
      else if (score==100)
      {
        println ("YOU WON!!!");
        background (0);
        textFont(font);
        fill (0, 255, 255);
        text("YOU WON!!!", height/2, width/2);
      }
    }

  void draw() {
    noStroke();
    fill(#FFE624);
    animTimerSec += 1.0/frameRate;

    if (animTimerSec >= ANIM_CYCLE) {
      animTimerSec = 0;
      state++;
      state = state % 2;
    }

    if (state == 0) {
      ellipse(x, y, durchmesser, durchmesser);
    } 
    else if (state == 1) {
      arc(x, y, durchmesser, durchmesser, radians(30), 
      radians(330));
    }

    fill(0);
    ellipse(x+durchmesser/6, y-durchmesser/3, 8, 8);
  }

  void moveLeft() {
    x -= durchmesser;
    x = constrain(x, durchmesser/2, width-durchmesser/2);
  }

  void moveRight() {
    x += durchmesser;
    x = constrain(x, durchmesser/2, width-durchmesser/2);
  }

  void moveUp() {
    y -= durchmesser;
    y = constrain(y, durchmesser/2, height-durchmesser/2);
  }

  void moveDown() {
    y += durchmesser;
    y = constrain(y, durchmesser/2, height-durchmesser/2);
  }
}

// Tastatursteuerung
void keyPressed() {
  if (keyCode == LEFT) {
    pacman.moveLeft();
  }
  if (keyCode == RIGHT) {
    pacman.moveRight();
  }
  if (keyCode == UP) {
    pacman.moveUp();
  }
  if (keyCode == DOWN) {
    pacman.moveDown();
  }
}
class Punkt {
  int x;
  int y;
  int wert = 5;
  boolean alive = true;

  Punkt(int px, int py) {
    x = px;
    y = py;
  }

  void draw() {
    // zeichne nur, wenn noch nicht gefressen
    if (alive) {
      noStroke();
      fill(#FF52F4);
      ellipse(x, y, 10, 10);
    }
  }
}
int score = 0;
int cellSize = 40;
Pacman pacman = new Pacman(cellSize);
Punkt[] punkte = new Punkt[30];

void setup() {
  size(400, 400);
  for (int i = 0; i < punkte.length; i++) {
    int x = (int)random(0, 10) * cellSize + cellSize/2;
    int y = (int)random(0, 10) * cellSize + cellSize/2;
    punkte[i] = new Punkt(x, y);
  }
}



// Gibt true zurück, wenn Punkt erfolgreich gegessen

boolean tryToEat(Punkt p) {
  // Punkt ist bereits gegessen
  if (!p.alive) {
    return false;
  }

  // Wenn auf gleichem Feld: Punkt essen
  if (dist(pacman.x, pacman.y, p.x, p.y) <= 2/2) {
    p.alive = false; 
    return true; // Erfolgreich gegessen!
  }

  return false; 
}
void draw() {
  background(0);
  pacman.draw();
  for (int i = 0; i < punkte.length; i++) {
    boolean eaten = tryToEat(punkte[i]);

    if (eaten) {
      score += punkte[i].wert;
    }

    punkte[i].draw();
  }
}
class Geist {
  int x;
  int y;
  int durchmesser;

  Geist(int gx, int gy, int d) {
    x = gx;
    y = gy;
    durchmesser = d;
  }

  void draw() {
    noStroke();
    fill(#79D3FF);

    // Körper
    ellipse(x, y, durchmesser, durchmesser);
    rectMode(CORNER);
    rect(x-durchmesser/2, y, durchmesser, durchmesser/2);

    // Augen
    rectMode(CENTER);
    fill(0);
    rect(x-durchmesser/4, y, durchmesser/4, durchmesser/8);
    rect(x+durchmesser/4, y, durchmesser/4, durchmesser/8);
  }

  // Im Gegensatz zu Pacman wollen wir einen 
  // zufälligen Bewegungsschritt ausführen
  void move() {
    int richtung = (int)random(0, 4);
    if (richtung == 0) {
      moveLeft();
    }
    if (richtung == 1) {
      moveRight();
    }
    if (richtung == 2) {
      moveUp();
    }
    if (richtung == 3) {
      moveDown();
    }
  }

  void moveLeft() {
    x -= durchmesser;
    x = constrain(x, durchmesser/2, width-durchmesser/2);
  }

  void moveRight() {
    x += durchmesser;
    x = constrain(x, durchmesser/2, width-durchmesser/2);
  }

  void moveUp() {
    y -= durchmesser;
    y = constrain(y, durchmesser/2, height-durchmesser/2);
  }

  void moveDown() {
    y += durchmesser;
    y = constrain(y, durchmesser/2, height-durchmesser/2);
  }
}
// neue globale Variablen
Geist[] geister = new Geist[3];
int leben = 3;
void setup() {
  size(10*cellSize, 10*cellSize);
  for (int i = 0; i < punkte.length; i++) {
    int x = (int)random(0, 10) * cellSize + cellSize/2;
    int y = (int)random(0, 10) * cellSize + cellSize/2;
    punkte[i] = new Punkt(x, y);
  }
  for (int i = 0; i < geister.length; i++) {
    int x = (int)random(3, 10) * cellSize + cellSize/2;
    int y = (int)random(3, 10) * cellSize + cellSize/2;
    geister[i] = new Geist(x, y, cellSize);
  }
}
void manageGeister() {

  // Alle 50 Zyklen die Geister bewegen
  boolean move = false;
  if (timer <= 0) {
    move = true;
    timer = 50;
  }
  timer--;

  for (int i = 0; i < geister.length; i++) {
    if (move) {
      geister[i].move();
    }
    geister[i].draw();

    boolean eaten = geister[i].tryToEat(pacman);
    if (eaten) {
      leben--;

      // Pacman wieder oben links erscheinen lassen
      int x = cellSize/2;
      int y = cellSize/2;
      pacman.x = x;
      pacman.y = y;
    }
  }
}

-How could we manage to make the pacman going through the labyrinth (white path) without getting a out of it (black stroke). I mean, the path would be colored in white, while the walls would be colored in black.

-How could we manage to know the ubication of a pixel ?(is there a processing fonction/reference that allows us to know it?)

We would be gratefull if you could help us.