Multiple classes in processing

Question

I'm making a game where you're controlling a square, and objects will spawn in random places, which you have to pick up to get points, while also having to dodge big squares going from side to side. Right now I have 2 classes (one for enemies - big squares -, and one for the hero), I haven't done the point system yet with the spawning objects, but that's not what I'm trying to do now.

So my problem right now is that I don't really know how to make the person lose the game/a life when you touch the "enemies" with your hero. I would know how to do it without classes, but I'd like to know how to do it when they are in separate classes.

If someone could explain with code and comments how this would be done, it would help me out a lot :) (I read something about 'extends' for classes but I'm not sure if this is what I should use or not).

Here's a screenshot of what my game looks like at the moment, just to better illustrate it:

Here's the main code page:

Hero myHero = new Hero(400,480,5);
Enemies myEnemies = new Enemies(50,50,10);
Enemies myEnemies2 = new Enemies(50,350,15);
Enemies myEnemies3 = new Enemies(50,650,12);

void setup() {
    size(900,800);
    frameRate(30);
    smooth();
}

void draw() {
    background(0);
    myHero.keyPressed();
    myEnemies.enemyDisplay();
    myEnemies.enemyMove();
    myEnemies2.enemyDisplay();
    myEnemies2.enemyMove();
    myEnemies3.enemyDisplay();
    myEnemies3.enemyMove();
}

Class 1:

class Enemies {
    float xpos, ypos, speed;

    Enemies(float x, float y, float s) {
        xpos = x;
        ypos = y;
        speed = s;
    } 

    void enemyDisplay() {
        rect(xpos, ypos, 100, 100); 
    }

    void enemyMove() {
        xpos += speed;
        if((xpos > width - 100) || (xpos < 0)) {
            speed *= -1;
        }
    }
}

Class 2:

class Hero {
    float xpos_, ypos_, speed_;

    Hero(float x, float y, float s) {
        xpos_ = x;
        ypos_ = y;
        speed_ = s;
    }     

    void keyPressed() {
        if (key == CODED) {
            if (keyCode == UP) {
                ypos_ -= speed_;
            }
            if (keyCode == DOWN) {
                ypos_ += speed_;
            }
            if (keyCode == LEFT) {
                xpos_ -= speed_;
            }
            if (keyCode == RIGHT) {
                xpos_ += speed_;
            }     
        }
        rect(xpos_,ypos_,30,30);
    }
}

Answer 1

Alright got it to work thanks to all you helpful wonderful people!

I did this:

public boolean isColliding(Enemies h){
   float distance = dist(x,y,h.x,h.y);
    if(distance<100){
      return true;
    }else{
      return false;
    }
  }

and in my draw(){ I have

 if(myHero.isColliding(myEnemies)){
    println("You lost!");
  }

I had a very similar 'fix' earlier, but the reason I got an error was because I had Hero h instead of Enemies h in the 'if' function, so it was just a very dumb error that I overlooked :P

Answer 2

There are several problems here that touch on both application design as well as conventions. These should be addressed first before trying to tackle the collision detection problem.

The Enemies class only represents a single enemy, so the name of the class should reflect that. Additionally, prefixing the method names with "enemy" is redundant and can be removed. Other changes have been commented in the revised class below.

public class Enemy {
  // Instead of hard-coding in the width and height of an enemy, allow the 
  // instantiating code to specify the enemy's size.  This will allow you 
  // to have different size enemies and prevents you from having "magic numbers" 
  // in your code.
  private float xpos, ypos, width, height, speed;

  public Enemy(float x, float y, float s, float w, float h) {
    xpos = x;
    ypos = y;
    width = w;
    height = h;
    speed = s;
  }

  /* These getters will be used for collision detection later */

  public float getX() {
    return xpos;
  }

  public float getY() {
    return ypos;
  }

  public float getWidth() {
    return width;
  }

  public float getHeight() {
    return height;
  }

  // I've changed `display` to `draw` to be consistent with the method name in 
  // your main `draw` method.
  public void draw() {
    rect(xpos, ypos, width, height); 
  }

  // This method now accepts a screenWidth parameter so that the enemy can know
  // when they've collided with the left or right wall of the screen without 
  // having to rely on an global variable.
  public void move(int screenWidth) {
    xpos += speed;

    if ((xpos > screenWidth - width) || (xpos < 0)) {
      speed *= -1;
    }
  }
}

I mention the "magic numbers" in one of the comments above. See this wikipedia article for more on that.

The Hero class contains property names that have an underscore postfix. This ranges from unconventional to inconsistent with respect to all of your other property names in your other classes. The original keyPressed() method mixes the logic for both drawing and moving. These two things have been separated and the methods named like those of the Enemy class for consistency.

public class Hero {
  private float xpos, ypos, width, height, speed;

  public Hero(float x, float y, float s, float w, float h) {
    xpos = x;
    ypos = y;
    width = w;
    height = h;
    speed = s;
  }

  // Change this method name to draw for consistency with the Enemy class
  public void draw() {
    // Key press functionality has been moved to the `move` method for consistency 
    // with the Enemy class.
    rect(xpos, ypos, WIDTH, HEIGHT);
  }

  // This method uses the variables key, keyCoded, UP, DOWN, LEFT, and RIGHT.  You 
  // did not include any import statements with your code, so they may be coming 
  // from there; however, if they are globals, you should pass them to this method 
  // as arguments whenever you call it.
  public void move() {
    // If this condition isn't satisfied, return immediately.  This prevents 
    // unnecessary nesting and work below.
    if (key != CODED) {
      return;
    }

    if (keyCode == UP) {
      ypos -= speed;
    }
    // Use `else if` here and below to prevent multiple unnecessary 
    // comparisons of keyCode.
    else if (keyCode == DOWN) {
      ypos += speed;
    }
    else if (keyCode == LEFT) {
      xpos -= speed;
    }
    else if (keyCode == RIGHT) {
      xpos += speed;
    }
  }

  public boolean isColliding(Enemy enemy) {
     // Collision detection is easy since all of your game entities (the hero and 
     // the enemies) are all rectangles and axis-aligned (not rotated). You can 
     // use a method known as "bounding box intersection."

     return (Math.abs(enemy.getX() - xpos) * 2 < (enemy.getWidth() + width))
       && (Math.abs(enemy.getY() - ypos) * 2 < (enemy.getHeight() + height));
  }
}

For more on bounding box intersection, see this gamedev stackexchange question.

Now that your classes are in order, its time to address your main code. We'll need to update the method names and, as @James T suggested, you should make a list of enemies instead of creating a new independent object for each enemy. This will make it easier for you to add or remove enemies in the future and to be able to process all enemies with one block of code without repeating yourself.

// Use constants to remove magic numbers.
private static final int SCREEN_WIDTH = 900;
private static final int SCREEN_HEIGHT = 800;

private Hero myHero = new Hero(400, 480, 30, 30, 5);
private List<Enemy> enemies = new ArrayList<Enemy>();

void setup() {
  size(SCREEN_WIDTH, SCREEN_HEIGHT);
  frameRate(30);
  smooth();

  enemies.add(new Enemy(50, 50, 100, 100, 10));
  enemies.add(new Enemy(50, 350, 100, 100, 15));
  enemies.add(new Enemy(50, 650, 100, 100, 12));
}

void draw() {
  hasCollision = false;

  background(0);

  // I've changed the order of draw->move to move->draw.  If you draw first, then 
  // move, then detect collisions, it will appear to your user that your hero has 
  // not yet collided with an enemy even though you act as they have (e.g.: they 
  // will not see the collision until the next time you draw the scene).
  myHero.move();
  myHero.draw();

  for (Enemy enemy : enemies) {
    enemy.move();
    enemy.draw(SCREEN_WIDTH);

    if (!hasCollision &&  myHero.isColliding(enemy)) {
      hasCollision = true;
    }
  }

  if (hasCollision) {
    // Handle enemy collision here
  }
}

You'll notice that I've also added accessibility modifiers to everything. While it is technically valid to exclude them and use the defaults, it makes your code more readable to include them because it is more obvious. When you're first starting out, the more obvious the better.

Answer 3

I believe the question you are asking involves basic collision detection and object interactions.

I would first make the Enemies a List and create it / add elements during the setup() call:

List<Enemies> enemies = new List<Enemies>();
enemies.add(new Enemies(50,50,10));

This allows you to store all of your Enemies under one object. So your draw() method would look something like:

void draw(){
    background(0);
    myHero.keyPressed();

    for(Enemies enemy : enemies)
    {
        enemy.enemyDisplay();
        enemy.enemyMove();

        if (hero.isCollidingWith(enemy)) // collision method defined in the hero object, but you could define it in the Enemies class as well, it doesn't really matter
        {
            hero.removeHealth(); // method defined in hero that removes health
        }
    }
}

This method would be in one of your classes:

public boolean isColliding(Enemies enemy)
{
  // check the x and y coordinates of each object

}

I hope this helps to point you in the right direction.

Answer 4

It seems the first part you need help with is collision detection. The short answer I would give that will almost undoubtedly lead you to more questions is to look at the Area class (specifically Area.intersect). You might also want to look at the classes I've put together for displaying & managing areas in this project here

Answer 5

you need to figure out collision detection and when your objects collide with each other, something basic like:

class Enemy 
{
//...
public boolean isColliding(Hero hero)
{
  //figure out the distance between two objects, if its less than their size, they are colliding..
  //...
}
//...
}

then you need a part of your Game Loop that checks if anything is colliding with your hero, pickups, walls, etc...