制作复式矩阵

Question

I'm trying to implement a class to check if two game objects intersect. Can anyone give me a better solution / more elegant to this problem?

Basically I want to addCollision and know if one object collidesWith another. A double entry matrix seemed a good idea.

    private class CollisionMatrix {

    private boolean[][] matrix;
    private HashMap<Tag, Integer> matrixIndexes = new HashMap<Tag, Integer>();

    public CollisionMatrix() {
        int i = 0;
        for (Tag tag : Tag.values())
            matrixIndexes.put(tag, i++);
        matrix = new boolean[i][i];
    }

    private void addCollision(Tag tag1, Tag tag2) {
        int p1 = matrixIndexes.get(tag1);
        int p2 = matrixIndexes.get(tag2);
        matrix[p1][p2] = true;
        matrix[p2][p1] = true;
    }

    private boolean collidesWith(Tag tag1, Tag tag2) {
        int p1 = matrixIndexes.get(tag1);
        int p2 = matrixIndexes.get(tag2);
        return matrix[p1][p2] || matrix[p2][p1];
    }

}

Answer 1

This is not a complete answer, but it should set you on a path to get a more complete solution.

The simplest (not efficient) way to do this is to have a list of the objects that can collide with each other and then for every frame in time, got through every object in the list and check if the object collides (Shares the same space or bounding volume) with another one in the list.

pseudo code:

L: list of objects that can potentially collide.
t: time

for each frame in t {
    for each object obj in L {
        P: list of objects without obj
        for each object otherObj in P {
             does obj collide with otherObj
        }
    }
}

While this technically works, it's not a good solution as it will be very slow as soon as you start having many objects, and it doesn't take that many to make it slow.

To make this possible in real time, you would need to add some acceleration techniques. One of these acceleration techniques is using "Bounding volume hierarchy" or BVH. https://en.wikipedia.org/wiki/Bounding_volume_hierarchy

In a nutshell, BVH is technique or algorithm to enable quick lookups of which objects are likely to collide.

It typically uses some type of tree structure to keep track of the positions and volumes occupied by the said objects. Tree structures provide faster lookup times than just linearly iterating a list multiple times.

Each level of the tree provides a hierarchy of bounding volumes (space the object is likely to occupy). Top levels of the tree provide a bigger volume for the particular object (a more rough, less granular or less fitting to the object's shape), but easier to discard if the object in question is not in that same space (you would know with little calculations that the object would never collide with anything in that same bounding volume). The deeper in the tree you go, the more granular or more fitting to the objects shape the bounding volumes get, until you get the objects which collide.

Hope this helps :)