How would one go about creating an array of a float inside of a array of a class? For example, say I have a class called Module[1...50], how could I create two types of variables like  ModuleX[1...50] and ModuleY[1...50] ?

Basically I need to store the X and Y values of the center point of a class Module[1...50] so that another class, Enemy, can check for collision detection with any given Module.

How the old games of yore did collision detection was the use of a bounding box and checking all moving objects if the bounding box had a collision. There's also the other method, for 2D, which is you project the movement and see if any of the lines have intersected. 

Sorry, perhaps I should rephrase my question. Basically I have two classes in arrays, Shot[50] and Enemy[50]. When a Shot class hits an Enemy class, both of them need to detect the collision, but only the two colliding need to detect the collision, not every Shot and Enemy in the array. I need globolized variables for Shot x y and Enemy x y so that on contact, not every class in the array reads collision detection, correct?

Quark, it looks very much like your code will do exactly what I need. I'll try experimenting with it, thanks!

You could look at 'e' and 'f' as placeholder variables - but in this context they are called parameters.

So in the Friend class we have the method

1.   boolean collision(Enemy e) {
2.     if ((x - e.x)*(x - e.x) + (y - e.y)*(y - e.y) < d)
3.       return true;
4.     else
5.       return false;
6.   }

This method is used to detect if this Friend is close to e, which can be any object of type Enemy.

SO in the main code we have the collision detection double loop

1.   for (int i = 0; i < friends.length; i++) {
2.     println("Friend " + friends[i].id);
3.     for (int j = 0; j < enemies.length; j++) {
4.       if (friends[i].collision(enemies[j])) {
5.         println("   Enemy " + enemies[j].id);
6.       }
7.     }
8.   }

In this line we are saying
for the friend object at index i (in friends) call its collision method passing the enemy object at index j (in enemies)

If you look at the values of i and j as the double loop progresses you get

i                  j
0                  0
0                  1
0                  2
0                  3
...                ...
0                  enemies.length -1
1                  0
1                  0
1                  0
...                ...

So by the time the double loop is finished every friend has been tested against every enemy.

Notice that

• the code inside the Friend class has no attributes/fields that identify any other Friend objects   and  
• the code inside the Enemy class has no attributes/fields that identify any other Enemy objects

This is the way it should be when using OO i.e. classes and objects  

HTH

A Bullet class basic template:

class Bullet {
  static final int DIM = 4;
  int x, y;

  Bullet(int xx, int yy) {
    x = xx;
    y = yy;
  }

  void display() {
    ellipse(x, y, DIM, DIM);
  }

  boolean hasCollided_A(Enemy e) {  // for squared Enemy forms
    return x > e.x & x < e.x + e.w & y > e.y & y < e.y + e.h;
  }

  boolean hasCollided_B(Enemy e) {  // for elliptical Enemy forms
    return sq(x - e.x) + sq(y - e.y) < sq(e.radius);
  }
}

And a more complex online example:
http://studio.processingtogether.com/sp/pad/export/ro.91kLmk61vAOZp/latest

An online example similar to quarks': 
http://studio.processingtogether.com/sp/pad/export/ro.9s0026dE7B8v-/latest

Pay attention to function connectPoints(), which is called from the for loop update within draw().